Un número escalera es un número entero positivo x tal que su n º dígitos (una indexadas empezando con el dígito menos significativo) es igual a x% (n + 1) . Eso es un poco bocado, así que veamos un ejemplo. Tome 7211311 , si tomamos los residuos modulares de 7211311 en el rango 2-8 obtenemos lo siguiente:

7211311 % 2 = 1
7211311 % 3 = 1
7211311 % 4 = 3
7211311 % 5 = 1
7211311 % 6 = 1
7211311 % 7 = 2
7211311 % 8 = 7

¡Estos son los dígitos de 7211311 ! Por lo tanto, 7211311 es un número de escalera.

Tarea

Escribir código que toma cuando se le da un número positivo como entrada, generará dos valores distintos, uno si el número es un número de escalera y el otro si no lo es.

Esta es una competencia de código de golf , por lo que su objetivo debe ser minimizar el número de bytes en su código fuente.

Casos de prueba

Aquí están los primeros 13 números de escalera:

1, 10, 20, 1101, 1121, 11311, 31101, 40210, 340210, 4620020, 5431101, 7211311, 12040210

Haskell, 55 57 bytes

f m|let n#x=n==0||n`mod`10==m`mod`x&&div n 10#(x+1)=m#2

Un enfoque diferente al de la otra solución de Haskell.

Gracias xnor por guardar 2 bytes.

Brachylog , 25 21 16 14 bytes

{it+₂;?↔%}ᶠ↔c?

Pruébalo en línea!

Primera presentación de Brachylog: D probablemente muy poco golfista ... muchas gracias a Leaky Nun y Fatalize por alentar y ayudar a jugar golf desde 25 hasta solo 14. :) :)

Javascript, 42 41 39 38 bytes

-4 bytes gracias a @Shaggy y @ETHProductions

s=>[...s].some(d=>s%i++^d,i=~s.length)

Esto toma el número como una cadena y devuelve falsesi el número es un número de escalera y lo truecontrario.

Fragmento de código de ejemplo:

f=
s=>[...s].some(d=>s%i++^d,i=~s.length)

function update() {
  o.innerText = f(document.getElementById("i").value)
}

<input id="i" type="number">
<button onclick="update()">Test</button>
<p id="o">

05AB1E , 6 bytes

Código:

ā>%JRQ

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

ā        # Get the range [1 .. len(input)]
 >       # Increment by 1
  %      # Vectorized modulo
   J     # Join the array into a single number
    RQ   # Reverse that number and check if it's equal to the original input

Haskell, 60 bytes

Toma el número como int

x n|s<-show n=reverse s==(rem n.(+1)<$>[1..length s]>>=show)

Mathematica, 60 bytes

