เราสามารถกำหนดริ้วหารkของจำนวนnโดยการหาที่ไม่ใช่เชิงลบที่เล็กที่สุดจำนวนเต็มkดังกล่าวว่าไม่หารด้วยn+kk+1

ท้าทาย

ในภาษาที่คุณเลือกเขียนโปรแกรมหรือฟังก์ชั่นที่ส่งออกหรือส่งกลับ Divisibility Streak ของอินพุตของคุณ

ตัวอย่าง:

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

ริ้ว Divisibilty ของ13เป็น4

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

ริ้ว Divisibilty ของ120เป็น1

กรณีทดสอบ:

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

กรณีทดสอบเพิ่มเติมสามารถพบได้ที่นี่

หมายเหตุ

• ตามปัญหาของโครงการออยเลอร์ 601
• ลำดับนี้สามารถพบได้ในOEISเลื่อนลง 1

กฎระเบียบ

• คุณสามารถสันนิษฐานว่าอินพุตมีค่ามากกว่า 1

เกณฑ์การให้คะแนน

code-golf : การส่งที่มีคะแนนต่ำสุดชนะ

Pyth , 6 5 ไบต์

f%tQh

ลองออนไลน์!

Java 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

Husk , 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(;/@

ลองออนไลน์!

Cubified

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

• I1 ตั้งค่าสแต็กด้วยอินพุตและตัวหาร
• %? ทำ mod และทดสอบ
  • ;)qU)uqUถ้า 0 ลบผลลัพธ์และการเพิ่มอินพุตและตัวหาร บิตของรอบเกี่ยวกับเส้นทางเพื่อกลับไป%
  • /;(O@ ถ้าไม่ใช่ 0 ให้ดรอปผลลัพธ์ตัวหารที่ลดลงเอาต์พุตและทางออก

ดูมันทำงาน

Python 2 , 43 41 ไบต์

บันทึก 2 ไบต์ขอบคุณLeaky Nun !

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)

ลองออนไลน์!

Swift 4 , 56 bytes

นี่คือฟังก์ชั่นเต็มรูปแบบfด้วยพารามิเตอร์จำนวนเต็มที่iพิมพ์ออก

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

ลองที่นี่

Swift 4 , 56 bytes

นี่คือฟังก์ชั่นนิรนามที่ส่งคืนผลลัพธ์

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

ลองที่นี่

ตรวจสอบชุดทดสอบ!

C # (Mono) , 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และค่าเริ่มต้นของเราตราบใดที่ตัวดัดแปลงมูลค่าiยังคงเป็นศูนย์และเมื่อไม่เป็นความจริงเราก็ลบหนึ่งiและพิมพ์

Gaiaขนาด 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.+]

ลองออนไลน์!

ฉันคิดว่ายังมีพื้นที่สำหรับเล่นกอล์ฟที่นี่

คำอธิบาย (ungolfed)

[: {.@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)) ดังนั้นแนวจะสิ้นสุดที่นั่น

Japtap , 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 บิตดังนั้นจึงสามารถโทรจากรหัส C ได้อย่างง่ายดายโดยใช้คอมไพเลอร์ Microsoft หรือ Gnu

ตรรกะนั้นค่อนข้างเรียบง่าย: มันแค่ทำการทดสอบซ้ำเริ่มจาก 1 มันมีฟังก์ชั่นเหมือนกับคำตอบส่วนใหญ่ที่นี่ แต่เหมาะสำหรับขนาดมือ จำนวนมากคำแนะนำที่ดี 1 ไบต์มีรวมทั้งINC, DEC, และCDQ XCHGตัวถูกดำเนินการแบบ hard-coded สำหรับการแบ่งทำให้เราเจ็บปวดเล็กน้อย

ลองออนไลน์!

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]&

ลองออนไลน์! (Mathics)

วิธีการทางคณิตศาสตร์, n + k สามารถหารด้วย k + 1 ถ้าและต่อเมื่อ n-1 หารด้วย k + 1 และ n-1 ไม่สามารถหารด้วย n ได้ดังนั้นจึงRange@#มีจำนวนเพียงพอ

เดิมทีฉันตั้งใจจะใช้Min@Complement[Range@#,Divisors[#-1]]-1&แต่ก็ใช้ได้เช่นกัน

Julia 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)

ลองออนไลน์!

9 ไบต์ถูกตัดโดย Mr.Xcoder

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}

แลมบ์ดาแบบเรียกซ้ำ ยังใหม่กับ 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

ลองออนไลน์!

แก้ไข: -2 ตัวละครจาก Oliver

Befungeขนาด 19 ไบต์

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

ลองออนไลน์!