Bu zorluk, başlığın hepsinde temelde bulunacak kadar basittir: size N pozitif tamsayı verilir ve N bölücü olmayan en küçük pozitif tamsayıyı döndürmelisiniz .

Bir örnek: bölenler N = 24 vardır 1, 2, 3, 4, 6, 8, 12, 24. O listede yok en küçük pozitif tam sayıdır 5 , böylece çözüm bulmalıdır sonucu.

Bu, OEIS dizisi A007978'dir .

kurallar

Bir program veya fonksiyon yazabilir ve standart girdi alma ve çıktı alma yöntemlerimizden herhangi birini kullanabilirsiniz .

Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Bu kod-golf , yani en kısa geçerli cevap - bayt olarak ölçülen - kazanır.

Test Kılıfları

İlk 100 terim:

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

Özellikle, cevabınızın 1 ve 2 numaralı girişler için çalıştığından emin olun, bu durumda sonuç girdiden büyüktür.

Ve bazı daha büyük test durumları için:

N          f(N)
1234567    2
12252240   19
232792560  23

Mathematica, 19 bayt (UTF-8 kodlaması)

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

Adsız işlev sıfır olmayan bir tamsayı argümanı alarak ve pozitif bir tamsayı döndürür. Yarı yolda dikey çubuk aslında Mathematica'daki bölünebilirlik ilişkisini gösteren üç baytlık karakter U + 2223'tür. Açıklama:

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.

Eklemek için düzenlendi: ngenisis //., varsayılan olarak maksimum 65536 kez yineleyeceğine dikkat çekiyor . Bu nedenle bu uygulama, 1 ile 65538 arasındaki tam sayıların en az kullanılan katından daha az olan tüm giriş numaraları için çalışır (özellikle en fazla 28436 basamak olan tüm numaralarda), ancak teknik olarak tüm numaralar için değil. Biri bu hatayı düzeltmek için x//.yonunla değiştirebilir ReplaceRepeated[x,y,MaxIterations->∞], ancak açıkça ek 34 byte.

Pyth, 3 bayt

f%Q

Temel olarak, fkodu %QT( yineleme değişkeni Q % Tnerede T) true olana kadar döngüler .

Burada çevrimiçi deneyin.

JavaScript (ES6), 25 23 bayt

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

Not: Buradaki ilginç bir şey, kparametrenin ilk yinelemede nihilo'dan başlatılmış olmasıdır . Bunun nedeni çalışır n % undefinedolduğu NaN(beklendiği gibi falsy) ve -~undefinedeşittir 1. Bir sonraki yinelemede, -~kesasen eşdeğerdir k+1.

Ölçek

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 bayt

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

Altıgen , 12 bayt

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

Embiggened:

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

Çevrimiçi deneyin!

R, 28 bayt

Oldukça basit, süslü bir şey değil. Stdin'den girdi alır, modulo sıfır Tolana kadar değer artar .iT

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

Biraz daha süslü bir şey istiyorsanız, 29 bayt için aşağıdakiler var :

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

Açıklaması:

i=scan(): iStdin'den oku .

1:(i+1): Tüm tamsayıları oluşturma 1için i+1( +1vakalarında için muhasebe 1ve 2).

i%%1:(i+1) : Listemizdeki her numaraya göre girişi modulo.

!i%%1:(i+1): Sonuçlanan listeyi olumsuzlayın; Bu örtük öyle ki, mantıklı bir tipe dönüştürür 0olduğunu FALSEve sıfırdan farklı olduğu TRUE. İhmal ettikten sonra TRUEdeğerler olur FALSEve tersi olur. Şimdi, başlangıçta sıfır olmayan tüm değerler olarak kodlanmıştır FALSE.

match(0,!i%%1:(i+1)): 0Listemizdeki ilk örneğin dizinini döndür. 0yani FALSE, bu FALSE, modulo işleminden gelen ilk sıfır olmayan değer listedeki ilk dizini döndürür . Orijinal listemiz başladığından beri 1, endeks en küçük bölen olmayanların değerine eşittir.

Haskell, 26 bayt

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

Herkes unutuyor until!

Brachylog , 10 bayt

