Un numéro de colline est un numéro qui a le même chiffre dans le premier et le dernier , mais ce n'est pas tout. Dans un numéro de colline, les premiers chiffres augmentent strictement et les derniers chiffres diminuent strictement. Le plus grand chiffre peut être répété .

Voici un exemple de numéro de colline:

12377731 | 1237...             | ...731
^ same ^ | strictly increasing | strictly decreasing 
---------+---------------------+---------------------
12377731
   ^^^ okay because largest digit can be repeated

Ce n'est pas :

4588774 | ...8774
        |     ^^ not the largest digit
        |        so this has to be strictly decreasing
        |        but it's not, so not a hill number

Défi

Étant donné un entier positif, écrivez un programme complet ou une fonction qui renvoie la vérité pour les nombres de collines mais la fausse sur d'autres valeurs.

Remarques:

• L'entrée et la sortie peuvent être dans n'importe quel format raisonnable .
• C'est le code-golf, donc la réponse la plus courte dans chaque langue gagne!

Cas de test

12321 -> Truthy
1233321 -> Truthy
99 -> Truthy
3 -> Truthy
234567992 -> Truthy
1232 -> Falsy
778896 -> Falsy
23232 -> Falsy
45566554 -> Falsy
5645 -> Falsy

Gelée , 8 octets

_ƝṠÞ+SƊƑ

Essayez-le en ligne!

Comment ça fonctionne

_ƝṠÞ+SƊƑ  Main link. Argument: n (integer)

_Ɲ        Take the differences of neighboring digits.
          This maps n = abcd to [a-b, b-c, c-d].
       Ƒ  Fixed; apply the link to the left and return 1 if the result is equal to
          its argument, 0 if not.
      Ɗ       Drei; combine the three links to the left into a monadic chain.
  ṠÞ              Sort the differences by their signs (negative, zero, positive).
     S            Take the sum of the differences, yielding 0 if and only if the
                  first digit is equal to the last.
    +             Add the sum to each difference.

JavaScript (ES6), 62 54 octets

Prend l'entrée sous forme de chaîne. Renvoie une valeur booléenne.

s=>s[-[...s].some(p=q=n=>q>(q=Math.sign(p-(p=n))))]==p

Essayez-le en ligne!

Commenté

s =>                  // s = input string
  s[                  // we will eventually access either s[0] or s[-1]
    -[...s].some(     // depending on the result of this some()
      p = q =         // initialize p and q to non-numeric values
      n =>            // for each digit n:
        q > (         //   compare q with
          q =         //   the new value of q,
          Math.sign(  //   defined as the sign of
          p - (p = n) //   the difference between the current digit and the previous one
        ))            //   yield true if the previous q is greater than the new q
    )                 // s[-1] being undefined, a truhty some() will force the test to fail
  ] == p              // otherwise: test if the 1st digit s[0] is equal to the last digit p

JavaScript (ES6), 65 octets

$0$$1$

s=>/N(,-\d+)*(,0)*[^0-]*$/.test([...s].map(p=v=>p-(p=v)))&p==s[0]

Essayez-le en ligne!

Comment?

$[-9,9]$

[...s].map(p = v => p - (p = v))

Exemple:

"234567992" --> [ NaN, -1, -1, -1, -1, -1, -2, 0, 7 ]

Ce tableau est contraint à une chaîne, ce qui donne:

"NaN,-1,-1,-1,-1,-1,-2,0,7"

Nous appliquons l'expression régulière suivante:

 +-----------------------> the second 'N' of 'NaN'
 |    +------------------> a sequence of negative numbers
 |    |     +------------> a sequence of zeros
 |    |     |     +------> a sequence of positive numbers
 |    |     |     |  +---> end of string
 |    |     |     |  |
 |/¨¨¨¨¨¨\/¨¨¨\/¨¨¨¨\|
/N(,-\d+)*(,0)*[^0-]*$/

Enfin, nous testons également si le dernier chiffre pest égal au premier chiffre s[0].

Pyth, 16 octets

&SI_._MJ.+jQT!sJ

Essayez la suite de tests .

          jQT          input in base 10
       J.+             J = differences: [3,1,4,1] -> [-2,3,-3]
    ._M                Signs of each element of J
   _                   Reverse the list
 SI                    and check if it is Invariant under Sorting.
                       If this is true, J consists of some positive numbers,
                         followed by some 0s, followed by some negative numbers,
                         which is what we want.
            !sJ        Now we check the other hill condition by ensuring
                         sum(differences) = 0; i.e. the first and last digit are equal.
&                      We take the logical AND of both conditions.

Gelée , 11 octets

DIµṠNṢƑaS¬$

Explication:

D               Convert to a list of Digits.
 I              Increments; compute differences between successive elements.
  µ             Start new µonadic link.
   Ṡ              Find Ṡign of each increment
    N             then negate;
     ṢƑ           is the result invariant under Ṣorting?
                  If so, the increments consist of some positive numbers,
                     followed by some 0s, followed by some negative numbers,
                     which is what we want.
       a          Logical AND this result with
        S¬$       logical NOT of the Sum of the increments.
                  If the sum of the increments is zero, first and last digits are equal.

