Un número de colina es un número que tiene el mismo dígito en el primero y el último , pero eso no es todo. En un número de colina, los primeros dígitos están aumentando estrictamente y los últimos dígitos están disminuyendo estrictamente. El dígito más grande se puede repetir .

Aquí hay un ejemplo de un número de colina:

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

Esto no es :

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

Desafío

Dado un número entero positivo, escriba un programa completo o una función que devuelva verdad para los números de colina pero falsa en otros valores.

Notas:

• La entrada y salida pueden estar en cualquier formato razonable .
• Este es el código de golf, por lo que la respuesta más corta en cada idioma gana.

Casos de prueba

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

Jalea , 8 bytes

_ƝṠÞ+SƊƑ

Pruébalo en línea!

Cómo funciona

_ƝṠÞ+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 bytes

Toma la entrada como una cadena. Devuelve un valor booleano.

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

Pruébalo en línea!

Comentado

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 bytes

Una solución usando una expresión regular. Toma la entrada como una cadena. Devuelve $0$ o $1$ .

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

Pruébalo en línea!

¿Cómo?

Primero convertimos el número a una lista de diferencias de dígitos por pares en $[-9,9]$ :

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

Ejemplo:

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

Esta matriz se coacciona a una cadena, lo que da:

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

Aplicamos la siguiente expresión regular:

 +-----------------------> 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-]*$/

Finalmente, también probamos si el último dígito pes igual al primer dígito s[0].

Pyth, 16 bytes

&SI_._MJ.+jQT!sJ

Prueba el conjunto de pruebas .

          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.

Jalea , 11 bytes

DIµṠNṢƑaS¬$

Explicación:

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.

Pruébalo en línea!

Perl 6 , 39 bytes

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

Pruébalo en línea!

Explicación

{ ... }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 bytes

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]))

Pruébalo en línea!

R , 65 bytes

Toma cuerdas. Tomó la idea de verificar la invariancia de clasificación de la respuesta Pyth.

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

Pruébalo en línea!

05AB1E , 19 17 13 12 bytes

¥D.±Â{RQsO_*

-5 bytes mediante la creación de un puerto de @lirtosiast respuesta Pyth 's .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

¥           # 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)

Â{RQalternativamente puede ser (Â{Qpara el mismo número de bytes, donde (niega cada signo: Pruébelo en línea .

J, 23 bytes

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

Idea robada de las respuestas de Jelly. Solo quería ver cuán corto podría hacerlo en J.

Pruébalo en línea!

MATL , 12 bytes

dZSd1<AGds~*

Pruébalo en línea!

Explicación

La entrada es una cadena de dígitos. La salida es a 1o 0. El número 222222es un número de colina según este programa. Ahorré 2 bytes copiando el método de Dennis para verificar la igualdad del primer y último dígito.

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 bytes

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

Toma la entrada como una cadena. La salida es por presencia o ausencia de una excepción .

Pruébalo en línea!

Python 2 , 62 bytes

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

Toma la entrada como una cadena y devuelve un booleano.

Pruébalo en línea!

Lenguaje Mathematica / Wolfram, 69 64 bytes

Pura función. Toma la entrada como un entero, devuelve Trueo False.

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

Explicación:

La primera cláusula verifica la "colina":

• IntegerDigits: Obtener dígitos del número entero. Almacenar en y.
• -Differences: Tome las diferencias sucesivas y los carteles.
• Sign: Reemplace cada entrada con +1 si es positivo, 0 si es cero y -1 si es negativo. Almacenar en x.
• Sort: Ordena la lista de +1, 0, -1 de menor a mayor. Comparar con la lista original en x.

La segunda cláusula verifica si el primer y el último dígito son iguales.

Un consejo para @IanMiller para consejos sobre cómo refinar este código.

Japt, 11 bytes

Toma la entrada como una matriz de dígitos.

ä-
eUñg)«Ux

Pruébalo o ejecuta todos los casos de prueba

             :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 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

.
$*1;$&$*1,

Convierta cada dígito a unario dos veces, separado por ;sy terminado por ,s. Sin embargo, puede pensar en el resultado como el primer dígito, a ;, luego todos los pares de dígitos adyacentes, los dígitos de cada par separados por, y los pares separados por ;s, luego otro ;, luego el último dígito, luego un final ,.

(1+),\1
,

Resta los pares de dígitos adyacentes. Esto deja ;,;dígitos iguales y 1s en el lado mayor para dígitos desiguales. (Esto podría hacerse como parte de la siguiente expresión regular, pero obviamente eso no sería tan complejo).

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

Haga coincidir el primer dígito, luego cualquier número de pares de dígitos ascendentes, luego cualquier número de pares de dígitos iguales, luego cualquier número de pares de dígitos descendentes, luego haga coincidir el primer dígito nuevamente al final.

Rojo , 181 bytes

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)]

Pruébalo en línea!

Más legible:

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 bytes

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

Menos guión de prueba de 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"
}

Salida:

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

C # (compilador interactivo de Visual C #) , 161 bytes

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]);}

Pruébalo en línea!

Aquí hay una descripción general de cómo funciona esto ...

1. La entrada tiene la forma de un string
2. Encuentra el dígito más grande
3. Asegúrese de que el primer y el último dígito sean iguales
4. Asegúrese de que los dígitos después de la última aparición del dígito más grande estén disminuyendo
5. Asegúrese de que los dígitos entre la primera y la última aparición del dígito más grande sean iguales al dígito más grande
6. Asegúrese de que los dígitos antes de la primera aparición del dígito más grande estén aumentando

Python 3 , 114 bytes

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]

Pruébalo en línea!

Mucho más que algunas soluciones de Python 2, pero esta está basada en def y me gusta.

Ruby , 47 bytes

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

Pruébalo en línea!

Entrada como matriz de dígitos, la salida es booleana.