Desafío :

Compruebe si el número dado forma un number staircaseo no

Entrada:

Un entero (mayor que 0 y no decimal). NOTA: Puede tomar la entrada como cadena, matriz de dígitos.

Salida:

un valor verdadero / falso dependiendo de si el número forma una escalera o no

Escalera de número:

Una escalera numérica es un número entero que, cuando se lee de izquierda a derecha:

• Empieza con 1
• que puede ser seguido por 2
• que puede ser seguido por 3
• y así hasta n
• entonces el número desciende comenzando en n - 1
• entonces n - 2
• entonces n - 3
• y así hasta que llegue a 1

Nota :

El puede ser parte se utiliza para indicar que si la longitud> es mayor que 1. Si se trata de la orden debe respetarse como es. es decir: 12321

Ejemplo:

12321                          ---> true
12345654321                    ---> true
9                              ---> false
1                              ---> true
2                              ---> false
123421                         ---> false
112312318901323                ---> false
123456789101110987654321       ---> true

Nota :

La entrada dada siempre será un número entero mayor que 0 y no será un decimal. Su salida debe ser un truthy or falsyvalor dependiendo de la entrada

Restricciones:

Este es el código de golf, por lo que gana el código más corto en bytes (para cada lenguaje de programación).

R , 97 bytes

function(n)"if"(n>1,{while({T=T+1;x=paste(c(1:T,T:2-1),collapse="");nchar(x)<nchar(n)})0;x==n},T)

Pruébalo en línea!

Toma ncomo una charactero una integer; el uso characterdará resultados correctos para enteros que no se pueden mantener con precisión como 64 bits double.

Genera números de escalera hasta que encuentra uno al menos el tiempo que nsea, luego prueba la igualdad.

Equivalente a:

function(n)
    if(n > 1){
        T <- T + 1
        x <- paste(c(1:T,T:2-1),collapse="")
        while(nchar(x) < nchar(n)){
            T <- T + 1
            x <- paste(c(1:T,T:2-1),collapse="")
        }
        return(x == n)
    } else
        return(TRUE)

Jalea , 5 bytes

ŒḄ€Vċ

Pruébalo en línea!

Advertencia: muy lento (rápido para 1y 121)! Prepárate DLpara hacerlo más rápido.

JavaScript (ES6), 62 57 bytes

Guardado 2 bytes gracias a @ l4m2

Devuelve un booleano.

f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k

Pruébalo en línea!

¿Cómo?

Comenzando con k = 1 , buscamos k al principio y al final de la cadena, e iteramos recursivamente el proceso en la subcadena central restante con k + 1 . La recursión se detiene tan pronto como ya no hay coincidencia. La entrada es un número de escalera si la última subcadena es igual a k .

Ejemplo para s = "1234321":

 k | s         | match     | s == k 
---+-----------+-----------+--------
 1 | "1234321" | 1(23432)1 | no     
 2 | "2343"    | 2(343)2   | no     
 3 | "343"     | 3(4)3     | no     
 4 | "4"       | null      | yes    

Haskell , 55 54 bytes

_{-1 byte gracias a Laikoni !}

f x=elem x[read$[1..z]++[z-1,z-2..1]>>=show|z<-[1..x]]

Pruébalo en línea!

Pyth, 13 12 bytes

/mjk+Sd_Stdl

Guardado un byte gracias a RK.
Pruébalo aquí

Explicación

/mjk+Sd_Stdl
 m         lQ   For each d up to the length of the (implicit) input...
    +Sd_Std     ... get the list [1, 2, ..., d, d-1, ..., 1]...
  jk            ... concatenated.
/               Count how many times the input appears.

Si realmente desea la entrada como un entero, puede usarla }Qmsjk+Sd_Stden su lugar, pero esto es horriblemente lento.

Python 2 , 69 bytes

f=lambda s,n=1,t='1',u='':t+':'>s>t<s*f(s,n+1,t+`n+1`,`n`+u)or s==t+u

Pruébalo en línea!

C # (Visual C # interactivo Compilador) , 138 107 102 bytes

bool t(List<int>s)=>s.Select((j,i)=>s[0]==1&&s.Last()==1&&(i==0||j+1==s[i-1]||j-1==s[i-1])).All(x=>x);

