楼梯号

29

阶梯数是一个正整数x，因此它的第n个数字（从最低有效数字开始索引的一个数字）等于x％（n +1）。有点麻烦，让我们来看一个例子。以7211311为例，如果我们将7211311的模残数取在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

code-golf number decision-problem

— 小麦巫师
source

0楼梯号不是吗？很多答案都这样认为。

— Okx

3

@Okx的任务只是将正楼梯号与正非楼梯号区分开，因此对于0和负数来说，行为是不确定的。

— 圣保罗Ebermann

Answers:

10

Haskell，55 57字节

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

与其他Haskell解决方案不同的方法。

感谢xnor节省2个字节。

— 西尔维奥·梅奥洛（Silvio Mayolo）
source

4

您可以使用此技巧来缩短let表达式。

— xnor

另一种较短的方法。做得好！+1

— qfwfq

9

Brachylog，25 21 16 14字节

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

在线尝试！

首次Brachylog提交：D ~~可能非常荒唐~~ ... 非常感谢Leaky Nun和Fatalize的鼓励，并帮助将高尔夫球从25下降到14。:) :)

— 暴民埃里克
source

7

Javascript，42 41 39 38字节

-4个字节，感谢@Shaggy和@ETHProductions

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

— 赫尔曼·L
source

2

您应该可以删除，!因为挑战没有明确指定必须返回truetrue和falsefalse，只是必须返回2个不同的值。

— 毛茸茸的

2

打高尔夫球非常好，做得很好。我认为，如果自己计算i一下，您应该可以再挤出两个字节：s=>[...s].some(d=>s%i--^d,i=s.length+1)

— ETHproductions'Jul

2

实际上，通过利用在~x == -(x+1)和上的事实x%-y == x%y，我认为您可以再得到一个：s=>[...s].some(d=>s%i++^d,i=~s.length)

— ETHproductions'Jul

6

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

— 阿德南
source

6

Haskell，60个字节

将数字作为一个整数

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

— qfwfq
source

5

Mathematica，60个字节

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

在线尝试！

@alephalpha打到48

Mathematica，48个字节

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

下一个是24120020

— J42161217
source

5

Python 2，54个字节

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

在线尝试！

— ovs
source

5

Japt，9 7字节

将输入作为字符串。

¥£%´JÃw

在ETHproductions的帮助下节省了2个字节。

说明

我们隐式地将字符串作为输入。

£   Ã

映射字符串中的每个字符。

´J

J是的Japt常数-1，并´在每次通过时将其递减1（--在JavaScript中）。因此，在第一遍，这给了我们-2。

我们使用该值对输入字符串执行模运算，该字符串将在过程中自动转换为整数。在JavaScript中x%-y，结果与相同x%y。

反转结果字符串。

¥

检查新字符串是否等于原始输入，并将结果隐式输出为布尔值。

— 毛茸茸
source

