Tantangan ini cukup sederhana bahwa pada dasarnya semua dalam judul: Anda diberi positif bilangan bulat N dan Anda harus kembali bilangan bulat positif terkecil yang bukan merupakan pembagi dari N .

Contoh: pembagi N = 24 adalah 1, 2, 3, 4, 6, 8, 12, 24. Bilangan bulat positif terkecil yang tidak ada dalam daftar itu adalah 5 , jadi itulah hasil solusi Anda.

Ini adalah urutan OEIS A007978 .

Aturan

Anda dapat menulis program atau fungsi dan menggunakan salah satu metode standar kami untuk menerima input dan memberikan output.

Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

Ini adalah kode-golf , sehingga jawaban terpendek yang valid - diukur dalam byte - menang.

Uji Kasus

100 istilah pertama adalah:

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

Khususnya, pastikan jawaban Anda berfungsi untuk input 1 dan 2 yang hasilnya lebih besar dari input.

Dan untuk beberapa kasus uji yang lebih besar:

N          f(N)
1234567    2
12252240   19
232792560  23

Mathematica, 19 byte (pengkodean UTF-8)

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

Fungsi tanpa nama mengambil argumen integer nol dan mengembalikan integer positif. Bilah vertikal sekitar setengah jalan sebenarnya adalah karakter tiga byte U + 2223, yang menunjukkan hubungan yang dapat dibagi dalam Mathematica. Penjelasan:

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.

Diedit untuk menambahkan: ngenisis menunjukkan bahwa //., secara default, akan mengulang maksimal 65536 kali. Jadi implementasi ini bekerja untuk semua bilangan input yang kurang dari kelipatan bilangan bulat paling umum dari 1 hingga 65538 (khususnya, pada semua angka dengan paling banyak 28436 digit), tetapi secara teknis tidak untuk semua angka. Seseorang dapat mengganti x//.ydengan ReplaceRepeated[x,y,MaxIterations->∞]untuk memperbaiki kekurangan ini, tetapi jelas dengan biaya 34 byte tambahan.

Pyth, 3 byte

f%Q

Pada dasarnya, floop kode sampai %QT(di Q % Tmana Tvariabel iterasi) benar.

Cobalah online di sini.

JavaScript (ES6), 25 23 byte

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

Catatan: Satu hal yang menarik di sini adalah bahwa kparameter diinisialisasi ex nihilo pada iterasi pertama. Ini bekerja karena n % undefinedmerupakan NaN(falsy seperti yang diharapkan) dan -~undefinedsederajat 1. Pada iterasi berikutnya, -~kpada dasarnya setara dengan k+1.

Uji

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)

Hexagony , 12 byte

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

Diwarnai:

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

Cobalah online!

R, 28 byte

Cukup mudah, tidak ada yang mewah. Mengambil input dari stdin, nilai kenaikan Thingga imodulo Tbukan nol.

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

Jika Anda menginginkan sesuatu yang sedikit lebih mewah, berikut ini ada 29 byte :

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

Dijelaskan:

i=scan(): Baca idari stdin.

1:(i+1): Hasilkan semua bilangan bulat dari 1ke i+1( +1akuntansi untuk kasus 1dan 2).

i%%1:(i+1) : Modulo input dengan setiap nomor dalam daftar kami.

!i%%1:(i+1): Meniadakan daftar yang dihasilkan; ini secara implisit mengkonversi ke jenis logis, sehingga 0adalah FALSEdan nol adalah TRUE. Setelah negating, TRUEnilai menjadi FALSEdan sebaliknya. Sekarang, semua nilai awalnya bukan nol dikodekan sebagai FALSE.

match(0,!i%%1:(i+1)): Kembalikan indeks instance pertama 0dalam daftar kami. 0adalah FALSE, jadi ini mengembalikan indeks yang pertama FALSEdalam daftar, yang merupakan nilai bukan nol pertama dari operasi modulo. Sejak daftar awal kami dimulai 1, indeksnya sama dengan nilai non-pembagi terkecil.

Haskell, 26 byte

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

Semua orang lupa tentang until!

Brachylog , 10 byte

