Thách thức này là đủ đơn giản rằng đó là về cơ bản tất cả trong tiêu đề: bạn đang đưa ra một số nguyên dương N và bạn nên trả lại số nguyên dương nhỏ nhất mà không phải là một ước của N .

Một ví dụ: các ước của N = 24 là 1, 2, 3, 4, 6, 8, 12, 24. Số nguyên dương nhỏ nhất không có trong danh sách đó là 5 , vì vậy đó là kết quả mà giải pháp của bạn sẽ tìm thấy.

Đây là trình tự OEIS A007978 .

Quy tắc

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

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

100 điều khoản đầu tiên là:

2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 
3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 
2, 3, 2, 4, 2, 3, 2, 3, 2, 7, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 
3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3

Cụ thể, đảm bảo rằng câu trả lời của bạn hoạt động cho đầu vào 1 và 2 trong trường hợp kết quả lớn hơn đầu vào.

Và đối với một số trường hợp thử nghiệm lớn hơn:

N          f(N)
1234567    2
12252240   19
232792560  23

Mathicala, 19 byte (mã hóa UTF-8)

1//.x_/;x∣#:>x+1&

Hàm không tên lấy tham số nguyên không khác và trả về số nguyên dương. Thanh dọc khoảng nửa chừng thực sự là ký tự ba byte U + 2223, biểu thị mối quan hệ chia hết trong Mathicala. Giải trình:

1                   Starting with 1,
 //.                apply the following rule until it stops mattering:
    x_                if you see a number x
      /;x∣#           such that x divides the function argument,
           :>x+1      replace it with x+1.
                &   Cool, that's a function.

Được chỉnh sửa để thêm: ngenisis chỉ ra rằng //., theo mặc định, sẽ lặp lại tối đa 65536 lần. Vì vậy, việc triển khai này hoạt động đối với tất cả các số đầu vào nhỏ hơn bội số chung nhỏ nhất từ ​​1 đến 65538 (đặc biệt, trên tất cả các số có tối đa 28436 chữ số), nhưng về mặt kỹ thuật không phải cho tất cả các số. Người ta có thể thay thế x//.ybằng ReplaceRepeated[x,y,MaxIterations->∞]để sửa chữa lỗ hổng này, nhưng rõ ràng với chi phí của 34 byte bổ sung.

Bình thường, 3 byte

f%Q

Về cơ bản, fcác vòng lặp mã cho đến khi %QT( Q % Ttrong đó Tbiến lặp) là đúng.

Hãy thử trực tuyến tại đây.

JavaScript (ES6), 25 23 byte

f=(n,k)=>n%k?k:f(n,-~k)

Lưu ý: Một điều thú vị ở đây là ktham số được khởi tạo ex nihilo trong lần lặp đầu tiên. Điều này hoạt động vì n % undefinedlà NaN(giả như mong đợi) và -~undefinedbằng 1. Trên các lần lặp lại tiếp theo, -~kvề cơ bản là tương đương với k+1.

Kiểm tra

f=(n,k)=>n%k?k:f(n,-~k)

// first 100 terms
for(i = 1, list = []; i <= 100; i++) {
  list.push(f(i));
}
console.log(list.join(' '));

// larger test cases
console.log(f(1234567));
console.log(f(12252240));
console.log(f(232792560));

Python, 43 36 35 byte

f=lambda n,d=2:d*(n%d>0)or f(n,d+1)

Lục giác , 12 byte

\\)?}'@{!%.}

Xuất thân:

   \ \ )
  ? } ' @
 { ! % . }
  . . . .
   . . .

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

R, 28 byte

Khá đơn giản, không có gì lạ mắt. Lấy đầu vào từ stdin, tăng giá trị Tcho đến khi imodulo Tlà khác không.

i=scan()
while(!i%%T)T=T+1
T

Nếu bạn muốn một cái gì đó lạ mắt hơn một chút, có 29 byte sau:

i=scan()
match(0,!i%%1:(i+1))

Giải thích:

i=scan(): Đọc itừ stdin.

1:(i+1): Tạo tất cả các số nguyên từ 1đến i+1( +1kế toán cho các trường hợp 1và 2).

i%%1:(i+1) : Modulo đầu vào theo mỗi số trong danh sách của chúng tôi.