Essayez-le en ligne!

Perl 6 , 39 octets

{.[0]==.tail&&[<=] $_ Z<=>.skip}o*.comb

Essayez-le en ligne!

Explication

{ ... }o.comb  # Split into digits and feed into block
.[0]==.tail    # First element equals last
&&             # and
     $_ Z<=>.skip  # Pairwise application of three-way comparator
[<=]           # Results never decrease

Python 2 , 114 112 octets

lambda n:all((n[0]==n[-1])*sorted(set(x))==list(x)[::d]for x,d in zip(n.split(max(n)*n.count(max(n)),1),[1,-1]))

Essayez-le en ligne!

R , 65 octets

Prend des cordes. A pris l'idée de vérifier l'invariance de tri de la réponse Pyth.

function(a)!sum(d<-diff(utf8ToInt(a)))&all(sort(k<-sign(d),T)==k)

Essayez-le en ligne!

05AB1E , 19 17 13 12 octets

¥D.±Â{RQsO_*

-5 octets en créant un port de @lirtosiast réponse Pyth de .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

¥           # Push the deltas of the digits of the (implicit) input
            #  i.e. 4588774 → [1,3,0,-1,0,-3]
 D          # Duplicate this list
  .±        # Get the sign of each
            #  [1,3,0,-1,0,-3] → [1,1,0,-1,0,-1]
    Â       # Bifurcate (short for DR: Duplicate and Reverse copy)
            #  i.e. [1,1,0,-1,0,-1] → [-1,0,-1,0,1,1]
     {      # Sort the copy
            #  i.e. [-1,0,-1,0,1,1] → [-1,-1,0,0,1,1]
      R     # Reverse it
            #  i.e. [1,1,0,0,-1,-1]
       Q    # And check if they are equal
            #  i.e. [1,1,0,-1,0,-1] and [1,1,0,0,-1,-1] → 0 (falsey)
s           # Swap to get the list of deltas again
 O          # Take the sum
            #  i.e. [1,3,0,-1,0,-3] → 0
  _         # And check if it's exactly 0
            #  0 → 1 (truthy)
*           # Check if both are truthy (and output implicitly)
            #  i.e. 0 and 1 → 0 (falsey)

Â{RQpeut également être (Â{Qpour le même nombre d'octets, où (annule chaque signe: essayez-le en ligne .

J, 23 octets

[:((0=+/)**-:*/:*)2-/\]

L'idée volée aux réponses de Jelly. Je voulais juste voir à quel point je pouvais le faire en J.

Essayez-le en ligne!

MATL , 12 octets

dZSd1<AGds~*

Essayez-le en ligne!

Explication

L'entrée est une chaîne de chiffres. La sortie est un 1ou 0. Le numéro 222222est un numéro de colline selon ce programme. Enregistrement de 2 octets en copiant la méthode de Dennis pour vérifier l'égalité des premier et dernier chiffres.

d               % Takes the difference between digits
 ZS             % Calculate the sign. 
   d            % Take the difference again. 
    1<          % A number is a hill number if these differences are < 1.
      A         % Truthy iff above is all true OR if array is empty (necessary for short inputs)
       Gds      % Push the input, and sum all the differences.
          ~     % Negate
           *    % Multiply the two tests (=logical AND).

Python 2 , 53 octets

def f(s):x=map(cmp,s,s[1:]);s[:sorted(x)==x]!=s[-1]>_

Prend l'entrée sous forme de chaîne. La sortie se fait via la présence ou l'absence d'une exception .

Essayez-le en ligne!

Python 2 , 62 octets

lambda s:s[:eval('<='.join(map(str,map(cmp,s,s[1:]))))]==s[-1]

Prend l'entrée sous forme de chaîne et renvoie un booléen.

Essayez-le en ligne!

Langage Mathematica / Wolfram, 69 64 octets

Fonction pure. Prend l'entrée comme un entier, retourne Trueou False.

Sort[x=Sign@-Differences[y=IntegerDigits@#]]==x&&y[[1]]==Last@y&

Explication:

La première clause vérifie le "relief":

• IntegerDigits: Récupère les chiffres d'un entier. Conserver dans y.
• -Differences: Prenez les différences successives et les flip signs.
• Sign: Remplacez chaque entrée par +1 si positif, 0 si zéro et -1 si négatif. Conserver dans x.
• Sort: Trier la liste de +1, 0, -1 du plus petit au plus grand. Comparer à la liste d'origine dans x.

La deuxième clause vérifie si les premier et dernier chiffres sont égaux.

Un coup de chapeau à @IanMiller pour obtenir des conseils sur l'amélioration de ce code.

Japt, 11 octets

Prend l'entrée comme un tableau de chiffres.

ä-
eUñg)«Ux

Essayez-le ou exécutez tous les cas de test

             :Implicit input of digit array U
ä-           :Deltas
\n           :Reassign to U
 Uñ          :Sort U
   g         :  By signs
e   )        :Check for equality with U
     «       :Logical AND with the negation of
      Ux     :U reduced by addition

Retina 0.8.2 , 52 octets

.
$*1;$&$*1,
(1+),\1
,
^(1+);(,1+;)*(,;)*(1+,;)*\1,$

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

.
$*1;$&$*1,

Convertissez chaque chiffre en unaire deux fois, séparé par ;s et terminé par ,s. Cependant, vous pouvez alors considérer le résultat comme le premier chiffre, a ;, puis toutes les paires de chiffres adjacents, les chiffres de chaque paire séparés par ,et les paires séparées par ;s, puis un autre ;, puis le dernier chiffre, puis un final ,.

(1+),\1
,

Soustrayez les paires de chiffres adjacents. Cela laisse ;,;des chiffres égaux et 1s du côté supérieur pour des chiffres inégaux. (Cela pourrait être fait dans le cadre de l'expression rationnelle suivante, mais ce ne serait évidemment pas si golfique.)

^(1+);(,1+;)*(,;)*(1+,;)*\1,$

Faites correspondre le premier chiffre, puis n'importe quel nombre de paires de chiffres ascendants, puis n'importe quel nombre de paires de chiffres égaux, puis n'importe quel nombre de paires de chiffres descendants, puis faites correspondre à nouveau le premier chiffre à la toute fin.

Rouge , 181 octets

func[n][m: last sort copy t: s: form n
parse t[opt[copy a to m(a: sort unique a)]copy b thru any m
opt[copy c to end(c: sort/reverse unique c)]](s = rejoin[a b c])and(s/1 = last s)]

Essayez-le en ligne!

Plus lisible:

f: func[n][
    t: s: form n                                    
    m: last sort copy t                             
    parse t [ opt [ copy a to m (a: sort unique a) ] 
              copy b thru any m
              opt [ copy c to end (c: sort/reverse unique c) ]
            ]
    (s = rejoin [ a b c ]) and (s/1 = last s)
]

Powershell, 77 octets

($x=-join("$($args|%{"-$_;$_"})"|iex))-match'^(-\d)+0*\d+$'-and$x[1]-eq$x[-1]

Script de test moins golfé:

$f = {
                                           # $args = 1,2,3,3,3,2,1
$a=$args|%{"-$_;$_"}                       # "-1;1","-2;2","-3;3","-3;3","-3;3","-2;2","-1;1"
$d="$a"                                    # "-1;1 -2;2 -3;3 -3;3 -3;3 -2;2 -1;1"
$x=-join($d|Invoke-Expression)             # "-1-1-100111"
$x-match'^(-\d)+0*\d+$'-and$x[1]-eq$x[-1]  # $true or $false

}

@(
    ,($True , 1,2,3,2,1 )
    ,($True , 1,2,3,3,3,2,1 )
    ,($True , 9,9 )
    ,($True , 3 )
    ,($True , 2,3,4,5,6,7,9,9,2 )
    ,($False, 1,2,3,2 )
    ,($False, 7,7,8,8,9,6 )
    ,($False, 2,3,2,3,2 )
    ,($False, 4,5,5,6,6,5,5,4 )
    ,($False, 5,6,4,5 )
) | % {
    $expected,$a = $_
    $result = &$f @a
    "$($result-eq$expected): $result"
}

Production:

True: True
True: True
True: True
True: True
True: True
True: False
True: False
True: False
True: False
True: False

C # (Visual C # Interactive Compiler) , 161 octets

s=>{var m=s.OrderBy(c=>c).Last();return s[0]==s.Last()&Enumerable.Range(1,s.Length-1).All(i=>i>s.LastIndexOf(m)?s[i-1]>s[i]:i>s.IndexOf(m)?m==s[i]:s[i-1]<s[i]);}

Essayez-le en ligne!

Voici un aperçu de comment cela fonctionne ...

1. L'entrée se présente sous la forme d'un string
2. Trouvez le plus grand chiffre
3. Assurez-vous que les premier et dernier chiffres sont identiques
4. Assurez-vous que les chiffres après la dernière occurrence du plus grand chiffre diminuent
5. Assurez-vous que les chiffres entre la première et la dernière occurrence du plus grand chiffre sont égaux au plus grand chiffre
6. Assurez-vous que les chiffres avant la première occurrence du plus grand chiffre augmentent

Python 3 , 114 octets

def f(r):
 l=[*r]
 for i in-1,0:
  while 1<len(l)and l[i]<l[(1,-2)[i]]:l.pop(i)
 return 2>len({*l})and r[0]==r[-1]

Essayez-le en ligne!

Bien plus long que certaines solutions Python 2, mais celle-ci est basée sur la définition et j'aime ça.

Rubis , 47 octets

->n{(r=n.each_cons(2).map{|a,b|a<=>b})==r.sort}

Essayez-le en ligne!

Entrée sous forme de tableau de chiffres, la sortie est booléenne.