天哪(Y+2，我觉得那至少要短1个字节...

— ETHproductions'Jul

1

...并且它可以：：¥£%´JÃwx%y == x%-y

— ETHproductions'Jul

啊哈，是的，正在尝试一些不同的事情，以将计算量减少到2个字节。

— 毛茸茸的

4

Neim，6个字节

𝐧ᛖ𝕄𝐫𝐣𝔼

说明：

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

在线尝试！

— 奥克斯
source

@Thehx关于您的编辑，Neim使用自定义编码：这是

— Okx

2

果冻，7个字节

DJ‘⁸%⁼Ṛ

在线尝试！

— 暴民埃里克
source

2

Python 2，56个字节

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

在线尝试！

— 阿特耶
source

2

Perl 6，32个字节

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

在线尝试！

.comb是输入参数的字符串表示形式中的字符数$_（即数字位数）。
1 + .comb ... 2 是一个数字序列，从一个大于数字的位数一直到2。
«%«是模数超级运算符，当$_其左侧的输入参数除以其右侧序列的每个元素时，给出余数$_ % 2, $_ % 3, ...。
[~]将这些数字连接成一个新数字，并使用字符串相等运算符将其与输入参数进行比较eq。

— 肖恩
source

2

PHP，43字节

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

在线尝试！

PHP，44字节

打印1为真，否为假

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

在线尝试！

— 约格·赫尔瑟曼
source

2

Pyth，13个字节

-1个字节，感谢Okx。

qsjk_m%QhdSl`

在线尝试！

说明

             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

备用解决方案，仍为13个字节（由于karlkastor）

qi_.e%Q+2k`QT

在线尝试！这与第一个解决方案基本相同，除了它用于i将数字数组转换为数字，并且生成的范围不同。

— 吉姆
source

1

您可以替换ss`M_使用jk_，以节省2个字节。

— Okx

@Okx我需要它，因为j输出一个字符串，而我需要一个数字来与输入进行比较（这是一个数字）。

— 吉姆（Jim）

1

另一个13字节的解决方案是：qi_.e%Q+2k`QT使用枚举map（.e）代替map。然后从列表中将余数转换为以10为底的int而不是使用join。

— KarlKastor '17

2

C ++，104字节

1）原始版本：

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）以可读的形式：

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

在线尝试！

— koita_pisw_sou
source

1

Pari / GP，42字节

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

在线尝试！

— Alephalpha
source

1

Python 2中，66个60 58 57字节

感谢@Leaky修女6个字节：删除不需要的x and（不应检查0）
感谢@Einkorn Enchanter提供1个字节：使用 enumerate

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

在线尝试！

— 官方网站
source

1

如果枚举

— Wheat

谢谢。嘿，我刚刚意识到你是小麦巫师。

— Officialaimm

1

Python 3：63字节

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

如果我能数一下我希望“枚举”的时间更短的次数...

在线尝试！

— 本德尔
source

是的，我刚刚意识到它与@officialaimm给出的答案完全相同...我应该删除吗？

— bentl

他们的代码在python 2中，您独立提出了它，因此我将其保留。

— 小麦巫师

通过在2处开始枚举并重新排列逻辑，可以节省两个字节：lambda m:all(m%n==int(x)for n,x in enumerate(str(m)[::-1],2))

— nocturama

1

Java（OpenJDK 8），60字节

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

在线尝试！

非字符串版本。

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

1

Java的8，156名 149字节

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

松散

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

在线尝试！

更新：
-7个字节：删除了无用的内容{}并替换Integer.parseInt(...)为new Integer(...)
-9个字节：感谢Kevin Cruijssen，删除了一堆无用的内容()，Long代替Integer和print代替了println。谢谢凯文！

— 亚历克斯·费雷蒂
source

1

好的回答，我+1。顺便说一句，打高尔夫球的一些小事情：new Integer可以new Long（-3字节）；println可以是print（-2个字节）; 并且您可以删除括号内的内容new Long(s[0])%i+f;（-4个字节）。

— 凯文·克鲁伊森

非常好！谢谢，我会更新的！

— Alex Ferretti

1

木炭，20 15字节

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

在线尝试！-楼梯号的输出，否则为空。链接是详细版本的代码。

— 尼尔
source

0

Python 2，61字节

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

— 丹尼尔
source

不，您的新高尔夫球短了一个字节。:)

— 小麦巫师

0

q / kdb +，34个字节

解：

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

例：

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

说明：

将输入数字转换为字符串，从0..string的长度开始计数，将所有数字加2，取反，然后将每个数字mod与原始输入一起输入。将mod的结果强制转换为字符串并缩小列表，检查其是否等于输入数字的字符串：

{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

笔记：

大多数解决方案是用于生成2,3,4..列表，我还有另一种解决方案，它的工作量较少，但打完高尔夫球后却变成了37个字节：

{s~x mod'reverse 2 + til count s:("J"$) each string x} / ungolfed
{s~x mod'(|)2+til(#)s:("J"$)each($)x}                  / golfed

— 街头小贩
source

0

Clojure，75个字节

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

输入是一个字符串，使用map，结尾结尾%比for[i(range(count %))]方法短。

— 尼古妮
source

0

Haskell，62个字节

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

它没有反转模数的（无限）列表，而是通过使用整数x的反向字符串表示形式压缩列表来截断列表，然后确保该整数表示元素相等。

— 始祖鸟
source

0

Perl 5，41个字节

39个字节的代码+ 2个标志 -pa

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

在线尝试！

不输出任何楼梯编号（undef），其他则输出1

— Xcali
source

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.

Licensed under cc by-sa 3.0 with attribution required.