~{=#>:A'*}

Çevrimiçi deneyin!

Bu, Fatalize'in orijinal çözümüne çok benzer (ancak daha kısa) oldu. Fatalize, o zamandan beri bununla farklı bir yöntemle bağlanan farklı bir algoritmaya geçti, bu yüzden kendim açıklamak zorunda kalacağım:

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

Fonksiyonu tersine çevirdiğimizde, "input" ve "output" u değiştirerek, oldukça makul bir algoritma elde ederiz (sadece garip bir şekilde ifade edilir): "bulduğunuza kadar, muhtemel pozitif tamsayıları doğal sıralarında (yani, 1 yukarı) deneyin. girişi üretmek için hiçbir şeyle çarpılamayan bir tanesi ". Brachylog, bütün girdiler bilinmediği sürece kayan nokta hesaplamaları yapmaz, bu nedenle sadece A tamsayısını dikkate alır.

Brachylog , 11 10 bayt

,.=:?r'%0'

Çevrimiçi deneyin!

açıklama

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

COW, 174 bayt

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

Çevrimiçi deneyin!

Bu kod sadece kısmen kendime ait - beynimden taşıdığım modulus algoritmasını uyguluyor . Kodun geri kalanı benim. Ancak, modül algoritmasını yazmadığım için, nasıl çalıştığını tam olarak incelemedim ve kodun bu bölümünü belgeleyemedim. Bunun yerine, her zamanki dökümümü vereceğim, ardından kodun neden çalıştığına dair daha ayrıntılı bir açıklama yapacağım.

Kod dökü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.

açıklama

Kod önce tamsayıyı [0] okur. Ana döngünün her yinelemesi (satır 2 - 26) [1] değerini artırır, daha sonra sonucunu [5] 'e yayan modül algoritmasına gerekli olan her şeyi kopyalar. [5] herhangi bir değer içeriyorsa, [1] yazdırmamız gereken sayıdır. Basarız ve sonra da programdan çıkar.

COW, bir beyinböceği türevi olduğu için, beynin işleyiş şekline benzer şekilde çalışır - sonsuz şerit şeridi, sola veya sağa hareket edebilir, artırabilir veya azaltabilir ve mevcut bant değeri sıfır değilken "döngü". Brainfuck'a ek olarak, COW birkaç kullanışlı özelliğe sahiptir.

(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

Buradaki asıl ilgi noktası talimat 3'tür mOO. Tercüman geçerli teyp değerini okur ve bu teyp değerini temel alan bir talimat yürütür. Değer 0'dan küçük, 11'den büyük veya 3'e eşitse, yorumlayıcı programı sonlandırır. Bölücü olmayan kişiyi bulduğumuzda bunu ana döngünün (ve programın tamamen) hızlı ve kirli bir şekilde bırakılması olarak kullanabiliriz. Tek yapmamız gereken, numaramızı yazdırmak, [1] (ile OOO) işaretini silmek , onu -1 ile azaltmak MOove sonra programı bitiren -1 komutunu uygulamak mOO.

Bu program için kasetin kendisi şu şekilde çalışır:

[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

Modül algoritması doğal olarak işlem sonunda [2], [3], [6] ve [7] 'yi temizler. [4] 'un içeriği 4. satırdaki register macunu üzerine yazılır ve [0], [1] [1] ile bölündüğü zaman [5] sıfırdır, bu yüzden onu silmek zorunda değiliz. [5] sıfır değilse, satır 23'te zorla istifa ederiz, bu yüzden endişelenmek zorunda kalmayız.

05AB1E , 7 bayt

Xµ¹NÖ_½

Çevrimiçi deneyin!

açıklama

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

Jöle , 5 bayt

1%@#Ḣ

Çevrimiçi deneyin!

Açıklama:

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

Bu korkunç bir suistimal #; Bu programda çok sayıda operatör var, ancak bir sürü eksik işlenen var. #gerçekten bir 1nedenden ötürü açıkça verilmesini istiyor (aksi takdirde girdi için varsayılana çalışır); ancak, programda belirtilmeyen her şey varsayılan olarak programın girişine ayarlanmıştır. (Örneğin, 24'ü girdi olarak verirseniz, bu program 24'ü bölmeyen ilk 24 sayıyı bulur, sonra ilkini döndürür; tür israfı, ancak işe yarar.)

C, 32 35 bayt

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

Düzenleme: i=1döngüde eklendi

kullanım

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

Tam Program sürümü, 64 Bayt:

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

C #, 39 37 bayt

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

Martin sayesinde iki bayt kurtarıldı!

Perl, 19 bayt

18 bayt kodu + -pbayrak.

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

Çalıştırmak için:

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

Çok ayrıntılı olmayan açıklamalar:
- $.varsayılan değeri erişilen son dosyahanenin geçerli satır numarası olan (burada stdin) olan özel bir değişkendir, bu nedenle girişin ilk satırını okuduktan sonra 1 olarak ayarlanır.
- $_girişi tutar ve örtülü olarak basılır sonunda ( -pbayrak sayesinde ).
- redo(bu bağlamda) programın bir döngü içinde olduğunu ve mevcut yinelemeyi yinelediğini düşünür (yalnızca artırıldığından $.beri farklı olacaktır).
- Eğer $.bölünmeyen en küçük sayıyı (saklanmış ) $_bulursak, o zaman $_ona koyarız, aksi takdirde bir sonraki sayıyı deneyeceğiz (sayesinde redo).

Octave / MATLAB, 26 24 bayt

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

find(...,1)1ilk argümanda vektörün ilk sıfır olmayan elemanının indeksini ( temelli) döndürür . İlk argüman, test etmeye başladığımızdan beri dizine [n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]eklememiz +1gerektiği anlamına geliyor 1. -2 bayt için @Giuseppe teşekkürler.

Çevrimiçi deneyin!

Jöle , 6 bayt

%R;‘TḢ

Çevrimiçi deneyin!

Açıklama:

                                               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 bayt

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

Dene

Expanded:

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

ÌL¹ÑK¬

Çevrimiçi deneyin!

Ayrıca, "LINK!" İ büyüler ... Tür ...

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

Jöle , 5 bayt

‘ḍ€i0

Çevrimiçi deneyin!

Nasıl çalışır

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

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

İdeone Testi

Tekrarlı olarak potansiyel bölenleri saymaz d. Tekrarlı olarak artış, sonucu çıktıdan daha kısadır d. Bir ofset, eşit olan 1Boole tarafından elde edilir , ancak her zaman bir bölen olduğundan, çıktı her zaman bir sayıya dönüştürülür.True1d==1

Python 2.7.9 izin vermek için kullanılır 0or. 2.7.10 ile başlayan sürümler 0or, sekizli sayının başlangıcı olarak ayrıştırmaya çalışır ve bir sözdizimi hatası verilir. Bunu Ideone'da gör .

Aslında , 7 bayt

;÷@uR-m

Çevrimiçi deneyin! (not: bu çok yavaş bir çözümdür ve büyük test durumları için uzun zaman alacaktır)

Açıklama:

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

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

İfade [k|k<-[2..]]sadece sonsuz bir liste oluşturur [2,3,4,5,...]. Bu şartla, mod n k>0yalnızca klistede olmayanlara izin vermeyiz n. Ekleme !!0sadece 0listenin ilk girişini (dizinindeki giriş ) gösterir.

Çevrimiçi deneyin!

Dyalog APL , 8 bayt

1⍳⍨0≠⍳|⊢

1⍳⍨ ilk True konumunda

0≠ sıfır olmayan değerleri

⍳|bölü 1 ... N bölüm kalanları

⊢ N-

TryAPL çevrimiçi!

Not: bu, 1 ve 2 için çalışır çünkü 1⍳⍨hiçbiri bulunmazsa 1 + argümanının uzunluğunu döndürür.

julia, 28 bayt

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

Not: 1:N+2bellek ayırmadığından beri büyük Ns için bellek sorunu yoktur
- @flawr N+2benim için bazı baytlar
kaydeder - @Martin 'in önerisi 1 bayt kurtardı

QBIC , 14 bayt

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

Açıklama:

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

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

-rSeçeneği olan konsolu çalıştırırsanız (thx - @ ais523)

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

32 bayt

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

1 baytı kaldırmak için @ manatwork sayesinde

33 bayt (orijinal)

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

Cubix , 14 12 bayt

I2/L/);?%<@O

MickyT sayesinde 2 bayt kaydedildi.

Dene

açıklama

Küp biçiminde kod:

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

Temel olarak, bu sadece girişi alır ve bir sayaç başlatır. Ardından, girişin bir faktörü olmayanı bulana kadar sayacın ardışık her değerini kontrol eder.

> <> , 15 +3 = 18 bayt

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

Program başlangıcında girişin yığında olması bekleniyor, bu nedenle -vbayrak için +3 bayt . Çevrimiçi deneyin!

Denizanası , 12 10 bayt

p\~~|1
 >i

STDIN'den giriş alır ve STDOUT'ya çıkar. Çevrimiçi deneyin!

Martin Ender 2 bayt kurtardı, teşekkürler!

açıklama

 \~~|
 >i

Bu bölüm, tanımındaki giriş değerini kullanan bir fonksiyondur.

   ~|

Bu ~hücreye bir işlev verilir, bu yüzden argümanlarını çevirir: "left argümanı modulo ( |) right argümanı" ikili işlevini üretir . Denizanası'ndaki yerleşik modulo işlevi, argümanlarını ters sırada alır.

  ~~|
  i

Bu ~hücreye bir değer ve bir işlev verilir, bu yüzden kısmi uygulama yapar: "input ( i) modulo right argümanı" ikili işlevini üretir . Bu fonksiyona f diyelim .

 \~~|
 >i

\Cell iki işlevi verilmektedir, bu yüzden yineleme yapar: tekli fonksiyonu "artışı (üretir >) işlevi kadar f mevcut ve önceki değerlerine tatbik edilen bir truthy (sıfır olmayan) bir sonuç verir, daha sonra, mevcut değeri dönüş". Bu, argümanın girişi bölmediği sürece artırıldığı anlamına gelir.

p\~~|1
 >i

Son olarak, bu işlevi başlangıç ​​değerine uygularız 1ve sonucu ile yazdırırız p.