Um número escadaria é um número inteiro positivo x tal que a sua n th dígitos (uma indexadas começando com o dígito menos significativo) é igual a X% (n + 1) . Isso é um pouco exagerado, então vamos ver um exemplo. Pegue 7211311 , se usarmos os resíduos modulares de 7211311 no intervalo de 2 a 8, obteremos o seguinte:

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

Estes são os dígitos de 7211311 ! Portanto, 7211311 é um número da escada.

Tarefa

Escreva o código que recebe quando recebe um número positivo como entrada, produzirá dois valores distintos, um se o número for um número de escada e o outro se não for.

Como é uma competição de código-golfe , seu objetivo deve ser minimizar o número de bytes no seu código-fonte.

Casos de teste

Aqui estão os 13 primeiros números da escada:

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

Uma abordagem diferente da outra solução Haskell.

Obrigado xnor por salvar 2 bytes.

Brachylog , 25 21 16 14 bytes

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

Experimente online!

Primeira submissão ao Brachylog: D provavelmente muito não-destruído ... muito obrigado a Leaky Nun e Fatalize pelo incentivo e ajuda a jogar de 25 a 25 para apenas 14. :) :)

Javascript, 42 41 39 38 bytes

-4 bytes graças a @Shaggy e @ETHProductions

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

Isso pega o número como uma sequência e retorna falsese o número for um número de escada ou truenão.

Exemplo de trecho de código:

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

Usa a codificação 05AB1E . Experimente online!

Explicação:

ā        # 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

Pega o 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]==#&

Experimente online!

@alephalpha jogou até 48

Mathematica, 48 bytes

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

o próximo é 24120020

Python 2 , 54 bytes

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

Experimente online!

Japonês , 9 7 bytes

Recebe a entrada como uma sequência.

¥£%´JÃw

Teste-o

• 2 bytes salvos com a ajuda da ETHproductions.

Explicação

Nós assumimos implicitamente a string como entrada.

£   Ã

Mapeie sobre cada caractere na sequência.

´J

Jé a constante Japt para -1e a ´diminui em 1 em cada passagem ( --em JavaScript). Então, na primeira passagem, isso nos dá -2.

%

Usamos esse valor para executar uma operação de módulo na sequência de entrada que é automaticamente convertida em um número inteiro no processo. Em JavaScript x%-ydá o mesmo resultado que x%y.

w

Inverta a sequência resultante.

¥

Verifique se a nova sequência é igual à entrada original e gera implicitamente o resultado como um booleano.

Neim , 6 bytes

𝐧ᛖ𝕄𝐫𝐣𝔼

Explicação:

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

Experimente online!

Geléia , 7 bytes

DJ‘⁸%⁼Ṛ

Experimente online!

Python 2 , 56 bytes

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

Experimente online!

Perl 6 , 32 bytes

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

Experimente online!

• .combé o número de caracteres na representação em cadeia do argumento de entrada $_(ou seja, o número de dígitos).
• 1 + .comb ... 2 é a sequência de números de um maior que o número de dígitos até 2.
• «%«é o módulo de hyperoperator que dá o restante quando $_, o argumento de entrada no seu lado esquerdo, é dividida por cada um dos elementos da sequcia no seu direito: $_ % 2, $_ % 3, ....
• [~]concatena esses dígitos em um novo número, que é comparado com o argumento de entrada usando o operador de igualdade de cadeias eq.

PHP , 43 bytes

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

Experimente online!

PHP , 44 bytes

imprime 1 para verdadeiro e nada para falso

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

Experimente online!

Pitão , 13 bytes

-1 bytes graças a Okx .

qsjk_m%QhdSl`

Experimente online!

Explicação

             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

Solução alternativa , ainda com 13 bytes (graças a karlkastor )

qi_.e%Q+2k`QT

Experimente online! Isso é essencialmente o mesmo que a primeira solução, exceto pelo fato de ele ser usado ipara converter da matriz de números em um número, e que o intervalo é gerado de maneira diferente.

C ++, 104 bytes

1) versão 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) de forma legível:

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

Experimente Online!

Pari / GP , 42 bytes

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

Experimente online!

Python 2 , 66 60 58 57 bytes

• Graças à freira @Leaky por 6 bytes: remova desnecessariamente x and(não deve verificar se há 0)
• Obrigado a @Einkorn Enchanter por 1 byte: uso de enumerate

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

Experimente online!

Python 3: 63 bytes

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

Se eu pudesse contar o número de vezes que desejava que "enumerar" fosse menor ...

Experimente online!

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

Experimente online!

Uma versão sem sequência.

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

Ungolfed:

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

Experimente Online!

UPDATE:
-7 bytes : removido inútil {}e substituído Integer.parseInt(...)por new Integer(...)
-9 bytes : graças a Kevin Cruijssen, removemos um monte de inúteis (), usados ​​em Longvez de Integere em printvez de println. Obrigado Kévin!

Carvão , 20 15 bytes

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

Experimente online! Saídas -para um número de escada, nada diferente. Link é a versão detalhada do código.

Python 2, 61 bytes

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

q / kdb +, 34 bytes

Solução:

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

Exemplo:

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

Explicação:

Converta o número da entrada em uma string, conte de 0..length da string, adicione 2 a todos, inverta-o e alimente cada número modjunto com a entrada original. Lance o resultado do mod para uma string e reduza a lista, verifique se é igual à string do 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:

A maior parte da solução é para gerar a 2,3,4..lista, eu tenho outra solução que faz menos coisas, mas acaba sendo 37 bytes depois do golfe:

{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)%)))

A entrada é uma string, usando mape o final %acabou sendo mais curto que a for[i(range(count %))]abordagem.

Haskell, 62 bytes

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

Em vez de reverter a lista (infinita) de módulos, ela trunca a lista, compactando-a com a representação de seqüência de caracteres invertida da integral x, o que garante que seja igual em termos de elementos.

Perl 5 , 41 bytes

39 bytes de código + 2 sinalizadores -pa

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

Experimente online!

Não produz nada (undef) para números de escadas, 1 para qualquer outra coisa