Chuỗi phân chia

31

Chúng ta có thể xác định Streak chia hết kcủa một số nbằng cách tìm các không âm nhỏ nhất số nguyên knhư vậy mà n+kkhông chia hết cho k+1.

Thử thách

Trong ngôn ngữ bạn chọn, hãy viết chương trình hoặc chức năng xuất ra hoặc trả về Chuỗi phân chia của đầu vào của bạn.

Ví dụ:

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

Chuỗi phân chia 13là4

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

Chuỗi phân chia 120là1

Các trường hợp thử nghiệm:

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

Nhiều trường hợp thử nghiệm có thể được tìm thấy ở đây .

Ghi chú

Quy tắc

  • Bạn có thể giả sử đầu vào lớn hơn 1.

Chấm điểm

code-golf : Bài nộp có số điểm thấp nhất sẽ thắng.

code-golf  number  division 
— Oliver
nguồn
Tôi đề nghị thay đổi "số nguyên dương nhỏ nhất" thành "số nguyên không âm nhỏ nhất". Nó hoàn toàn không thay đổi thử thách, nhưng với mô tả hiện tại, nó ngụ ý rằng chúng ta không cần phải kiểm tra mức độ chia hết cho 1 (mà về mặt kỹ thuật chúng ta không cần phải làm). Hoặc, hoặc bạn có thể loại bỏ tính phân chia bằng 1 kiểm tra khỏi mô tả.
— TehPers
Số nguyên dương nhỏ nhất là 1 và k + 1là 2, trong đó ksố nguyên dương nhỏ nhất. Xin lỗi cho nitpick.
— TehPers
Đây không giống như tìm kiếm nhỏ nhất kmà không phân chia n-1?
— Paŭlo Ebermann
@ PaŭloEbermann Đi n=7đâu k=3: n-1chia hết cho k.
— Oliver
Ah, tôi đã bỏ lỡ +1.
— Paŭlo Ebermann

Câu trả lời:

17

Java 8, 44 42 41 39 byte

Vượt qua 44 vẫn là 44 thường xuyên (

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

-2 byte nhờ @LeakyNun .
-1 byte nhờ @TheLethalCoder .
-2 byte nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây.

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
— Kevin Cruijssen
nguồn
1
— Leaky Nun
1
41 byte Chỉ cần cạo một byte từ đề xuất của LeakyNun.
— TheLethalCoder
2
— Nevay
4

JavaScript (ES6), 28 byte

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

Kiểm tra nó

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>
Mở rộng đoạn trích

— Xù xì
nguồn
3

Khối , 17 byte

)uUqI1%?;)qUO(;/@

Hãy thử trực tuyến!

Tạo khối

    ) u
    U q
