계단 수는 양의 정수 x 이므로 n 번째 자릿수 (최하위 자릿수로 시작하는 인덱스)는 x % (n + 1)과 같습니다 . 그것은 약간 한 입이므로 예제를 살펴 보겠습니다. 가지고 7,211,311을 우리의 모듈 잔류 가지고가는 경우에, 7,211,311을 우리는 다음을 얻을 범위 2-8 :

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

이것들은 7211311 의 숫자입니다 ! 따라서 7211311 은 계단 번호입니다.

태스크

양수를 입력으로 사용할 때 걸리는 코드 작성은 숫자 가 계단 수 이면 다른 값 이 아닌 값을 출력 합니다.

이것은 코드 골프 경쟁이므로 소스 코드의 바이트 수를 최소화하는 것이 목표입니다.

테스트 사례

처음 13 개의 계단 번호는 다음과 같습니다.

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

하스켈, 55 57 바이트

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

다른 Haskell 솔루션과 다른 접근 방식.

2 바이트를 저장해 주셔서 감사합니다.

Brachylog , 25 21 16 14 바이트

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

온라인으로 사용해보십시오!

첫 번째 Brachylog 제출 : D 아마도 매우 골치 아픈 ... Leaky Nun과 Fatalize에게 격려와 감사의 말을 전하며 25에서 14까지 골프를 치는 데 많은 도움을주었습니다. :) :)

자바 스크립트, 42 41 39 38 바이트

@Shaggy 및 @ETHProductions 덕분에 -4 바이트

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

이것은 숫자를 문자열로 취하여 false숫자가 계단 수이면 true그렇지 않으면 반환합니다.

코드 스 니펫 예제 :

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 바이트

암호:

ā>%JRQ

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

설명:

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

하스켈, 60 바이트

숫자를 정수로 취합니다.

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

Mathematica, 60 바이트

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

온라인으로 사용해보십시오!

@alephalpha는 48로 골프를 쳤다.

매스 매 티카, 48 바이트

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

다음은 24120020입니다

파이썬 2 , 54 바이트

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

온라인으로 사용해보십시오!

apt , 9 7 바이트

입력을 문자열로받습니다.

¥£%´JÃw

그것을 테스트

• ETH 프로덕션의 도움으로 2 바이트가 절약되었습니다.

설명

암시 적으로 문자열을 입력으로 사용합니다.

£   Ã

문자열의 각 문자를 매핑하십시오.

´J

JJAPT위한 상수 -1와 ´(각 패스에 1을 감소 --자바 스크립트). 따라서 첫 번째 패스에서 이것은 우리에게 -2.

%

이 값을 사용하여 프로세스에서 정수로 자동 캐스트되는 입력 문자열에서 모듈로 연산을 수행합니다. JavaScript x%-y에서는와 같은 결과를 제공합니다 x%y.

w

결과 문자열을 반대로 바꿉니다.

¥

새 문자열이 원래 입력과 같은지 확인하고 결과를 부울로 암시 적으로 출력합니다.

Neim, 6 bytes

𝐧ᛖ𝕄𝐫𝐣𝔼

Explanation:

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

Try it online!

Jelly, 7 bytes

DJ‘⁸%⁼Ṛ

Try it online!

Python 2, 56 bytes

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

Try it online!

Perl 6, 32 bytes

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

Try it online!

• .comb is the number of characters in the string representation of the input argument $_ (that is, the number of digits).
• 1 + .comb ... 2 is the sequence of numbers from one greater than the number of digits down to 2.
• «%« is the modulus hyperoperator that gives the remainder when $_, the input argument on its left, is divided by each of the elements of the sequence on its right: $_ % 2, $_ % 3, ....
• [~] concatenates those digits into a new number, which is compared with the input argument using the string equality operator eq.

PHP, 43 bytes

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

Try it online!

PHP, 44 bytes

prints 1 for true and nothing for false

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

Try it online!

Pyth, 13 bytes

-1 bytes thanks to Okx.

qsjk_m%QhdSl`

Try it online!

Explanation

             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

Alternate solution, still 13 bytes (thanks to karlkastor)

qi_.e%Q+2k`QT

Try it online! That's essentially the same as the first solution, excepted that it uses i to convert from array of numbers to a number, and that the range is generated differently.

C++,104 bytes

1) original version:

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 a readable form:

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

Try it Online!

Pari/GP, 42 bytes

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

Try it online!

Python 2, 66 60 58 57 bytes

• Thanks to @Leaky nun for 6 bytes: remove unneeded x and (shouldnot check for 0)
• Thanks to @Einkorn Enchanter for 1 byte: use of enumerate

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

Try it online!

Python 3: 63 Bytes

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

If I could count the number of times I wished 'enumerate' were shorter...

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

Try it online!

A non-string version.

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

Try it Online !

UPDATE :
-7 bytes : removed useless {} and replaced Integer.parseInt(...) by new Integer(...)
-9 bytes : thanks to Kevin Cruijssen, removed a bunch of useless (), used Long instead of Integer and print instead of println. Thanks Kévin !

Charcoal, 20 15 bytes

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

Try it online! Outputs - for a staircase number, nothing otherwise. Link is to verbose version of code.

Python 2, 61 bytes

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

q/kdb+, 34 bytes

Solution:

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

Example:

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

Explanation:

Cast the input number to a string, count from 0..length of string, add 2 to all, reverse it and feed each number into mod along with the original input. Cast the result of the mod to a string and reduce the list, check if it is equal to the string of the input number:

{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

Notes:

Most of the solution is for generating the 2,3,4.. list, I have another solution that does less stuff, but winds up being 37 bytes after golfing:

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

Input is a string, using map and the trailing % ended up being shorter than for[i(range(count %))] approach.

Haskell, 62 bytes

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

Instead of reversing the (infinite) list of moduli, it truncates the list by zipping it with the reversed string-respresentation of the integral x, which it then ensures is equal element-wise.

Perl 5, 41 bytes

39 bytes of code + 2 flags -pa

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

Try it online!

Outputs nothing (undef) for staircase numbers, 1 for anything else