我们可以定义整除条纹k一批n通过寻找最小的非负整数，k这样n+k是不是整除k+1。

挑战

用您选择的语言编写输出或返回输入的可分割条纹的程序或函数。

例子：

n=13:
13 is divisible by 1 
14 is divisible by 2 
15 is divisible by 3 
16 is divisible by 4 
17 is not divisible by 5

的多样性条纹13为4

n=120:
120 is divisible by 1 
121 is not divisible by 2 

的多样性条纹120为1

测试用例：

n      DS
2      1
3      2
4      1
5      2
6      1
7      3
8      1
9      2
10     1
2521   10

在这里可以找到更多的测试用例。

笔记

• 基于Project Euler Problem 601
• 可以在OEIS上找到此序列，向下移1。

规则

• 您可以假设输入大于1。

计分

代码高尔夫：得分最低的提交者获胜。

Pyth，6 5字节

f%tQh

在线尝试！

Java 8 8，44 42 41 39字节

^{划掉44仍然是常规44;（}

n->{int r=0;for(;~-n%--r<1;);return~r;}

-2个字节，感谢@LeakyNun。
-1个字节感谢@TheLethalCoder。
-2个字节，感谢@Nevay。

说明：

在这里尝试。

n->{                 // Method with integer as parameter and return-type
  int r=0;           //  Result-integer (starting at 0)
  for(;~-n%--r<1;);  //  Loop as long as `n-1` is divisible by `r-1`
                     //   (after we've first decreased `r` by 1 every iteration)
  return~r;          //  Return `-r-1` as result integer
}                    // End of method

Haskell，35个字节

f n=[k|k<-[1..],rem(n+k)(k+1)>0]!!0

在线尝试！

使用until也是35个字节

f n=until(\k->rem(n+k)(k+1)>0)(+1)1

外壳，7个字节

ḟ§%→+⁰N

在线尝试！

05AB1E，7 6字节

Ý+āÖ0k

在线尝试！

备用7字节解决方案：
<DLÖγнg
Ls<ÑKн<

JavaScript（ES6），28个字节

n=>g=(x=2)=>++n%x?--x:g(++x)

测试一下

o.innerText=(f=

n=>g=(x=2)=>++n%x?--x:g(++x)

)(i.value=2521)();oninput=_=>o.innerText=f(+i.value)()

<input id=i><pre id=o>

Mathematica，30 27字节

0//.i_/;(i+1)∣(#+i):>i+1&

带有整数参数的未命名函数。

在Wolfram Sandbox上尝试

用法：

0//.i_/;(i+1)∣(#+i):>i+1&[2521]

10

Perl 5中，23 21 + 1（-p）= 22个字节

1until$_++%++$\}{$\--

在线尝试！

Python 2，35个字节

f=lambda n,x=1:n%x<1and-~f(n+1,x+1)

在线尝试！

Cubix，17个字节

)uUqI1%?;)qUO(;/@

在线尝试！

集中化

    ) u
    U q