I 1 % ? ; ) q U
O ( ; / @ . . .
    . .
    . .
  • I1 thiết lập ngăn xếp với đầu vào và ước số
  • %? làm mod và kiểm tra
    • ;)qU)uqUnếu 0 loại bỏ kết quả và đầu vào tăng và ước. Một chút về con đường để quay trở lại%
    • /;(O@ nếu không 0, thả kết quả, ước số giảm, đầu ra và thoát

Xem nó chạy

— MickyT
nguồn
2

dc , 28 byte

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

Hãy thử trực tuyến!

Điều này cảm thấy thực sự không tối ưu, với sự gia tăng và giảm dần cuối cùng, nhưng tôi thực sự không thể thấy một cách để cải thiện nó. Về cơ bản, chúng tôi chỉ tăng một bộ đếm ivà giá trị bắt đầu của chúng tôi miễn là mod giá trị itiếp tục bằng không, và một khi điều đó không đúng, chúng tôi trừ đi một ivà in.

— brhfl
nguồn
2

Gaia , 8 byte

@1Ė₌)†↺(

Hãy thử trực tuyến!

Giải trình

@         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.
— Mèo kinh doanh
nguồn
2

J, 17 byte

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

Hãy thử trực tuyến!

Tôi nghĩ vẫn còn chỗ để chơi gôn ở đây.

Giải thích (vô danh)

[: {.@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

Giới hạn ( [:) ở đó để đảm bảo rằng J không xử lý động từ cuối cùng ({.@I. ) là một phần của hook.

Điều kỳ lạ duy nhất về câu trả lời này là I.thực sự sao chép chỉ số của mỗi số khác không nhiều lần so với giá trị của số đó. ví dụ

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

Nhưng nó không thành vấn đề vì chúng tôi muốn chỉ số đầu tiên dù sao (và vì i.đưa ra một phạm vi tăng dần, chúng tôi biết chỉ số đầu tiên sẽ là giá trị nhỏ nhất).

Cuối cùng, đây là một bằng chứng rất ngắn rằng nó chỉ hợp lệ để kiểm tra phân chia tối đa n.

Chúng tôi bắt đầu kiểm tra tính chia hết với 1 | n, vì vậy, giả sử chuỗi đó đi xa đến mức, một khi chúng tôi kiểm tra tính phân chia bằng cách nchúng tôi n | 2n - 1sẽ không bao giờ đúng ( 2n - 1 ≡ n - 1 (mod n)). Do đó, vệt sẽ kết thúc ở đó.

— cole
nguồn
2

Mã máy x86, 16 byte

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)

Hàm trên có một tham số duy nhất n, trong thanh ECXghi. Nó tính toán chuỗi phân chia của nó kvà trả về thông qua thanh EAXghi. Nó phù hợp với quy ước gọi fastcall 32 bit , do đó có thể dễ dàng gọi được từ mã C bằng cách sử dụng trình biên dịch Microsoft hoặc Gnu.

Logic khá đơn giản: nó chỉ thực hiện một bài kiểm tra lặp lại bắt đầu từ 1. Nó giống hệt với hầu hết các câu trả lời khác ở đây, nhưng được tối ưu hóa bằng tay cho kích thước. Rất nhiều đẹp hướng dẫn 1-byte có, bao gồm INC, DEC, CDQ, và XCHG. Các toán hạng được mã hóa cứng để phân chia làm tổn thương chúng ta một chút, nhưng không quá tệ.

Hãy thử trực tuyến!

— Cody xám
nguồn
2

PHP , 34 byte

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

Hãy thử trực tuyến!

Đủ đơn giản. Kiểm tra phần còn lại của phép chia (mod) mỗi vòng lặp trong khi tăng từng giá trị, xuất ra khi số không chia hết được nữa.

— Xanderhall
nguồn
1

SOGL V0.12 , 8 byte

]e.-ē⁴I\

Hãy thử nó ở đây!

Không tệ cho một ngôn ngữ được tạo ra cho một loại thử thách hoàn toàn khác.

Giải trình:

]         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`
— dzaima
nguồn
1

Toán học, 40 byte

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

Hãy thử trực tuyến! (Toán học)

Phương pháp toán học, n + k chia hết cho k + 1 khi và chỉ khi n - 1 chia hết cho k + 1. Và n-1 không chia hết cho n, vậy Range@#là đủ số.

Ban đầu tôi định sử dụng Min@Complement[Range@#,Divisors[#-1]]-1&, nhưng cái này cũng có tác dụng.

— người dùng202729
nguồn
Tại sao hình ảnh xác thực xuất hiện khi tôi sử dụng trình từ tio?
— dùng202729
1
Bởi vì bạn đã gõ (sao chép và dán) nó quá nhanh. Đó không phải là về TIO.
— Nữ tu rò rỉ
1

Julia 0.6.0 (47 byte) (38 byte)

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)

Hãy thử trực tuyến!

9 byte đã bị cắt nhờ Mr.Xcoder

— Goysa
nguồn
2
Thông thường, liên kết "Dùng thử trực tuyến" cho phép mọi người thực sự thử mã bằng cách xác định một số kết hợp của tiêu đề, chân trang và đối số có nghĩa là nhấn nút phát sẽ cho đầu ra.
— Peter Taylor
@PeterTaylor Bằng một phỏng đoán thuần túy, tôi đã thử chạy nó như vậy , và thật ngạc nhiên là nó đã hoạt động. Tôi khuyên OP nên chỉnh sửa bằng phiên bản thử nghiệm.
— Ông Xcoder
46 byte (xóa một khoảng n->(i=1;while isinteger(n/i) i+=1;n+=1end;i-1)
— trắng
Một dự đoán thuần túy khác được phép đánh gôn xuống còn 38 byte:n->(i=1;while n%i<1 i+=1;n+=1end;i-1)
— Ông Xcoder
@PeterTaylor Xin lỗi đã quên nó!
— Goysa
1

Mẻ, 70 byte

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

Tất cả điều này đang làm là tìm ra lớn nhất inhư vậy mà LCM(1..i)chia n-1.

— Neil
nguồn
1

Aceto , 28 27 byte

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

Tôi có thể lưu một byte nếu tôi không phải thoát.

Giải trình:

Chúng tôi sử dụng ba ngăn xếp: Ngăn xếp bên trái giữ một bộ đếm bắt đầu từ 2, ngăn bên phải giữ số đã cho (hoặc số gia của nó), ngăn xếp trung tâm được sử dụng để thực hiện các thao tác modulo. Tất nhiên chúng ta có thể làm mọi thứ trong một ngăn xếp, nhưng bằng cách này, chúng ta có thể đặt các ngăn xếp bên ngoài thành "dính" (các giá trị được bật lên không thực sự bị loại bỏ) và tiết kiệm cho chúng ta nhiều thao tác sao chép. Đây là phương pháp chi tiết:

Đọc một số nguyên, tăng nó, làm cho ngăn xếp hiện tại dính và "di chuyển" nó (và chính chúng ta) sang ngăn xếp bên trái:

iI
rk[

Đi thêm một chồng sang trái, đẩy 2 chữ, làm cho ngăn xếp này cũng dính. Ghi nhớ vị trí này trong mã ( @) và "di chuyển" một giá trị và chính chúng ta vào ngăn xếp trung tâm một lần nữa.

  @]
  k2
   (

Bây giờ chúng tôi kiểm tra: Là modulo của hai số đầu không phải là 0? Nếu vậy, nhảy đến cuối, nếu không hãy đi một chồng sang phải, tăng dần và đẩy giá trị và chúng ta vào giữa. Sau đó, đi đến ngăn xếp bên trái, cũng tăng nó và nhảy trở lại dấu mà chúng ta đã đặt trước đó.

[;`%
I)
    I(
    &

Khi kết quả của modulo không bằng 0, chúng ta đảo ngược vị trí IP đang di chuyển, đi một chồng sang trái (nơi bộ đếm của chúng ta sống), giảm giá trị và in giá trị, sau đó thoát.

      D(
     Xpu
— L3viathan
nguồn
1

Ruby, 34 32 31 byte

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

Một lambda đệ quy. Vẫn còn mới đối với Ruby, vì vậy các đề xuất đều được chào đón!

Hãy thử trực tuyến!

— Yytsi
nguồn
1

F#, 86 bytes 84 bytes

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

Try it online!

Edit: -2 characters from Oliver

— Vladislav Khapin
nguồn
Welcome to PPCG! Does your program take stdin? You can use TIO, which has an online F# interpreter. Also, can remove the whitespace in r = if?
— Oliver
1
@Oliver Thank you, I changed the link to TIO, so now you can actually pass the argument to test it. :)
— Vladislav Khapin
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.