Un numero scala è un intero positivo x tale che il suo n -esima cifra (uno indicizzato iniziando con la cifra meno significativa) è uguale a x% (n + 1) . È un po 'un boccone, quindi diamo un'occhiata a un esempio. Prendi 7211311 , se prendiamo i residui modulari di 7211311 nell'intervallo 2-8 otteniamo quanto segue:

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

Queste sono le cifre di 7211311 ! Pertanto 7211311 è un numero di scala.

Compito

Scrivi il codice che accetta quando viene dato un numero positivo come input, genererà due valori distinti uno se il numero è un numero di scala e l'altro se non lo è.

Questa è una competizione di code-golf quindi il tuo obiettivo dovrebbe essere quello di ridurre al minimo il numero di byte nel tuo codice sorgente.

Casi test

Ecco i primi 13 numeri delle scale:

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

Haskell, 55 57 byte

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

Un approccio diverso rispetto all'altra soluzione Haskell.

Grazie xnor per aver salvato 2 byte.

Brachylog , 25 21 16 14 byte

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

Provalo online!

Prima presentazione di Brachylog: D probabilmente molto non golfato ... molte grazie a Leaky Nun e Fatalize per l'incoraggiamento e l'aiuto per giocare a golf da 25 fino a soli 14. :) :)

Javascript, 42 41 39 38 byte

-4 byte grazie a @Shaggy e @ETHProductions

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

Questo prende il numero come una stringa e restituisce falsese il numero è un numero di scala e in truealtro modo.

Esempio di frammento di codice:

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 byte

Codice:

ā>%JRQ

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione:

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

Prende il numero come int

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

Mathematica, 60 byte

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

Provalo online!

@alephalpha ha giocato a golf a 48

Mathematica, 48 byte

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

il prossimo è 24120020

Python 2 , 54 byte

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

Provalo online!

Japt , 9 7 byte

Accetta l'input come stringa.

¥£%´JÃw

Provalo

• 2 byte salvati con l'aiuto di ETHproductions.

Spiegazione

Prendiamo implicitamente la stringa come input.

£   Ã

Mappa su ogni carattere della stringa.

´J

Jè la costante di Japt -1e la ´diminuisce di 1 ad ogni passaggio ( --in JavaScript). Quindi, al primo passaggio, questo ci dà -2.

%

Usiamo quel valore per eseguire un'operazione modulo sulla stringa di input che viene automaticamente lanciata su un numero intero nel processo. In JavaScript x%-ydà lo stesso risultato di x%y.

w

Invertire la stringa risultante.

¥

Controlla se la nuova stringa è uguale all'input originale e genera implicitamente il risultato come booleano.

Neim , 6 byte

𝐧ᛖ𝕄𝐫𝐣𝔼

Spiegazione:

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

Provalo online!

Gelatina , 7 byte

DJ‘⁸%⁼Ṛ

Provalo online!

Python 2 , 56 byte

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

Provalo online!

Perl 6 , 32 byte

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

Provalo online!

• .combè il numero di caratteri nella rappresentazione in formato stringa dell'argomento di input $_(ovvero il numero di cifre).
• 1 + .comb ... 2 è la sequenza di numeri da uno maggiore del numero di cifre fino a 2.
• «%«è il hyperoperator modulo che dà il resto quando $_l'argomento di input alla sua sinistra, è diviso per ciascuno degli elementi della sequenza alla sua destra: $_ % 2, $_ % 3, ....
• [~]concatena quelle cifre in un nuovo numero, che viene confrontato con l'argomento di input utilizzando l'operatore di uguaglianza delle stringhe eq.

PHP , 43 byte

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

Provalo online!

PHP , 44 byte

stampa 1 per vero e niente per falso

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

Provalo online!

Pyth , 13 byte

-1 byte grazie a Okx .

qsjk_m%QhdSl`

Provalo online!

Spiegazione

             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

Soluzione alternativa , ancora 13 byte (grazie a karlkastor )

qi_.e%Q+2k`QT

Provalo online! È essenzialmente la stessa della prima soluzione, tranne per il fatto che utilizza iper convertire da array di numeri in un numero e che l'intervallo viene generato in modo diverso.

C ++, 104 byte

1) versione 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) in una forma leggibile:

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

Provalo online!

Pari / GP , 42 byte

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

Provalo online!

Python 2 , 66 60 58 57 byte

• Grazie alla suora @Leaky per 6 byte: rimuovi non necessario x and( non controllare 0)
• Grazie a @Einkorn Enchanter per 1 byte: utilizzo di enumerate

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

Provalo online!

Python 3: 63 byte

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

Se potessi contare il numero di volte in cui avrei voluto che "enumerare" fosse più breve ...

Provalo online!

Java (OpenJDK 8) , 60 byte

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

Provalo online!

Una versione non stringa.

Java 8, 156 149 byte

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

Provalo online!

AGGIORNAMENTO:
-7 byte : rimosso inutile {}e sostituito Integer.parseInt(...)da new Integer(...)
-9 byte : grazie a Kevin Cruijssen, rimosso un mucchio di inutili (), utilizzato al Longposto di Integere printinvece di println. Grazie Kévin!

Carbone , 20 15 byte

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

Provalo online! Uscite -per un numero di scala, nient'altro. Il collegamento è alla versione dettagliata del codice.

Python 2, 61 byte

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

q / kdb +, 34 byte

Soluzione:

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

Esempio:

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

Spiegazione:

Cast il numero di input in una stringa, contare da 0..lunghezza della stringa, aggiungere 2 a tutti, invertirlo e inserire ciascun numero modinsieme all'input originale. Trasmetti il ​​risultato della mod in una stringa e riduci l'elenco, controlla se è uguale alla stringa del numero di input:

{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

Gli appunti:

La maggior parte della soluzione è per generare l' 2,3,4..elenco, ho un'altra soluzione che fa meno cose, ma finisce per essere 37 byte dopo il 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 byte

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

L'input è una stringa, usando mape il trailing ha %finito per essere più breve for[i(range(count %))]dell'approccio.

Haskell, 62 byte

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

Invece di invertire la (infinita) lista di moduli, tronca la lista comprimendola con la rappresentazione di stringa inversa della x integrale, che assicura quindi che sia uguale per elemento.

Perl 5 , 41 byte

39 byte di codice + 2 flag -pa

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

Provalo online!

Non genera nulla (undef) per i numeri delle scale, 1 per qualsiasi altra cosa