Staircase numbers

Question

A staircase number is a positive integer x such that its nth digit (one indexed starting with the least significant digit) is equal to x % (n + 1). Thats a bit of a mouthful so lets look at an example. Take 7211311, if we take the modular residues of 7211311 on the range 2-8 we get the following:

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

These are the digits of 7211311! Thus 7211311 is a staircase number.

Task

Write code that takes when given a positive number as input, will output two distinct values one if the number is a staircase number and the other if it is not.

This is a code-golf competition so your aim should be to minimize the number of bytes in your source code.

Test Cases

Here are the first 13 staircase numbers:

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

Answer 1

Haskell, 55 57 bytes

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

A different approach than the other Haskell solution.

Thanks xnor for saving 2 bytes.

Answer 2

Brachylog, 25 21 16 14 bytes

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

Try it online!

First Brachylog submission :D probably very ungolfed...many thanks to Leaky Nun and Fatalize for encouragement and help to golf this from 25 all the way down to just 14. :) :)

Answer 3

05AB1E, 6 bytes

Code:

ā>%JRQ

Uses the 05AB1E encoding. Try it online!

Explanation:

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

Answer 4

Javascript, 42 41 39 38 bytes

-4 bytes thanks to @Shaggy and @ETHProductions

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

This takes the number as a string and returns false if the number is a staircase number and true otherwise.

Example code snippet:

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

Answer 5

Python 2, 54 bytes

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

Try it online!

Answer 6

Haskell, 60 bytes

Takes the number as an int

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

Answer 7

Mathematica, 60 bytes

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

Try it online!

@alephalpha golfed it to 48

Mathematica, 48 bytes

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

next one is 24120020

Answer 8

Japt, 9 7 6 bytes

Takes input as a string.

Ô¶¡%´J

2 bytes saved with help from ETHproductions.

Try it

Ô¶¡%´J     :Implicit input of string U
Ô          :Reverse
 ¶         :Test for equality with 
  ¡        :Map U
   %       :  Modulo
    ´J     :  J (initially -1) prefix decremented

Answer 9

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!

Answer 10

Jelly, 7 bytes

DJ‘⁸%⁼Ṛ

Try it online!

Answer 11

Python 2, 56 bytes

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

Try it online!

Answer 12

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.

Answer 13

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!

Answer 14

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.

Answer 15

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!

Answer 16

APL (Dyalog Extended), ²¹ 19 bytes

{⍵=10⊥⌽⍵|⍨1↓⍳1+≢⍕⍵}

Try it online!

Creates two lists of digits and check if they are equal.

Explanation

{⍵=10⊥⌽⍵|⍨1↓⍳1+≢⍕⍵} ⍵ → input
               ≢⍕⍵  length of ⍵ as a string
             1+     +1
            ⍳       range from 1 to that
          1↓        Drop first element 
       ⍵|⍨          ⍵ mod each element in range
      ⌽             reversed
   10⊥              converted from base 10
 ⍵=                 equals the input?

Answer 17

Pari/GP, 42 bytes

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

Try it online!

Answer 18

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!

Answer 19

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!

Answer 20

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.

Answer 21

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 !

Answer 22

Charcoal, 20 15 bytes

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

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

Answer 23

Haskell, 53 bytes

f n=foldr(\(k,_)a->10*a+mod n k)0(zip[2..]$show n)==n

Try it online!

Answer 24

Python 2, 61 bytes

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

Answer 25

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

Answer 26

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.

Answer 27

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.

Answer 28

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

Answer 29

MathGolf, 7 bytes

mækî)%Ñ

Input as a string.

Try it online.

Explanation:

m        # Map over each character of the (implicit) input-string,
 æ       # using the following four characters as inner code-block:
         #  (implicitly push the current character of the map)
  k      #  Push the input as an integer
   î     #  Push the 1-based map-index
    )    #  Increase it by 1
     %   #  Take the input-integer modulo (1-based) index+1
         # After the map, the digits are implicitly joined together to a string
      Ñ  # Check that this string is a palindrome
         # (after which the entire stack joined together is output implicitly as result)