FromDigits@Reverse@Mod[#,Range@Length@IntegerDigits@#+1]==#&

Pruébalo en línea!

@alephalpha lo jugó hasta 48

Mathematica, 48 bytes

FromDigits@Reverse@Mod[#,Range[2,Log10@#+2]]==#&

el siguiente es 24120020

Python 2 , 54 bytes

f=lambda n,x=0:10**x>n or(`n%(x+2)`==`n`[~x])*f(n,x+1)

Pruébalo en línea!

Japt , 9 7 bytes

Toma la entrada como una cadena.

¥£%´JÃw

Pruébalo

• 2 bytes guardados con la ayuda de ETHproductions.

Explicación

Implícitamente tomamos la cadena como entrada.

£   Ã

Mapa sobre cada carácter en la cadena.

´J

Jes la constante de Japt para -1y la ´disminuye en 1 en cada pasada ( --en JavaScript) Entonces, en el primer pase, esto nos da -2.

%

Usamos ese valor para realizar una operación de módulo en la cadena de entrada que se convierte automáticamente en un entero en el proceso. En JavaScript x%-yda el mismo resultado que x%y.

w

Invierta la cadena resultante.

¥

Compruebe si la nueva cadena es igual a la entrada original y genera el resultado como un valor booleano.

Neim , 6 bytes

𝐧ᛖ𝕄𝐫𝐣𝔼

Explicación:

𝐧         Get the length of the input, then create an exclusive range
 ᛖ        Add 2 to each element
  𝕄       Modulus
    𝐫      Reverse
     𝐣     Join
      𝔼   Check for equality

Pruébalo en línea!

Jalea , 7 bytes

DJ‘⁸%⁼Ṛ

Pruébalo en línea!

Python 2 , 56 bytes

lambda x:all(`x%(i+2)`==`x`[~i]for i in range(len(`x`)))

Pruébalo en línea!

Perl 6 , 32 bytes

{$_ eq[~] $_ «%«(1+.comb...2)}

Pruébalo en línea!

• .combes el número de caracteres en la representación de cadena del argumento de entrada $_(es decir, el número de dígitos).
• 1 + .comb ... 2 es la secuencia de números desde uno mayor que el número de dígitos hasta 2.
• «%«es la hyperoperator módulo que da el resto cuando $_el argumento de entrada a su izquierda, se divide por cada uno de los elementos de la secuencia en su derecho: $_ % 2, $_ % 3, ....
• [~]concatena esos dígitos en un nuevo número, que se compara con el argumento de entrada utilizando el operador de igualdad de cadena eq.

PHP , 43 bytes

for(;$r<$a=$argn;)$r=$a%~++$i.$r;echo$r>$a;

Pruébalo en línea!

PHP , 44 bytes

imprime 1 para verdadero y nada para falso

for(;$r<$a=$argn;)$r=$a%~++$i.$r;echo$r==$a;

Pruébalo en línea!

Pyth , 13 bytes

-1 bytes gracias a Okx .

qsjk_m%QhdSl`

Pruébalo en línea!

Explicación

             QQ    # Implicit input
          Sl`Q     # Generate [1, len(str(Q))]
     m%Qhd         # For digit d in above range, perform Q % (d + 1)
 sjk_              # Reverse, then convert to number
q             Q    # Test equality with input

Solución alternativa , todavía 13 bytes (gracias a karlkastor )

qi_.e%Q+2k`QT

Pruébalo en línea! Eso es esencialmente lo mismo que la primera solución, con la excepción de que se usa ipara convertir una matriz de números a un número, y que el rango se genera de manera diferente.

C ++, 104 bytes

1) versión original:

int main(){int N,T,R=1;cin>>N;T=N;for(int i=1;i<=log10(N)+1;i++){if(N%(i+1)!=T%10){R=0;}T/=10;}cout<<R;}

2) en una forma legible:

int main()
{
    int N, T, R = 1;

    cin >> N;
    T = N;

    for (int i = 1; i <= log10(N) + 1; i++)
    {
        if (N % (i + 1) != T % 10)
        {
            R = 0;
        }

        T /= 10;
    }

    cout << R;
}

Pruébalo en línea!

Pari / GP , 42 bytes

n->Vecrev(s=digits(n))==[n%d|d<-[2..#s+1]]

Pruébalo en línea!

Python 2 , 66 60 58 57 bytes

• Gracias a @Leaky nun por 6 bytes: eliminar innecesariamente x and (no debe verificar 0)
• Gracias a @Einkorn Enchanter por 1 byte: uso de enumerate

lambda x:all(a==`x%(i+2)`for i,a in enumerate(`x`[::-1]))

Pruébalo en línea!

Python 3: 63 bytes

lambda m:all(int(x)==m%(n+2)for n,x in enumerate(str(m)[::-1]))

Si pudiera contar el número de veces que desearía que 'enumerar' fuera más corto ...

Pruébalo en línea!

Java (OpenJDK 8) , 60 bytes

n->{int m=2,r=0,t=1;for(;n>=t;t*=10)r+=n%m++*t;return r==n;}

Pruébalo en línea!

Una versión sin cadenas.

Java 8, 156 149 bytes

interface B{static void main(String[]s){String f="";for(int i=1;i<=s[0].length();)f=new Long(s[0])%++i+f;System.out.print(f.equals(s[0]));}}

Sin golf:

interface B {
    static void main(String[] s) {
        String f = "";
        for (int i = 1; i <= s[0].length();)
            f = new Long(s[0]) % ++i + f;
        System.out.print(f.equals(s[0]));
    }
}

Pruébalo en línea!

ACTUALIZACIÓN:
-7 bytes : eliminado inútil {}y reemplazado Integer.parseInt(...)por new Integer(...)
-9 bytes : gracias a Kevin Cruijssen, eliminó un montón de inútil (), utilizado en Longlugar de Integery en printlugar de println. Gracias Kévin!

Carbón , 20 15 bytes

⌊Ｅθ⁼ιＩ﹪Ｉθ⁻⁺¹Ｌθκ

Pruébalo en línea! Salidas -para un número de escalera, nada de lo contrario. El enlace es a la versión detallada del código.

Python 2, 61 bytes

lambda x:[`x%(n+2)`for n in range(len(`x`))][::-1]==list(`x`)

q / kdb +, 34 bytes

Solución:

{s~raze($)x mod'2+(|)(!)(#)s:($)x}

Ejemplo:

q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211311 / this is a staircase number (true)
1b
q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211312 / this is not (false)
0b
q)t(&){s~raze($)x mod'2+(|)(!)(#)s:($)x}each t:1 + til 1000000 / up to a million
1 10 20 1101 1121 11311 31101 40210 340210

Explicación:

Transmita el número de entrada a una cadena, cuente desde 0..length de cadena, agregue 2 a todos, inviértalo y alimente cada número modjunto con la entrada original. Transmita el resultado del mod a una cadena y reduzca la lista, verifique si es igual a la cadena del número de entrada:

{s~raze string x mod'2 + reverse til count s:string x} / ungolfed solution
{                                                    } / lambda function
                                           s:string x  / convert input to string, save as s
                                     count             / return length of this string
                                 til                   / like python's range() function
                         reverse                       / reverses the list
                     2 +                               / adds two to each element in the list
               x mod'                                  / ' is each both, so feeds x, and each element of the list to modulo function
        string                                         / converts output list to string list ("7";"2";"1"..etc)
   raze                                                / reduce list ("721...")
 s~                                                    / is s equal to this reduced list, returns boolean

Notas:

La mayor parte de la solución es para generar la 2,3,4..lista, tengo otra solución que hace menos cosas, pero termina siendo 37 bytes después del golf:

{s~x mod'reverse 2 + til count s:("J"$) each string x} / ungolfed
{s~x mod'(|)2+til(#)s:("J"$)each($)x}                  / golfed

Clojure, 75 bytes

#(=(sort %)(sort(map(fn[i c](char(+(mod(Integer. %)(+ i 2))48)))(range)%)))

La entrada es una cadena que se usa mapy el final %terminó siendo más corto que el for[i(range(count %))]enfoque.

Haskell, 62 bytes

f x=and$zipWith(==)(reverse$show x)$map(head.show.mod x)[2..]

En lugar de invertir la lista (infinita) de módulos, trunca la lista comprimiéndola con la representación de cadena invertida de la integral x, que luego asegura que es igual en cuanto a elementos.

Perl 5 , 41 bytes

39 bytes de código + 2 banderas -pa

map{$\||=$_!=$F[0]%++$n}0,reverse/./g}{

Pruébalo en línea!

No genera nada (undef) para números de escalera, 1 para cualquier otra cosa