Números de escalera

29

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 , 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
Asistente de trigo
fuente
¿No son los 0números de una escalera? Muchas respuestas piensan que sí.
Okx
3
@Okx la tarea es solo distinguir los números de escalera positivos de los números positivos que no son de escalera, por lo que el comportamiento no está definido para 0 y números negativos.
Paŭlo Ebermann

Respuestas:

10

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.

Silvio Mayolo
fuente
44
Puedes usar este consejo para acortar la letexpresión.
xnor
Un enfoque diferente y más corto. ¡Bien hecho! +1
qfwfq
9

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. :) :)

Erik el Outgolfer
fuente
7

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">

Herman L
fuente
2
Debería poder descartarlo !ya que el desafío no especifica explícitamente que debe devolver trueverdadero y falsefalso, simplemente que debe devolver 2 valores distintos.
Shaggy
2
Esto está muy bien golfizado, bien hecho. Creo que deberías poder exprimir dos bytes más si te calculas a iti mismo:s=>[...s].some(d=>s%i--^d,i=s.length+1)
ETHproductions
2
En realidad, al explotar el hecho de que ~x == -(x+1)en enteros y x%-y == x%y, creo que puedes obtener uno más:s=>[...s].some(d=>s%i++^d,i=~s.length)
ETHproductions
6

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
Adnan
fuente
6

Haskell, 60 bytes

Toma el número como int

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

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

J42161217
fuente
5

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.

Lanudo
fuente
Dios mío (Y+2, siento que eso podría ser al menos 1 byte más corto ...
ETHproductions
1
... y puede: ¥£%´JÃw:-) (funciona porque x%y == x%-yen JS)
ETHproductions
Ah, sí, estaba intentando algunas cosas diferentes para reducir ese cálculo a 2 bytes.
Shaggy
4

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!

Okx
fuente
@Thehx Con respecto a su edición, Neim utiliza una codificación personalizada: esta
Okx
2

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.
Sean
fuente
2

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.

Jim
fuente
1
Puede reemplazar ss`M_con jk_para guardar 2 bytes.
Okx
@Okx Lo necesito porque jgenera una cadena mientras que necesito un número para comparar con la entrada (que es un número).
Jim
1
Otra solución de 13 bytes sería: qi_.e%Q+2k`QTusar map ( .e) enumerado en lugar de map. Y convertir los restos a una base 10 int de la lista en lugar de usar join.
KarlKastor 01 de
2

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!

koita_pisw_sou
fuente
1

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!

officialaimm
fuente
1
Más corto si enumeras
Wheat Wizard
Gracias. Y oye, me acabo de dar cuenta de que eras mago del trigo ...: D
officialaimm
1

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!

Bendl
fuente
Sí, y me di cuenta de que es exactamente lo mismo que la respuesta que dio @officialaimm ... ¿Debería eliminarlo?
bendl
El suyo está en Python 2 y se te ocurrió de forma independiente, así que lo dejaría.
Wheat Wizard
Puede guardar dos bytes iniciando su enumeración en 2 y reorganizando la lógica:lambda m:all(m%n==int(x)for n,x in enumerate(str(m)[::-1],2))
nocturama
1

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!

Alex Ferretti
fuente
1
Buena respuesta, +1 de mi parte. Por cierto, algunas cosas pequeñas para el golf: new Integerpueden ser new Long(-3 bytes); printlnpuede ser print(-2 bytes); y puede eliminar el paréntesis que lo rodea new Long(s[0])%i+f;(-4 bytes).
Kevin Cruijssen
Muy agradable ! ¡Gracias, actualizaré esto!
Alex Ferretti
1

Carbón , 20 15 bytes

⌊Eθ⁼ιI﹪Iθ⁻⁺¹Lθκ

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.

Neil
fuente
0

Python 2, 61 bytes

lambda x:[`x%(n+2)`for n in range(len(`x`))][::-1]==list(`x`)
Daniel
fuente
No, tu nuevo golf es un byte más corto. :)
Wheat Wizard
0

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
callejero
fuente
0

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.

NikoNyrh
fuente
0

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.

Archaephyrryx
fuente
0

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

Xcali
fuente