~{=#>:A'*}

Cobalah online!

Ini keluar sangat mirip dengan (tetapi lebih pendek dari) solusi asli Fatalize. Sejak itu Fatalize telah beralih ke algoritme lain yang terkait dengan ini melalui metode yang berbeda, jadi saya harus menjelaskannya sendiri:

~{=#>: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

Ketika kita membalikkan fungsi, dengan menukar "input" dan "output", kita mendapatkan algoritma yang cukup masuk akal (hanya dinyatakan dengan cara yang canggung): "coba kemungkinan bilangan bulat positif, dalam urutan alami mereka (yaitu 1 ke atas), sampai Anda menemukan yang tidak dapat dikalikan dengan apa pun untuk menghasilkan input ". Brachylog tidak melakukan perhitungan titik-mengambang kecuali semua input diketahui, sehingga hanya akan mempertimbangkan integer A.

Brachylog , 11 10 byte

,.=:?r'%0'

Cobalah online!

Penjelasan

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

SAPI, 174 byte

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

Cobalah online!

Kode ini hanya sebagian milik saya sendiri - ini mengimplementasikan algoritma modulus yang saya porting dari brainfuck. Sisa kode adalah milik saya. Namun, karena saya tidak menulis algoritma modulus, saya belum benar-benar menyelidiki cara kerjanya dan tidak dapat mendokumentasikan bagian kode tersebut. Sebagai gantinya, saya akan memberikan uraian yang biasa, diikuti dengan penjelasan yang lebih mendalam tentang mengapa kode itu bekerja.

Rincian kode

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.

Penjelasan

Kode pertama kali membaca bilangan bulat ke [0]. Setiap iterasi dari loop utama (baris 2 hingga 26) bertambah [1], kemudian menyalin semua yang diperlukan ke algoritma modulus, yang memuntahkan hasilnya ke [5]. Jika [5] berisi nilai apa pun, maka [1] adalah angka yang perlu kita cetak. Kami mencetaknya, dan kemudian secara paksa keluar dari program.

Karena COW adalah turunan dari brainfuck, fungsinya relatif mirip dengan cara brainfuck beroperasi - strip pita tanpa batas, Anda dapat bergerak ke kiri atau ke kanan, menambah atau mengurangi, dan "memutar" sementara nilai pita saat ini adalah nol. Selain brainfuck, SAP dilengkapi dengan beberapa fitur yang bermanfaat.

(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

Poin nyata yang menarik di sini adalah instruksi 3 mOO,. Interpreter membaca nilai rekaman saat ini, dan menjalankan instruksi berdasarkan nilai rekaman itu. Jika nilainya kurang dari 0, lebih besar dari 11, atau sama dengan 3, juru bahasa mengakhiri program. Kita dapat menggunakan ini sebagai kekuatan cepat dan kotor keluar dari loop utama (dan program sepenuhnya) setelah kami menemukan non-pembagi kami. Yang harus kita lakukan adalah mencetak nomor kita, hapus [1] (dengan OOO), kurangi menjadi -1 dengan MOo, dan kemudian jalankan instruksi -1 melalui mOOyang mengakhiri program.

Rekaman itu sendiri untuk program ini berfungsi sebagai berikut:

[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

Algoritma modulus membersihkan secara alami [2], [3], [6], dan [7] pada akhir operasi. Isi [4] ditimpa dengan register paste pada baris 4, dan [5] adalah nol ketika [0] habis dibagi oleh [1], jadi kita tidak harus menghapusnya. Jika [5] tidak nol, kami berhenti secara paksa pada saluran 23 sehingga kami tidak perlu khawatir.

05AB1E , 7 byte

Xµ¹NÖ_½

Cobalah online!

Penjelasan

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

Jelly , 5 byte

1%@#Ḣ

Cobalah online!

Penjelasan:

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

Ini merupakan penyalahgunaan yang mengerikan dari #; ada banyak operator dalam program ini, tetapi satu ton operan yang hilang. #benar-benar ingin 1diberikan secara eksplisit untuk beberapa alasan (jika tidak mencoba untuk default ke input); namun, semua hal lain yang tidak ditentukan dalam program default ke input program. (Jadi misalnya, jika Anda memberi 24 sebagai input, program ini menemukan 24 angka pertama yang tidak membagi 24, lalu mengembalikan yang pertama; jenis pemborosan, tetapi berhasil.)

C, 32 35 byte

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

Edit: ditambahkan i=1di loop

Pemakaian

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

Versi Program Lengkap, 64 Bytes:

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

Disimpan dua byte berkat Martin!

Perl, 19 byte

18 byte kode + -pbendera.

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

Untuk menjalankannya:

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

Penjelasan yang tidak terlalu terperinci :
- $.adalah variabel khusus yang nilai defaultnya adalah nomor baris saat ini dari filehandle terakhir yang diakses (stdin di sini), jadi setelah membaca input baris pertama, disetel ke 1.
- $_menyimpan input dan dicetak secara implisit di akhir (terima kasih untuk -pbendera).
- redo(dalam konteks itu) menganggap bahwa program dalam satu lingkaran dan mengulangi iterasi saat ini (hanya $.akan berbeda karena bertambah).
- Jadi, jika kami menemukan nomor terkecil (tersimpan di $.) yang tidak dibagi $_, maka kami mengaturnya $_, jika tidak, kami mencoba nomor berikutnya (terima kasih redo).

Oktaf / MATLAB, 26 24 byte

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

find(...,1)mengembalikan indeks ( 1-based) elemen bukan nol pertama dari vektor dalam argumen pertama. Argumen pertama adalah [n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]Itu berarti kita harus menambah +1indeks, karena kita mulai menguji pada 1. Terima kasih @Giuseppe untuk -2 byte.

Cobalah online!

Jelly , 6 byte

%R;‘TḢ

Cobalah online!

Penjelasan:

                                               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..*}

Cobalah

Diperluas:

{  # 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¬

Cobalah online!

Juga, itu mengeja "LINK!" ... Agak ...

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

Jelly , 5 byte

‘ḍ€i0

Cobalah online!

Bagaimana itu bekerja

‘ḍ€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)

Uji Ideone

Secara rekursif menghitung potensial non-pembagi d. Lebih pendek untuk meningkatkan hasil secara rekursi daripada output d. Offset 1diraih oleh Boolean of True, yang sama dengan 1, tetapi karena d==1selalu merupakan pembagi, output selalu dikonversi ke angka.

Python 2.7.9 digunakan untuk mengizinkan 0or. Versi mulai 2.7.10 akan mencoba untuk menguraikan 0orsebagai awal dari angka oktal dan diberi kesalahan sintaksis. Lihat ini di Ideone .

Sebenarnya , 7 byte

;÷@uR-m

Cobalah online! (catatan: ini adalah solusi yang sangat lambat, dan akan memakan waktu lama untuk kasus uji besar)

Penjelasan:

;÷@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

Ekspresi [k|k<-[2..]]hanya membuat daftar tak terbatas [2,3,4,5,...]. Dengan kondisi tersebut mod n k>0kami hanya mengizinkan mereka yang ada kdi daftar yang tidak membagi n. Menambahkan !!0hanya mengembalikan entri pertama (entri pada indeks 0) dari daftar itu.

Cobalah online!

Dyalog APL , 8 byte

1⍳⍨0≠⍳|⊢

1⍳⍨ posisi True pertama di

0≠ nilai bukan nol dari

⍳|sisa pembagian 1 ... N bila dibagi dengan

⊢ N

TryAPL online!

Catatan: ini berfungsi untuk 1 dan 2 karena 1⍳⍨mengembalikan 1 + panjang argumennya jika tidak ada yang ditemukan.

julia, 28 byte

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

Catatan: karena 1:N+2tidak mengalokasikan memori, tidak ada masalah memori untuk Ns
- @flawr besar , N+2simpan untuk saya beberapa byte
- Saran @Martin disimpan 1 byte

QBIC , 14 byte

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

Penjelasan:

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

jika dijalankan dari konsol dengan -ropsi (thx ke @ ais523)

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

32 byte

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

terima kasih kepada @manatwork untuk menghapus 1 byte

33 byte (asli)

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

Cubix , 14 12 byte

I2/L/);?%<@O

Disimpan 2 byte berkat MickyT.

Cobalah

Penjelasan

Dalam bentuk kubus, kodenya adalah:

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

Pada dasarnya, ini hanya mengambil input dan memulai penghitung. Kemudian memeriksa setiap nilai konter berturut-turut sampai menemukan nilai yang bukan merupakan faktor input.

> <> , 15 +3 = 18 byte

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

Input diharapkan berada di stack saat program dimulai, jadi +3 byte untuk -vflag. Cobalah online!

Ubur-ubur , 12 10 byte

p\~~|1
 >i

Mengambil input dari STDIN dan output ke STDOUT. Cobalah online!

Martin Ender menyimpan 2 byte, terima kasih!

Penjelasan

 \~~|
 >i

Bagian ini adalah salah satu fungsi yang menggunakan nilai input dalam definisinya.

   ~|

Ini ~-cell diberikan fungsi, sehingga membalik argumen: nya menghasilkan fungsi biner "argumen kiri Modulo ( |) argumen yang tepat". Fungsi modulo bawaan di Jellyfish mengambil argumennya dalam urutan terbalik.

  ~~|
  i

Ini ~-cell diberi nilai dan fungsi, sehingga tidak aplikasi parsial: menghasilkan fungsi biner "input ( i) modulo argumen yang tepat". Sebut saja fungsi itu f .

 \~~|
 >i

The \-cell diberikan dua fungsi, sehingga tidak iterasi: menghasilkan fungsi unary "increment ( >) sampai fungsi f diterapkan untuk nilai-nilai sebelumnya dan saat ini memberikan truthy (nol) hasil, kemudian kembali nilai saat ini". Ini berarti bahwa argumen bertambah hingga tidak membagi input.

p\~~|1
 >i

Akhirnya, kami menerapkan fungsi ini ke nilai awal 1dan mencetak hasilnya dengan p.