Pruébalo en línea!

Explicación:

bool t(List<int>s)=>
    s.Select((j,i) =>         //iterate over each item and store the return value
        s[0]==1&&s.Last()==1  //does the sequence start and end with 1?
        &&                    //AND
        (i==0                 //is it the first item?
        ||                    //OR
        j+1==s[i-1]           //is the item 1 greater than the previous?
        ||                    //OR
        j-1==s[i-1])          //is the item 1 smaller than the previous?
    ).All(x=>x);              //did all pass the criteria?

05AB1E , 9 8 bytes

L€L€ûJså

Advertencia: ¡EXTREMADAMENTE LENTO! Agregue gal inicio para acelerarlo.

Pruébalo en línea!

Explicación:

L           1..input
 €L         for each element, map to 1..element 
   €û       palindromize each element
     J      join each element from a list to a string
      så    is the input in that list?

Vieja explicación:

F           For [0 .. input] map over
 NL          Push 1..i
   û         Palindromize
    J        Join
     ¹       First input
      Q      Equal?
       }   end loop
        O  Sum.

Pruébalo en línea!

Python 2 , 77 bytes

lambda s,r=range:s in[''.join(map(str,r(1,k+2)+r(k,0,-1)))for k in r(len(s))]

Pruébalo en línea!

Stax , 14 bytes

Ç╗☻W╧ΩÆΘαφ←≤─♣

Ejecutar y depurarlo

Muy lento para números más grandes.

agregado , 57 55 46 bytes

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}

Pruébalo en línea! Ah, eso es mucho más elegante.

Con Generate(49 bytes):