!i%%1:(i+1): Phủ định danh sách kết quả; này mặc nhiên chuyển đổi nó thành một loại logic, như vậy 0là FALSEvà khác không là TRUE. Sau khi phủ định, TRUEcác giá trị trở thành FALSEvà ngược lại. Bây giờ, tất cả các giá trị khác không ban đầu được mã hóa là FALSE.

match(0,!i%%1:(i+1)): Trả về chỉ mục của phiên bản đầu tiên 0trong danh sách của chúng tôi. 0là FALSE, vì vậy, điều này trả về chỉ mục của cái đầu tiên FALSEtrong danh sách, là giá trị khác không đầu tiên từ hoạt động modulo. Vì danh sách ban đầu của chúng tôi bắt đầu vào 1, chỉ số bằng với giá trị của số không chia nhỏ nhất.

Haskell, 26 byte

f n=until((>0).mod n)(+1)1

Mọi người quên mất until!

Brachylog , 10 byte

~{=#>:A'*}

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

Điều này xuất hiện rất giống với (nhưng ngắn hơn) giải pháp ban đầu của Fatalize. Fatalize đã chuyển sang một thuật toán khác có liên kết với thuật toán này thông qua một phương thức khác, vì vậy tôi sẽ phải tự giải thích nó:

~{=#>:A'*}
~{       }    inverse of the following function:
  =           try possible values for the input, if it's unbound
   #>         the input is a positive integer
     :A'*     there is no A for which the input times A is the output

Khi chúng ta đảo ngược hàm, bằng cách hoán đổi "đầu vào" và "đầu ra", chúng ta sẽ nhận được một thuật toán khá hợp lý (chỉ diễn đạt một cách khó xử): "thử các số nguyên dương có thể, theo thứ tự tự nhiên của chúng (tức là 1 trở lên), cho đến khi bạn tìm thấy một thứ không thể được nhân lên bởi bất cứ thứ gì để tạo ra đầu vào ". Brachylog không thực hiện tính toán dấu phẩy động trừ khi tất cả các đầu vào được biết đến, vì vậy nó sẽ chỉ xem xét số nguyên A.

Brachylog , 11 10 byte

,.=:?r'%0'

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

Giải trình

,.=           Assign an integer to the output
 . :?r'%0     Input mod Output ≠ 0
        0'    Output ≠ 0

COW, 174 byte

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

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

Mã này chỉ là một phần của riêng tôi - nó thực hiện một thuật toán mô đun mà tôi đã chuyển từ brainfuck. Phần còn lại của mã là của riêng tôi. Tuy nhiên, vì tôi không viết thuật toán mô đun, tôi chưa thực sự nghiên cứu cách thức hoạt động của nó và không thể ghi lại phần đó của mã. Thay vào đó, tôi sẽ đưa ra sự cố thông thường của mình, theo sau là một lời giải thích sâu hơn về lý do tại sao mã hoạt động.

Sự cố mã

oom                          ;Read input into [0].
MOO                          ;Loop while [0].  We never change [0], so the program only terminates forcibly after a print.
  MMMmoOmoOmoOMMMmOomOo      ; Copy [0] to [3] and navigate to [1].
  MoOMMMmoOmoOmoOMMM         ; Increment [1], and copy it to [4]
  mOo                        ; Navigate back to [3].
  MOO                        ; Modulus algorithm.  Direct port of brainfuck algorithm.
    moOMOomoOMoOmOo
    MOO
      moO
    moo
    moO
    MOO
      mOoMoOmoOMOo
    moo
    mOomOo
    MOO
      mOo
    moo
    moOMOo
  moo                        ; End modulus algorithm.
  moOmoO                     ; Navigate to [5].  This contains our modulus.
  MOO                        ; Only perform these operations if [5] is non-zero -- i.e. [0] % [1] != 0
    mOomOomOomOoOOMOOOMOomOO ;  Navigate to [1], print its contents, then error out.
  moo                        ; End condition
  mOomOomOomOomOo            ; Since we're still running, [0] % [1] == 0, so navigate back to [0] and try again.
moo                          ;End main loop.

Giải trình

Mã đầu tiên đọc số nguyên vào [0]. Mỗi lần lặp của vòng lặp chính (dòng 2 đến 26) tăng [1], sau đó sao chép mọi thứ cần thiết sang thuật toán mô đun, đưa ra kết quả của nó vào [5]. Nếu [5] chứa bất kỳ giá trị nào, thì [1] là số chúng tôi cần in. Chúng tôi in nó, và sau đó buộc phải thoát khỏi chương trình.

Vì COW là một dẫn xuất brainfuck, nó hoạt động tương đối giống với cách thức hoạt động của brainfuck - dải băng vô hạn, bạn có thể di chuyển sang trái hoặc phải, tăng hoặc giảm và "vòng lặp" trong khi giá trị băng hiện tại khác không. Ngoài brainfuck, COW đi kèm với một vài tính năng hữu ích.

(0) moo -- Equivalent to ]
(1) mOo -- Equivalent to <
(2) moO -- Equivalent to >
(3) mOO -- No equivalent.  Evaluate current tape value as instruction from this list.
(4) Moo -- If tape is 0, equivalent to ,; if tape is non-zero, equivalent to .
(5) MOo -- Equivalent to -
(6) MoO -- Equivalent to +
(7) MOO -- Equivalent to [
(8) OOO -- No equivalent.  Set tape (positive or negative) to 0
(9) MMM -- No equivalent.  If register is empty, copy tape to register.  If register is non-empty, paste register to tape and clear register.
(10) OOM -- No equivalent.  Print an integer from tape to STDOUT
(11) oom -- No equivalent.  Read an integer from STDIN and store it on tape

Điểm quan tâm thực sự ở đây là hướng dẫn 3 , mOO. Trình thông dịch đọc giá trị băng hiện tại và thực hiện một lệnh dựa trên giá trị băng đó. Nếu giá trị nhỏ hơn 0, lớn hơn 11 hoặc bằng 3, trình thông dịch sẽ chấm dứt chương trình. Chúng ta có thể sử dụng điều này như một lực lượng nhanh chóng và bẩn thỉu thoát khỏi vòng lặp chính (và hoàn toàn là chương trình) một khi chúng ta đã tìm thấy người không chia số. Tất cả những gì chúng ta phải làm là in số của mình, xóa [1] (với OOO), giảm số đó thành -1 với MOo, và sau đó thực hiện lệnh -1 qua mOOđó kết thúc chương trình.

Bản thân băng cho chương trình này hoạt động như sau:

[0]  -- Read-in integer from STDIN.
[1]  -- Current divisor to test
[2]  -- Placeholder for modulus algorithm
[3]  -- Temporary copy of [0] for use for modulus algorithm
[4]  -- Temporary copy of [1] for use for modulus algorithm
[5]  -- Placeholder for modulus algorithm.  Location of remainder at end of loop.
[6]  -- Placeholder for modulus algorithm
[7]  -- Placeholder for modulus algorithm

Thuật toán mô đun tự nhiên xóa [2], [3], [6] và [7] khi kết thúc hoạt động. Nội dung của [4] bị ghi đè bằng thanh ghi trên dòng 4 và [5] bằng 0 khi [0] chia hết cho [1], vì vậy chúng tôi không phải xóa nó. Nếu [5] khác không, chúng tôi buộc phải thoát khỏi dòng 23 vì vậy chúng tôi không phải lo lắng về điều đó.

05AB1E , 7 byte

Xµ¹NÖ_½

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

Giải trình

Xµ       # run until counter is 1
  ¹      # push input
   N     # push iteration counter
    Ö_   # push input % iteration counter != 0
      ½  # if true, increase counter
         # output last iteration

Thạch , 5 byte

1%@#Ḣ

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

Giải trình:

1%@#Ḣ
1  #      Find the first … numbers, counting up from 1, such that
 %@       dividing those numbers into … gives a truthy remainder
    Ḣ     then return the first

Đây là một sự lạm dụng khủng khiếp #; có rất nhiều toán tử trong chương trình này, nhưng một tấn toán hạng bị thiếu. #thực sự muốn 1được đưa ra một cách rõ ràng vì một số lý do (nếu không nó cố gắng mặc định cho đầu vào); tuy nhiên, mọi thứ khác không được chỉ định trong chương trình đều mặc định là đầu vào của chương trình. (Ví dụ: nếu bạn cung cấp 24 làm đầu vào, chương trình này sẽ tìm thấy 24 số đầu tiên không chia 24, sau đó trả về số đầu tiên; loại lãng phí, nhưng nó hoạt động.)

C, 32 35 byte

i;f(x){for(i=1;x%++i<1;);return i;}

Chỉnh sửa: thêm i=1vào vòng lặp

Sử dụng

main(c,v)char**v;{printf("%d",f(atoi(*++v)));}

Phiên bản chương trình đầy đủ, 64 byte:

main(c,v)char**v;{*++v;for(c=1;atoi(*v)%++c<1;);printf("%d",c);}

C #, 39 37 byte

n=>{int i=0;while(n%++i<1);return i;}

Lưu hai byte nhờ Martin!

Perl, 19 byte

18 byte mã + -pcờ.

$_=$_%++$.?$.:redo

Để chạy nó:

perl -pE '$_=$_%++$.?$.:redo' <<< 12252240

Giải thích không chi tiết :
- $.là một biến đặc biệt có giá trị mặc định là số dòng hiện tại của tệp cuối cùng được truy cập (stdin ở đây), vì vậy sau khi đọc dòng đầu tiên đầu tiên, nó được đặt thành 1.
- $_giữ đầu vào và được in ngầm ở cuối (nhờ -pcờ).
- redo(trong bối cảnh đó) xem xét rằng chương trình đang trong một vòng lặp và làm lại lần lặp hiện tại (chỉ $.sẽ khác nhau kể từ khi nó được tăng lên).
- Vì vậy, nếu chúng tôi tìm thấy số nhỏ nhất (được lưu trữ $.) không phân chia $_, thì chúng tôi sẽ đặt số $_đó, nếu không, chúng tôi sẽ thử số tiếp theo (nhờ redo).

Octave / MATLAB, 26 24 byte

@(n)find(mod(n,1:n+1),1)

find(...,1)trả về chỉ mục ( 1dựa trên cơ sở) của phần tử khác không đầu tiên của vectơ trong đối số đầu tiên. Đối số đầu tiên là [n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]Điều đó có nghĩa là chúng ta phải thêm +1vào chỉ mục, vì chúng ta bắt đầu thử nghiệm tại 1. Cảm ơn @Giuseppe cho -2 byte.

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

Thạch , 6 byte

%R;‘TḢ

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

Giải trình:

                                               Assume 24 is our N
 R      Generate all numbers from 1 to N         [1, 2, 3, 4 .., 24]
  ;‘    Attach N+1 to that list (for cases 1,2)  [1, 2, 3, 4 .., 25]
%       And modulo-divide our input by it
        Yields a list with the remainder         [0, 0, 0, 0, 4 ...]
    T   Return all thruthy indexes               [5, 7, ...]
     Ḣ  Takes the first element of that list -->  5

Perl 6 , 17 byte

{first $_%*,1..*}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  # return the first value
  first

  # where the block's argument ｢$_｣ modulus the current value ｢*｣
  # doesn't return 0 ( WhateverCode lambda )
  $_ % *,
  # ( ｢$_ !%% *｣ would be the right way to write it )

  # from 1 to Whatever
  1 .. *
}

05AB1E , 6 byte

ÌL¹ÑK¬

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

Ngoài ra, nó đánh vần "LINK!" ... Kinda ...

ÌL     # Push [1..n+2]
  ¹Ñ   # Push divisors of n.
    K¬ # Push a without characters of b, and take first item.

Thạch , 5 byte

‘ḍ€i0

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

Làm thế nào nó hoạt động

‘ḍ€i0  Main link. Argument: n

‘      Increment; yield n+1.
 ḍ€    Divisible each; test 1, ..., n+1 for divisibility by n.
   i0  Find the first index of 0.

Python 2.7.9, 32 byte

f=lambda n,d=1:n%d>0or-~f(n,d+1)

Thử nghiệm trên Ideone

Đệ quy đếm lên những người không ước tính tiềm năng d. Nó ngắn hơn để đệ quy kết quả tăng hơn so với đầu ra d. Một giá trị bù 1được đạt được bởi Boolean của True, bằng 1, nhưng vì d==1luôn luôn là một ước số, đầu ra luôn được chuyển đổi thành một số.

Python 2.7.9 được sử dụng để cho phép 0or. Các phiên bản bắt đầu 2.7.10 sẽ cố phân tích cú pháp 0orlà bắt đầu của một số bát phân và đưa ra lỗi cú pháp. Xem cái này trên Ideone .

Trên thực tế , 7 byte

;÷@uR-m

Hãy thử trực tuyến! (lưu ý: đây là một giải pháp rất chậm và sẽ mất nhiều thời gian cho các trường hợp thử nghiệm lớn)

Giải trình:

;÷@uR-m
;÷       duplicate N, divisors
  @uR    range(1, N+2)
     -   set difference (values in [1, N+1] that are not divisors of N)
      m  minimum

Haskell , 29 byte

f n=[k|k<-[2..],mod n k>0]!!0

Biểu thức [k|k<-[2..]]chỉ tạo ra một danh sách vô hạn [2,3,4,5,...]. Với điều kiện mod n k>0chúng tôi chỉ cho phép những người ktrong danh sách không phân chia n. Áp dụng !!0chỉ trả về mục đầu tiên (mục nhập tại chỉ mục 0) hình thành danh sách đó.

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

APL Dyalog , 8 byte

1⍳⍨0≠⍳|⊢

1⍳⍨ vị trí đầu tiên Đúng trong

0≠ các giá trị khác không của

⍳|phần dư của 1 ... N khi chia cho

⊢ VIẾT SAI RỒI

Dùng thử trực tuyến!

Lưu ý: điều này hoạt động cho 1 và 2 vì 1⍳⍨trả về 1 + độ dài của đối số nếu không tìm thấy.

julia, 28 byte

N->findfirst(x->N%x>0,1:N+2)

Lưu ý: vì 1:N+2không cấp phát bộ nhớ nên không có vấn đề về bộ nhớ cho Ns lớn
- @flawr N+2lưu cho tôi một số byte
- Đề xuất của @Martin đã lưu 1 byte

QBIC , 14 byte

:[a+1|~a%b|_Xb

Giải trình:

:      Read the first cmd line param as a number, called 'a'
[a+1|  FOR (b=1 ; b <= a+1; b++) <-- a+1 for cases a = 1 or 2
~a%b   IF A modulo B ( == 0, implicit)
|_Xb   THEN exit the program, printing b
       [IF and FOR implicitly closed by QBIC]

PHP, 30 byte

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

nếu chạy từ bàn điều khiển với -rtùy chọn (thx đến @ ais523)

php -r 'for(;$argv[1]%++$i<1;);echo$i;' 232792560

32 byte

<?for(;$argv[1]%++$i<1;);echo$i;

cảm ơn @manatwork vì đã xóa 1 byte

33 byte (bản gốc)

<?for(;$argv[1]%++$i==0;);echo$i;

Khối , 14 12 byte

I2/L/);?%<@O

Đã lưu 2 byte nhờ MickyT.

Thử nó

Giải trình

Ở dạng khối, mã là:

    I 2
    / L
/ ) ; ? % < @ O
. . . . . . . .
    . .
    . .

Về cơ bản, điều này chỉ cần đầu vào và bắt đầu một bộ đếm. Sau đó, nó kiểm tra từng giá trị liên tiếp của bộ đếm cho đến khi tìm thấy giá trị không phải là yếu tố đầu vào.

> <> , 15 +3 = 18 byte

1\n;
?\1+:{:}$%

Đầu vào dự kiến ​​sẽ nằm trên ngăn xếp khi bắt đầu chương trình, vì vậy +3 byte cho -vcờ. Hãy thử trực tuyến!

Sứa , 12 10 byte

p\~~|1
 >i

Lấy đầu vào từ STDIN và đầu ra thành STDOUT. Hãy thử trực tuyến!

Martin Ender đã lưu 2 byte, cảm ơn!

Giải trình

 \~~|
 >i

Phần này là một hàm sử dụng giá trị đầu vào trong định nghĩa của nó.

   ~|

Hàm ~-cell này được cung cấp một hàm, vì vậy nó lật các đối số của nó: nó tạo ra hàm nhị phân "đối số bên phải modulo ( |) đối số phải". Hàm modulo tích hợp trong Jellyfish đưa các đối số của nó theo thứ tự ngược lại.

  ~~|
  i

Đây ~-cell được gán giá trị và chức năng, vì vậy nó không áp dụng từng phần: nó tạo ra các chức năng nhị phân "đầu vào ( i) lập luận đúng modulo". Hãy gọi hàm đó là f .

 \~~|
 >i

Hàm \-cell được cung cấp hai hàm, do đó, nó lặp đi lặp lại: nó tạo ra hàm unary "tăng ( >) cho đến khi hàm f áp dụng cho các giá trị hiện tại và giá trị hiện tại cho kết quả trung thực (khác không), sau đó trả về giá trị hiện tại". Điều này có nghĩa là đối số được tăng lên cho đến khi nó không phân chia đầu vào.

p\~~|1
 >i

Cuối cùng, chúng tôi áp dụng hàm này cho giá trị ban đầu 1và in kết quả với p.