I 1 % ? ; ) q U
O ( ; / @ . . .
    . .
    . .

• I1 使用输入和除数设置堆栈
• %? 做国防部和测试
  • ;)qU)uqU如果为0，则删除结果并递增输入和除数。关于返回路径的一轮回合%
  • /;(O@ 如果不为0，则丢弃结果，减除数，输出和退出

观看它运行

Python 2中，43 41个字节

感谢Leaky Nun节省了2个字节！

i=input();k=1
while~-i%-~k<1:k+=1
print k

在线尝试！

Python 2，40个字节

f=lambda i,k=1:~-i%-~k<1and f(i,k+1)or k

在线尝试！

Python 2中，44 40个字节

-4个字节，感谢Leaky Nun。

f=lambda n,x=1:~-n%-~x and x or f(n,x+1)

在线尝试！

迅捷 4，56字节

这是一个完整功能f，带有一个i用于输出输出的整数参数。

func f(i:Int){var k=0;while(i-1)%(k+1)<1{k+=1};print(k)}

在这里尝试。

迅捷 4，56字节

这是一个匿名函数，返回结果。

{var k=0;while($0-1)%(k+1)<1{k+=1};return k}as(Int)->Int

在这里尝试。

查看测试套件！

C＃（单声道），41 39字节

n=>{int r=0;while(~-n%--r<1);return~r;}

本质上来说，@ Kevin Cruijssen的Java 8答案端口以及进一步的打高尔夫球。

在线尝试！

dc，28个字节

1si[1+dli1+dsi%0=M]dsMxli1-p

在线尝试！

随着递增和最终递减，这确实感觉不是最理想，但是我真的看不出有任何改进的方法。基本上i，只要值mod i继续为零，我们就增加一个计数器和我们的初始值，一旦不正确，我们从中减去1 i并打印。

盖亚 8字节

@1Ė₌)†↺(

在线尝试！

说明

@         Push input (call it n).
 1        Push 1 (call it i).
      ↺   While...
  Ė₌       n is divisible by i:
    )†     Increment both n and i.
       (  Decrement the value of i that failed this test and print.

J，17个字节

[:{.@I.>:@i.|i.+]

在线尝试！

我认为这里仍然有打高尔夫球的空间。

解释（无胶体）

[: {.@I. >:@i. | i. + ]
                 i. + ]  Range [n,2n)
                 i.       Range [0,n)
                    +     Added to each
                      ]   n
         >:@i. | i. + ]  Divisibility test
         >:@i.            Range [1,n+1)
               |          Modulo (in J, the arguments are reversed)
                 i. + ]   Range [n,2n)
    {.@I.                Get the index of the first non-divisible
       I.                 Indices of non-zero values
    {.                    Head

使用大写（[:）来确保J不对待最后一个动词（{.@I.）视为钩子的一部分。

关于此答案的唯一奇怪的事情是，I.实际上将每个非零数字的索引重复了该数字的值多次。例如

   I. 0 1 0 2 3
1 3 3 4 4 4

但这无关紧要，因为我们还是要第一个索引（而且 i.给出了递增范围，所以我们知道第一个索引将是最小值）。

最后，这是一个非常简短的证明，仅对进行除法检查是有效的n。

我们开始检查与整除1 | n，所以假设连胜去那么远，一旦我们开始检查由整除n我们n | 2n - 1将不会为真（2n - 1 ≡ n - 1 (mod n)）。因此，条纹将在此处结束。

Japt，7个字节

õ b!%UÉ

在线测试！

x86机器代码，16个字节

49                 dec    ecx        ; decrement argument
31 FF              xor    edi, edi   ; zero counter

                Loop:
47                 inc    edi        ; increment counter
89 C8              mov    eax, ecx   ; copy argument to EAX for division
99                 cdq               ; use 1-byte CDQ with unsigned to zero EDX
F7 FF              idiv   edi        ; EDX:EAX / counter
85 D2              test   edx, edx   ; test remainder
74 F6              jz     Loop       ; keep looping if remainder == 0

4F                 dec    edi        ; decrement counter
97                 xchg   eax, edi   ; move counter into EAX for return
C3                 ret               ;  (use 1-byte XCHG instead of 2-byte MOV)

上面的函数n在ECX寄存器中使用单个参数。它计算其除数条纹，k并通过EAX寄存器返回。它符合32位快速调用调用约定，因此可以使用Microsoft或Gnu编译器轻松地从C代码进行调用。

逻辑非常简单：它仅从1开始进行迭代测试。它的功能与此处的其他大多数答案相同，但针对大小进行了手动优化。很多漂亮的1字节指令存在，包括INC，DEC，CDQ，和XCHG。硬编码的除法操作数对我们造成了一定的伤害，但并不是那么严重。

在线尝试！

PHP，34字节

for(;$argv[1]++%++$r<1;);echo$r-1;

在线尝试！

很简单。在递增每个值的同时检查每个循环的除法（mod）的其余部分，并在数字不再可分割时输出。

SOGL V0.12，8 个字节

]e.-ē⁴I\

在这里尝试！

对于一种挑战完全不同的语言来说，这还不错。

说明：

]         do .. while top of the stack is truthy
 e          push the variable E contents, by default user input
  .-        subtract the input from it
    ē       push the value of the variable E and then increase the variable
     ⁴      duplicate the item below one in the stack
      I     increase it
       \    test if divides
            if it does divide, then the loop restarts, if not, outputs POP which is `e-input`

Mathematica，40个字节

Min@Complement[Range@#,Divisors[#-1]-1]&

在线尝试！（数学）

用数学方法，当且仅当n-1可被k + 1整除时，n + k可被k + 1整除。n-1不能被n整除，所以Range@#足够多。

本来我打算使用Min@Complement[Range@#,Divisors[#-1]]-1&，但这也可以。

朱莉娅0.6.0 （47字节）（38字节）

n->(i=1;while isinteger(n/i) i+=1;n+=1 end;i-1)

n->(i=1;while n%i<1 i+=1;n+=1end;i-1)

在线尝试！

感谢Mr.Xcoder削减了9个字节

C（gcc），34个字节

i;f(n){for(i=1;++n%++i<1;);n=i-1;}

在线尝试！

批处理，70字节

@set/an=%1-1,i=0
:l
@set/ai+=1,r=n%%~i
@if %r%==0 goto l
@echo %i%

所有这一切都做的是寻找最大的i，使得LCM(1..i)分歧n-1。

[R，43个字节

function(n,k=0:n)which((n+k)%%(k+1)>0)[1]-1

匿名函数。

验证所有测试用例！

Aceto，28 27字节

[;`%
I)@]
iIk2I(D(
rk[(&Xpu

如果不必退出，我可以节省一个字节。

说明：

我们使用三个堆栈：左边的堆栈保存一个从2开始的计数器，右边的堆栈保存一个给定的数字（或其增量），中间的堆栈用于进行模运算。当然，我们可以在一个堆栈中完成所有操作，但是通过这种方式，我们可以将外部堆栈设置为“粘性”（不会真正删除弹出的值），并且可以为自己节省很多重复操作。详细方法如下：

读取一个整数，对其进行递增，使当前堆栈具有粘性，然后将其（以及我们自己）“移动”到左侧的堆栈：

iI
rk[

向左再移动一个堆栈，将文字2推入，也使该堆栈具有粘性。记住代码中的位置（@），然后再次将值和自己“移动”到中心堆栈。

  @]
  k2
   (

现在我们测试：前两个数字的模是否不为0？如果是这样，请跳到末尾，否则请向右移一叠，递增，然后将值和我们推到中间。然后转到左侧堆栈，也将其递增，然后跳回到我们之前设置的标记。

[;`%
I)
    I(
    &

当取模的结果不为零时，我们反转IP的移动位置，向左移动一个堆栈（计数器所在的位置），将其递减，然后打印该值，然后退出。

      D(
     Xpu

Ruby，34 32 31字节

f=->n,d=1{n%d<1?1+f[n+1,d+1]:0}

递归lambda。还是Ruby的新手，欢迎提出建议！

在线尝试！

F＃，86字节 84字节

let s n = 
    let rec c n1 d r=if n1%d=0 then c(n1+1)(d+1)(r+1)else r
    c n 1 0

在线尝试！

编辑：Oliver的-2个字符

Befunge，19个字节

#v_1+::&+1-\%
1<@.-

在线尝试！