Diese Herausforderung ist so einfach, dass im Grunde alles im Titel steht: Sie erhalten eine positive ganze Zahl N und Sie sollten die kleinste positive ganze Zahl zurückgeben, die kein Teiler von N ist .

Ein Beispiel: Die Teiler von N = 24 sind 1, 2, 3, 4, 6, 8, 12, 24. Die kleinste positive Ganzzahl, die nicht in dieser Liste enthalten ist , ist 5 , das ist also das Ergebnis, das Ihre Lösung finden sollte.

Dies ist die OEIS-Sequenz A007978 .

Regeln

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Die ersten 100 Begriffe sind:

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

Stellen Sie insbesondere sicher, dass Ihre Antwort für die Eingaben 1 und 2 funktioniert. In diesem Fall ist das Ergebnis größer als die Eingabe.

Und für einige größere Testfälle:

N          f(N)
1234567    2
12252240   19
232792560  23

Mathematica, 19 Bytes (UTF-8-Codierung)

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

Unbenannte Funktion, die ein Ganzzahlargument ungleich Null verwendet und eine positive Ganzzahl zurückgibt. Der vertikale Balken auf halbem Weg ist das Drei-Byte-Zeichen U + 2223, das die Teilbarkeitsrelation in Mathematica angibt. Erläuterung:

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.

Bearbeitet, um hinzuzufügen: ngenisis weist darauf hin, dass //.standardmäßig maximal 65536-mal iteriert wird. Diese Implementierung funktioniert also für alle Eingabenummern, die kleiner sind als das kleinste gemeinsame Vielfache der ganzen Zahlen von 1 bis 65538 (insbesondere für alle Zahlen mit höchstens 28436 Ziffern), aber technisch nicht für alle Zahlen. Man kann ersetzen x//.ymit ReplaceRepeated[x,y,MaxIterations->∞]diesen Fehler zu beheben, aber offensichtlich auf Kosten von 34 zusätzlichen Bytes.

Pyth, 3 Bytes

f%Q

fSchleifen Sie den Code grundsätzlich, bis %QT( Q % Two Tist die Iterationsvariable) wahr ist.

Probieren Sie es hier online aus.

JavaScript (ES6), 25 23 Bytes

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

Hinweis: Interessant ist hier, dass der kParameter bei der ersten Iteration ex nihilo initialisiert wird. Dies funktioniert, weil n % undefinedist NaN(falsch wie erwartet) und -~undefinedgleich 1. Bei den nächsten Iterationen -~kentspricht im Wesentlichen k+1.

Prüfung

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 Bytes

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

Hexagony , 12 Bytes

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

Begünstigt:

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

Probieren Sie es online!

R, 28 Bytes

Ziemlich unkompliziert, nichts Besonderes. Übernimmt die Eingabe von stdin und erhöht den Wert, Tbis imodulo Tungleich Null ist.

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

Wenn Sie etwas ausgefalleneres möchten, gibt es für 29 Bytes Folgendes :

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

Erklärt:

i=scan(): Lesen ivon stdin.

1:(i+1): Generiere alle ganzen Zahlen von 1bis i+1(die +1Buchhaltung für die Fälle von 1und 2).

i%%1:(i+1) : Modulo die Eingabe von jeder Zahl in unserer Liste.

!i%%1:(i+1): Negiere die resultierende Liste; Dies wandelt es implizit in einen logischen Typ um, der 0ist FALSEund nicht Null ist TRUE. Nach dem Negieren werden TRUEWerte FALSEund umgekehrt. Jetzt werden alle ursprünglichen Werte ungleich Null als codiert FALSE.

match(0,!i%%1:(i+1)): Gibt den Index der ersten Instanz von 0in unserer Liste zurück. 0ist FALSE, also gibt dies den Index des ersten FALSEin der Liste zurück, der der erste Wert ungleich Null aus der Modulo-Operation ist. Da unsere ursprüngliche Liste um begann 1, entspricht der Index dem Wert des kleinsten Nichtteilers.

Haskell, 26 Bytes

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

Jeder vergisst über until!

Brachylog , 10 Bytes

