Un certain nombre d'escalier est un entier positif x tel que sa n ième chiffre (une indexée en commençant par le chiffre le moins significatif) est égal à x% (n + 1) . C'est un peu bouchée, alors regardons un exemple. Prenez 7211311 , si nous prenons les résidus modulaires de 7211311 sur la plage 2-8, nous obtenons ce qui suit:

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

Ce sont les chiffres de 7211311 ! Ainsi, 7211311 est un numéro d'escalier.

Tâche

Écrire du code qui prend quand on lui donne un nombre positif en entrée, produira deux valeurs distinctes l'une si le nombre est un nombre d'escalier et l'autre s'il ne l'est pas.

Il s'agit d'une compétition de code-golf donc votre objectif devrait être de minimiser le nombre d'octets dans votre code source.

Cas de test

Voici les 13 premiers numéros d'escalier:

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

Haskell, 55 57 octets

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

Une approche différente de celle de l'autre solution Haskell.

Merci xnor d'avoir sauvé 2 octets.

Brachylog , 25 21 16 14 octets

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

Essayez-le en ligne!

Première soumission Brachylog: D probablement très peu golfé ... merci beaucoup à Leaky Nun et Fatalize pour leurs encouragements et leur aide à jouer au golf de 25 à 14. 14. :) :)

Javascript, 42 41 39 38 octets

-4 octets grâce à @Shaggy et @ETHProductions

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

Cela prend le nombre sous forme de chaîne et renvoie falsesi le numéro est un numéro d'escalier et truesinon.

Exemple d'extrait de code:

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 octets

Code:

ā>%JRQ

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication:

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

Prend le nombre en entier

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

Mathematica, 60 octets

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

Essayez-le en ligne!

@alephalpha l'a joué au golf à 48

Mathematica, 48 octets

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

le suivant est 24120020

Python 2 , 54 octets

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

Essayez-le en ligne!

Japt , 9 7 octets

Prend l'entrée sous forme de chaîne.

¥£%´JÃw

Essaye-le

• 2 octets enregistrés avec l'aide d'ETHproductions.

Explication

Nous prenons implicitement la chaîne en entrée.

£   Ã

Mappez sur chaque caractère de la chaîne.

´J

Jest la constante Japt de -1, et la ´décrémente de 1 à chaque passage ( --en JavaScript). Donc, au premier passage, cela nous donne -2.

%

Nous utilisons cette valeur pour effectuer une opération modulo sur la chaîne d'entrée qui est automatiquement convertie en un entier dans le processus. En JavaScript x%-ydonne le même résultat que x%y.

w

Inverse la chaîne résultante.

¥

Vérifiez si la nouvelle chaîne est égale à l'entrée d'origine et émettez implicitement le résultat sous la forme d'un booléen.

Neim , 6 octets

𝐧ᛖ𝕄𝐫𝐣𝔼

Explication:

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

Essayez-le en ligne!

Gelée , 7 octets

DJ‘⁸%⁼Ṛ

Essayez-le en ligne!

Python 2 , 56 octets

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

Essayez-le en ligne!

Perl 6 , 32 octets

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

Essayez-le en ligne!

• .combest le nombre de caractères dans la représentation sous forme de chaîne de l'argument d'entrée $_(c'est-à-dire le nombre de chiffres).
• 1 + .comb ... 2 est la séquence de nombres de un supérieur au nombre de chiffres jusqu'à 2.
• «%«est le module hyperoperator qui donne le reste lorsque $_le paramètre d'entrée à sa gauche, est divisée par chacun des éléments de la séquence à sa droite: $_ % 2, $_ % 3, ....
• [~]concatène ces chiffres en un nouveau nombre, qui est comparé à l'argument d'entrée à l'aide de l'opérateur d'égalité de chaîne eq.

PHP , 43 octets

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

Essayez-le en ligne!

PHP , 44 octets

imprime 1 pour vrai et rien pour faux

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

Essayez-le en ligne!

Pyth , 13 octets

-1 octets grâce à Okx .

qsjk_m%QhdSl`

Essayez-le en ligne!

Explication

             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

Solution alternative , toujours 13 octets (merci à karlkastor )

qi_.e%Q+2k`QT

Essayez-le en ligne! C'est essentiellement la même que la première solution, sauf qu'elle utilise ipour convertir d'un tableau de nombres en un nombre, et que la plage est générée différemment.

C ++, 104 octets

1) version originale:

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) sous une forme lisible:

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

Essayez-le en ligne!

Pari / GP , 42 octets

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

Essayez-le en ligne!

Python 2 , 66 60 58 57 octets

• Merci à @Leaky nun pour 6 octets: supprimez les inutiles x and(ne vérifiez pas 0)
• Merci à @Einkorn Enchanter pour 1 octet: utilisation de enumerate

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

Essayez-le en ligne!

Python 3: 63 octets

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

Si je pouvais compter le nombre de fois que je souhaitais que «énumérer» soit plus court ...

Essayez-le en ligne!

Java (OpenJDK 8) , 60 octets

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

Essayez-le en ligne!

Une version sans chaîne.

Java 8, 156 149 octets

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

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

Essayez-le en ligne!

MISE À JOUR:
-7 octets : supprimé inutile {}et remplacé Integer.parseInt(...)par new Integer(...)
-9 octets : grâce à Kevin Cruijssen, supprimé un tas d'inutiles (), utilisé à la Longplace de Integeret printau lieu de println. Merci Kévin!

Fusain , 20 15 octets

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

Essayez-le en ligne! Sorties -pour un numéro d'escalier, rien d'autre. Le lien est vers la version détaillée du code.

Python 2, 61 octets

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

q / kdb +, 34 octets

Solution:

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

Exemple:

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

Explication:

Cast le numéro d'entrée dans une chaîne, comptez à partir de 0..longueur de chaîne, ajoutez 2 à tous, inversez-le et introduisez chaque numéro modavec l'entrée d'origine. Convertissez le résultat du mod en chaîne et réduisez la liste, vérifiez s'il est égal à la chaîne du numéro d'entrée:

{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

Remarques:

La plupart de la solution consiste à générer la 2,3,4..liste, j'ai une autre solution qui fait moins de choses, mais qui finit par être de 37 octets après le 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 octets

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

L'entrée est une chaîne, en utilisant mapet la %fin a été plus courte que l' for[i(range(count %))]approche.

Haskell, 62 octets

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

Au lieu d'inverser la liste (infinie) de modules, il tronque la liste en la zippant avec la représentation de chaîne inversée de l'intégrale x, dont elle assure ensuite qu'elle est égale par élément.

Perl 5 , 41 octets

39 octets de code + 2 drapeaux -pa

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

Essayez-le en ligne!

N'affiche rien (undef) pour les numéros d'escalier, 1 pour autre chose