¿Es este un número de escalera?


15

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 por lo que gana el código más corto en bytes (para cada lenguaje de programación).



2
¿Podemos tomar la entrada como una lista de dígitos? Me gusta [1,2,3,4,5,6,7,8,9,1,0,1,1,1,0,9,8,7,6,5,4,3,2,1]para 123456789101110987654321?
Sr. Xcoder

@ Mr.Xcoder: Preferiría que no lo hicieras, pero supongo que puedes
Muhammad Salman

¿Hay un límite superior en la entrada?
mypetlion

@mypetlion: No realmente, es tan alto como su código puede soportar (excluyendo los codificados y los intencionalmente bajos). Normalmente, el más alto que su idioma puede soportar (pero no en este caso)
Muhammad Salman

¿Podemos tomar una cadena de caracteres como entrada para una función? (¿o es esto solo una entrada aceptable para un programa completo?)
Jonathan Allan

Respuestas:


5

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)


¿No se reemplazaría function(n)por n=scan();más corto? (para enteros, por supuesto)
pajonk

@pajonk supongo que sí. Pero diré que lo estoy tomando como una cadena, por lo que esta respuesta es correcta para entradas más grandes.
Giuseppe


3

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    

55 bytes . Asumir 0 como verdadero y nulo como falso (no especificó exactamente si lo hizo)

Hum, no vi esa suposición que no es válida. Lo sentimos

@ I'mnoone ¡No te preocupes! Curiosamente, la eliminación en su m[0]==s&lugar lo haría pasar todos los casos de prueba (pero aún fallaría en otros como "123217").
Arnauld

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


2

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.


puede usar en /lugar de hacerlo }Qpara que se complete automáticamente Qal final
RK.


2

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?

En realidad, el Zip...Skipmétodo en mi comentario anterior falla [1,1], lo que debería volver truesi entiendo la especificación. Lo he eliminado
benj2240

¡Gracias de cualquier manera! Nunca he utilizado Zip antes, pero ahora veo cómo puede ser útil.
Kahzaar

1

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!


¿Palindromizar? ¿Qué hace esto? Porque, como sabrán, las escaleras con más de 10 no son palíndromos
Yassin Hajaj

@YassinHajaj Palindromises la matriz, no la cadena
Okx

Muy

@YassinHajaj gLη€ûJsåes otro, donde puedes ver la vectorización de la palindromización usando €ûpalindromizar cada una.
Urna mágica de pulpo

@okx gLη€ûJsåpara un 8-byte que no explota TIO.
Urna mágica de pulpo

1

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!


Ahorre cuatro al aceptar un número entero si podemos cometer un error una vez que lleguemos a longs: TIO . ¡Necesitaríamos bastante tiempo y memoria para ese punto de todos modos!
Jonathan Allan


1

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.



1

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.


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]

0

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!


Teóricamente funciona para 12345678910987654321, si eres capaz de construir una lista con tantos elementos.
Esolanging Fruit

@ BMO Sabía que tenía que haber una manera de hacerlo. Gracias
Esolanging Fruit

@BMO Tu golf es realmente obvio en retrospectiva ...
Esolanging Fruit

También está muy cerca, lo habría sugerido como una mejora si no lo hubiera publicado (no vi el suyo hasta que publiqué el mío).
ბიმო


0

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

0

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


0

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.


Creo que sus \ds pueden llegar a ser .y AHORRARLE dos bytes
Leo


-1

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!


La salida no tiene que ser las cadenas truey los falsevalores verdaderos y falsos. 1y 0funcionaría por ejemplo
dylnan

@dylnan: Acabo de leer eso, gracias. Todavía golf (mucho por recorrer)

¿No podrías usar en s[0]lugar de startswith? Se permiten errores, y puede decir 'salidas 1 para escalera, cualquier otra cosa (incluso nada) [ya que se ignora stderrr] para no escalera'.
NoOneIsHere

@NoOneIsHere: buena idea. aparentemente codificar mientras duerme no es una buena idea gracias

1
Su solución de 138 bytes siempre devuelve False, ya gque nunca es 1. Probablemente debería probar estas soluciones antes de publicarlas ...
Jo King
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.