~{=#>:A'*}

Probieren Sie es online!

Dies war sehr ähnlich (aber kürzer als die ursprüngliche Lösung von Fatalize). Fatalize hat seitdem auf einen anderen Algorithmus umgestellt, der über eine andere Methode mit diesem verknüpft ist. Deshalb muss ich das selbst erklären:

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

Wenn wir die Funktion invertieren, indem wir "Eingabe" und "Ausgabe" vertauschen, erhalten wir einen ziemlich vernünftigen Algorithmus (nur auf unangenehme Weise ausgedrückt): "Probieren Sie mögliche positive ganze Zahlen in ihrer natürlichen Reihenfolge (dh 1 aufwärts) aus, bis Sie finden eine, die nicht mit irgendetwas multipliziert werden kann, um die Eingabe zu erzeugen ". Brachylog führt keine Gleitkommaberechnungen durch, es sei denn, alle Eingaben sind bekannt. Daher wird nur die Ganzzahl A berücksichtigt.

Brachylog , 11 10 Bytes

,.=:?r'%0'

Probieren Sie es online!

Erläuterung

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

COW, 174 Bytes

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

Probieren Sie es online!

Dieser Code ist nur teilweise mein eigener - er implementiert einen Modulalgorithmus, den ich aus Brainfuck portiert habe. Der Rest des Codes ist mein eigener. Da ich den Modulalgorithmus jedoch nicht geschrieben habe, habe ich nicht wirklich untersucht, wie er funktioniert, und kann diesen Teil des Codes nicht dokumentieren. Stattdessen werde ich meine übliche Aufschlüsselung geben, gefolgt von einer ausführlicheren Erläuterung, warum der Code funktioniert.

Code-Aufschlüsselung

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.

Erläuterung

Der Code liest zuerst die ganze Zahl in [0]. Jede Iteration der Hauptschleife (Zeilen 2 bis 26) inkrementiert [1] und kopiert dann alles Notwendige in den Modulalgorithmus, der das Ergebnis in [5] ausspuckt. Wenn [5] irgendeinen Wert enthält, dann ist [1] die Zahl, die wir drucken müssen. Wir drucken es und beenden dann das Programm.

Da COW ein Brainfuck-Derivat ist, funktioniert es relativ ähnlich wie Brainfuck. Sie können einen unendlichen Bandstreifen nach links oder rechts bewegen, erhöhen oder verringern und "loopen", während der aktuelle Bandwert ungleich Null ist. Zusätzlich zum Brainfuck bietet COW eine Reihe nützlicher Funktionen.

(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

Der eigentliche Punkt von Interesse ist hier die Anweisung 3 mOO,. Der Interpreter liest den aktuellen Bandwert und führt eine Anweisung basierend auf diesem Bandwert aus. Wenn der Wert kleiner als 0, größer als 11 oder gleich 3 ist, beendet der Interpreter das Programm. Wir können dies als schnelles und schmutziges Verlassen der Hauptschleife (und des Programms vollständig) verwenden, sobald wir unseren Nicht-Divisor gefunden haben. Alles, was wir tun müssen, ist, unsere Nummer auszudrucken, [1] (mit OOO) zu löschen , sie mit auf -1 zu dekrementieren MOound dann den Befehl -1 auszuführen, über mOOden das Programm endet.

Das Band selbst für dieses Programm funktioniert wie folgt:

[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

Der Modulalgorithmus löscht natürlich [2], [3], [6] und [7] am Ende der Operation. Der Inhalt von [4] wird mit der Registerpaste in Zeile 4 überschrieben, und [5] ist Null, wenn [0] durch [1] teilbar ist, sodass wir ihn nicht löschen müssen. Wenn [5] ungleich Null ist, beenden wir Zeile 23 zwangsweise, damit wir uns darüber keine Sorgen machen müssen.

05AB1E , 7 Bytes

Xµ¹NÖ_½

Probieren Sie es online!

Erläuterung

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

Gelee , 5 Bytes

1%@#Ḣ

Probieren Sie es online!

Erläuterung:

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

Dies ist ein schrecklicher Missbrauch von #; Es gibt viele Operatoren in diesem Programm, aber eine Menge fehlender Operanden. #möchte wirklich 1, dass das aus irgendeinem Grund explizit angegeben wird (andernfalls wird versucht, die Eingabe als Standard festzulegen); Alles andere, was nicht im Programm angegeben ist, wird standardmäßig vom Programm eingegeben. (Wenn Sie beispielsweise 24 als Eingabe eingeben, findet dieses Programm die ersten 24 Zahlen, die 24 nicht teilen, und gibt dann die erste zurück. Dies ist zwar verschwenderisch, funktioniert aber.)

C, 32 35 Bytes

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

Bearbeiten: i=1in der Schleife hinzugefügt

Verwendungszweck

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

Vollversion des Programms, 64 Bytes:

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

C #, 39 37 Bytes

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

Zwei Bytes gespart dank Martin!

Perl, 19 Bytes

18 Byte Code + -pFlag.

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

Um es auszuführen:

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

Nicht sehr detaillierte Erklärungen:
- $.ist eine spezielle Variable, deren Standardwert die aktuelle Zeilennummer des zuletzt aufgerufenen Dateihandles ist (hier stdin). Nach dem Lesen der ersten Eingabezeile wird sie auf 1 gesetzt.
- $_hält die Eingabe und wird implizit gedruckt am ende (dank -pflagge).
- redo(in diesem Zusammenhang) geht davon aus, dass sich das Programm in einer Schleife befindet, und wiederholt die aktuelle Iteration (nur $.anders, da sie erhöht wurde).
- Wenn wir also die kleinste Zahl (gespeichert in $.) gefunden haben, die sich nicht teilt $_, setzen wir $_sie auf, andernfalls versuchen wir es mit der nächsten Zahl (danke an redo).

Oktave / MATLAB, 26 24 Bytes

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

find(...,1)Gibt den Index ( 1-basiert) des ersten Nicht-Null-Elements des Vektors im ersten Argument zurück. Das erste Argument lautet: [n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]Das heißt, wir müssen +1den Index erweitern, da wir mit dem Testen bei beginnen 1. Danke @ Giuseppe für -2 Bytes.

Probieren Sie es online!

Gelee , 6 Bytes

%R;‘TḢ

Probieren Sie es online!

Erläuterung:

                                               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 Bytes

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

Versuch es

Erweitert:

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

ÌL¹ÑK¬

Probieren Sie es online!

Außerdem heißt es "LINK!" ... Ein bisschen ...

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

Gelee , 5 Bytes

‘ḍ€i0

Probieren Sie es online!

Wie es funktioniert

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

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

Test auf Ideone

Zählt potenzielle Nicht-Teiler rekursiv auf d. Es ist kürzer, das Ergebnis rekursiv zu erhöhen als auszugeben d. Ein Offset von 1wird durch den Booleschen Wert von erreicht True, der gleich 1ist. Da d==1es sich jedoch immer um einen Divisor handelt, wird die Ausgabe immer in eine Zahl umgewandelt.

Python 2.7.9 wird verwendet, um zuzulassen 0or. Versionen ab 2.7.10 versuchen, 0orals Beginn einer Oktalzahl zu analysieren und erhalten einen Syntaxfehler. Sehen Sie dies auf Ideone .

Eigentlich 7 Bytes

;÷@uR-m

Probieren Sie es online! (Hinweis: Dies ist eine sehr langsame Lösung, die für große Testfälle viel Zeit in Anspruch nimmt.)

Erläuterung:

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

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

Der Ausdruck [k|k<-[2..]]erstellt nur eine unendliche Liste [2,3,4,5,...]. Mit der Bedingung mod n k>0erlauben wir nur diejenigen kin der Liste, die sich nicht teilen n. Das Anhängen gibt !!0nur den ersten Eintrag (den Eintrag am Index 0) aus dieser Liste zurück.

Probieren Sie es online!

Dyalog APL , 8 Bytes

1⍳⍨0≠⍳|⊢

1⍳⍨ Position des ersten True in

0≠ die Nicht-Null-Werte von

⍳|der Teilungsrest von 1 ... N bei Division durch

⊢ N

TryAPL online!

Hinweis: Dies funktioniert für 1 und 2, da 1⍳⍨1 + die Länge des Arguments zurückgegeben wird, wenn keine gefunden wird.

Julia, 28 Bytes

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

Hinweis: Da 1:N+2kein Speicher reserviert wird, gibt es keine Speicherprobleme für große Ns
- @flawr - spart N+2mir einige Bytes
- @Martins Vorschlag sparte 1 Bytes

QBIC , 14 Bytes

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

Erläuterung:

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

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

Wenn laufen von der Konsole mit -rOption (Danke an @ ais523)

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

32 Bytes

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

danke an @manatwork für das entfernen von 1 byte

33 Bytes (original)

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

Cubix , 14 12 Bytes

I2/L/);?%<@O

2 Bytes gespart dank MickyT.

Versuch es

Erläuterung

In Würfelform lautet der Code:

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

Grundsätzlich übernimmt dies nur die Eingabe und startet einen Zähler. Anschließend wird jeder nachfolgende Wert des Zählers geprüft, bis ein Wert gefunden wird, der kein Faktor für die Eingabe ist.

> <> , 15 +3 = 18 Bytes

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

Es wird erwartet, dass die Eingabe beim Programmstart auf dem Stack ist, also +3 Bytes für das -vFlag. Probieren Sie es online!

Qualle , 12 10 Bytes

p\~~|1
 >i

Übernimmt die Eingabe von STDIN und gibt sie an STDOUT aus. Probieren Sie es online!

Martin Ender hat 2 Bytes gespart, danke!

Erläuterung

 \~~|
 >i

Dieser Teil ist eine Funktion, die den Eingabewert in ihrer Definition verwendet.

   ~|

Diese ~-Zelle erhält eine Funktion, also dreht sie ihre Argumente um: Sie erzeugt die Binärfunktion "linkes Argument modulo ( |) rechtes Argument". Die in Jellyfish integrierte Modulo-Funktion führt die Argumente in umgekehrter Reihenfolge aus.

  ~~|
  i

Diese ~-Zelle erhält einen Wert und eine Funktion, weshalb sie teilweise angewendet wird: Sie erzeugt die Binärfunktion "input ( i) modulo right argument". Nennen wir diese Funktion f .

 \~~|
 >i

Die \-Zelle erhält zwei Funktionen und führt daher eine Iteration durch: Sie erzeugt die unäre Funktion "increment ( >), bis die auf vorherige und aktuelle Werte angewendete Funktion f ein wahres Ergebnis (ungleich Null) ergibt, und gibt dann den aktuellen Wert zurück". Dies bedeutet, dass das Argument solange inkrementiert wird, bis die Eingabe nicht mehr geteilt wird.

p\~~|1
 >i

Zuletzt wenden wir diese Funktion auf den Anfangswert an 1und drucken das Ergebnis mit p.