{g@Generate[{g@_>=#_2}&_]=_}g:=N@Join@Bounce@1&`:

Explicación

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}
{                                            }   anonymous lambda, argument: _
 GenerateFirst[                  ,        ]      find the first element satisfying...
               N@Join@Bounce@1&`:                    this generation function
                                  `>=:`#&_           and this condition
                                           =_    is it equal to the input?

La función de generación simplemente crea el N número de escalera. Entonces, esta búsqueda termina una vez que `>=:`#&_está satisfecha. Ampliado, esto es:

 `>=:`#&_
 (`>= : `#) & _      NB. remember _ is the input
                     NB. also, f:g is f[...Map[g, args]]
 { #_1 >= #_2 } & _
 { Size[_1] >= Size[_2] } & _
 { Size[_1] >= Size[the original input] }
 [n] -> { Size[n] >= Size[input] }

Entonces, esto termina una vez que la longitud de la salida de la función de generación es al menos la de las entradas. Por lo tanto, esto genera el número de escalera más pequeño al menos tan largo como el número de entrada. Por lo tanto, si la entrada es un número de escalera, el resultado será el mismo número de escalera y, de lo contrario, el siguiente número de escalera más largo. Como tal, un simple chequeo con igualdad a la entrada original es suficiente para determinar si era o no un número de escalera.

Adjunto, 55 bytes

0&{If[#_2>#g[_],$[_+1,_2],_2=g!_]}g:=N@Join@Bounce@1&`:

Pruébalo en línea! Con plan de recursión.

J , 40 bytes

1#.[:(<-:"_1<@([:;>:<@":@-|@i:)@<:@#\)":

Pruébalo en línea!

No estoy muy contento con esta solución, mucho @y boxeo <.

SNOBOL4 (CSNOBOL4) , 109 bytes

	N =INPUT
	X =L ='1'
C	R =LT(SIZE(L R),SIZE(N)) X R	:F(O)
	X =X + 1
	L =L X	:(C)
O	OUTPUT =IDENT(L R,N) 1
END

Pruébalo en línea!

Curiosamente, reemplazar '1'en la segunda línea 1hace que el programa falle en la entrada de 1.

K , 36 bytes

{|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}

Toma una cadena como "12321" como parámetro.

Esta función está escrita como una larga cadena de aplicaciones de funciones, como en f g h x, así que lea las versiones comentadas desde abajo, hacia arriba. {x+1}es decir lambda x: x+1, x es un nombre de parámetro predeterminado. Echa un vistazo a https://pastebin.com/cRwXJn7Z o la ayuda del intérprete para conocer los significados del operador.

Generamos el número de escalera con nen el medio por {,/$(1+!x),1+1_|!x}:

{,/                      / join all the chars
   $                     / tostring each number
     (1+!x)              / take the range [0..x-1]; add 1 to each
            ,            / concat
             (1+1_|!x)}  / take the range [0..x-1]; reverse it; drop 1; add 1 to each

Toda la función {|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}:

{|/                                   / any_is_true
   ($x)~/:                            / match the string with each of the generated staircases
          {,/$(1+!x),1+1_|!x}'        / make staircase number of each of the numbers
                                      / (note: the x in the inner lambda shadows the outer x)
                              1+!#x}  / take the range [1..length of the string, inclusive]

Haskell , 64 60 58 bytes

^{-6 gracias a @BMO!}

elem.show<*>(`take`[[1..n]++[n-1,n-2..1]>>=show|n<-[1..]])

Pruébalo en línea!

Perl 5 -lp , 49 bytes

$i++while s/^$i//;$i-=2;$i--while s/^$i//;$_||=$i

Pruébalo en línea!

0 = verdad, cualquier otra cosa = falsedad

Java 10, 142 bytes

s->{int n=1,l,f=1;try{for(;;s=s.substring(l=(n+++"").length(),s.length()-l))if(!s.matches(n+".*"+n)&!s.equals(n+""))f=0;}finally{return f>0;}}

Pruébalo en línea.

Explicación:

s->{                 // Method with String parameter and boolean return-type
  int n=1,           //  Stair integer, starting at 1
      l,             //  Length integer to reduce bytes
      f=1;           //  Result-flag, starting at 1
  try{for(;;         //  Loop until an error occurs
          s=s.substring(l=(n+++"").length(),s.length()-l))
                     //    After every iteration: remove `n` from the sides of the String
        if(!s.matches(n+".*"+n)
                     //   If the current String with the current `n` isn't a stair
           &!s.equals(n+""))
                     //   And they are also not equal (for the middle)
          f=0;       //    Set the flag to 0
   }finally{         //  After the error (StringOutOfBoundsException) occurred:
      return f>0;}}  //   Return whether the flag is still 1

Japt, 11 bytes

Toma la entrada como una cadena.

Êõõ mê m¬øU

Intentalo

Explicación

                :Implicit input of string U
Ê               :Length of U
 õ              :Range [1,Ê]
  õ             :Range [1,el] for each element
    mê          :Map & palidromise
       m¬       :Map & join
         øU     :Contains U?

Alternativa, 10 9 bytes

Esta solución, que puede tomar la entrada como una cadena o un entero, devolverá una serie de números para la verdad o, eventualmente, arrojará un error para falsey, si no paraliza su navegador antes de eso. Usar con precaución.

@¥Xê q}aõ

Intentalo

Retina , 45 43 bytes

$
;1
+`^(.+)(.*)\1;\1$
$2;$.(_$1*
^(.+);\1$

Pruébalo en línea! El enlace incluye casos de prueba. Editar: Guardado 2 bytes gracias a @Leo. Explicación:

$
;1

Inicializar na 1.

+`^(.+)(.*)\1;\1$

Mientras scomienza y termina con n:

$2;$.(_$1*

Eliminar nde los extremos de se incrementar n.

^(.+);\1$

Prueba si nqueda.

Regex (PCRE) , 92 bytes

^(1|\d(?=1|9)|[2-79](?=8)|[2-68](?=7)|[2-57](?=6)|[2346](?=5)|[235](?=4)|[24](?=3)|3(?=2))+$

Pruébalo en línea!

Estoy abierto a cualquier sugerencia para mejorar esto.

Gracias a los siguientes usuarios:

@Nooneishere
@LyricLy
@JoKing

Python 2 , 147 bytes

g=s=input()
f=1
o='1'==s[0]
while`f`==s[0]:s=s[len(`f`):];f+=1
f-=2
o&=`f`==s[0]
while s and`f`==s[0]:s=s[len(`f`):];f-=1
o&=f==0
o|=g=='1'
print o

Pruébalo en línea!