Finden Sie die kleinste Zahl, die N nicht teilt

50

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 , 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
Martin Ender
quelle
Ich habe die Beispielausgabe in einen Zahlenvektor umgewandelt und festgestellt, dass sie sich, wenn Sie sie mit 24 Spalten formatieren, extrem wiederholt, abgesehen von der ungeraden Abweichung.
Carcigenicate
Das macht Sinn, 24 ist 0 mod 2, 3 und 4, so dass die einzigen Unterschiede in Spalten sind, in denen die Zahlen> 4 sind. Bei Breite 120 ist es sogar noch repetitiver.
CalculatorFeline

Antworten:

18

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.

Greg Martin
quelle
Sehr interessante Art und Weise zu Schleife ohne Verwendung For, Whileusw.
ngenisis
5
Ich habe es von dieser Seite gelernt! Ich genieße es auf jeden Fall, mehr über Mathematica zu lernen, wenn ich hier bin (kann ich das auf meinem Arbeitszeittabelle nachweisen ...?).
Greg Martin
3
Das sieht nicht nach mathematica O_o aus
Mama Fun Roll
2
Lass dich nicht vom Fehlen von Großbuchstaben und Klammern täuschen;)
Greg Martin
14

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.

busukxuan
quelle
2
Sah das Problem, machte diese Antwort, kam hierher, um es zu posten, fand deins. Gut gemacht!
Isaacg
Ich schrieb das und fühlte mich großartig in Bezug auf mich selbst: .V1In%Qb0bBSah deine Antwort und fühlte mich nicht mehr so ​​großartig.
John Red
@JohnRed Lol, ich denke, Sie müssen sich nur mit den in Pyth integrierten Funktionen vertraut machen.
Busukxuan
14

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

Arnauld
quelle
Genau das habe ich bekommen. Es würde mich wundern, wenn etwas kürzeres möglich ist
ETHproductions
@ETHproductions Beim zweiten Gedanken gibt es eine kürzere. :-)
Arnauld
5
Äh. Das ist ... äh ... wow.
ETHproductions
13

Python, 43 36 35 Bytes

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

Hexagony , 12 Bytes

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

Begünstigt:

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

Probieren Sie es online!

Sok
quelle
2
Das ist eine sehr beeindruckende Punktzahl für Hexagony, gute Arbeit!
Martin Ender
11

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.

rturnbull
quelle
Nizza, wollte nur vorschlagen which.min, aber dann sah ich die Bearbeitung und es scheint, matchmacht einen ähnlichen Job.
JAD
2
Auch netter Trick mit T, erspart die Notwendigkeit, ihn vor der whileSchleife zu definieren .
JAD
@ JarkoDubbeldam Danke! Ich kann keinen Weg finden, wie der vektorisierte Ansatz kürzer sein kann als der whileAnsatz, was in Ordnung ist, da er für große N sehr speicherintensiv ist. Der TTrick ist eine dieser Leckerbissen, die für das Golfen großartig, für das eigentliche Programmieren jedoch absolut schrecklich ist. (Und natürlich können Sie auch verwenden, Fwenn Sie eine benötigen 0.)
Rturnbull
Sie können zwei Bytes speichern, indem Sie 0: i + 1 anstelle von 1: (i + 1) verwenden, obwohl ich nicht sicher bin, wie es mit dem %% -Operator funktioniert.
Antoine-Sac
@ antoine-sac Hat leider %%Vorrang vor +, daher sind noch Parens erforderlich:, (0:i+1)mit der gleichen Anzahl von Bytes wie 1:(i+1). Ersteres hatte ich ursprünglich, habe es aber durch Letzteres ersetzt, da es leichter zu lesen ist.
Rturnbull
10

Haskell, 26 Bytes

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

Jeder vergisst über until!

xnor
quelle
9

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.


quelle
1
Ich habe nie darüber nachgedacht, das ist ordentlich!
Fatalize
8

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.

Gabriel Benamy
quelle
7

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
Emigna
quelle
Schön, ich habe mich gefragt, wie Sie das in 05AB1E iterativ machen würden.
Magic Octopus Urn
7

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.)


quelle
Verdammt, Jelly! Pyth schlägt dich heute! : D
John Red
Nur ASCII:2%@1#
Erik der Outgolfer
7

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);}
Giacomo Garabello
quelle
6

C #, 39 37 Bytes

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

Zwei Bytes gespart dank Martin!

Alfie Goodacre
quelle
Ich mag while (! (N% ++ i)); Besser, aber das ist natürlich Code Golf und 1 Byte ist 1 Byte.
John Hamilton
Funktioniert es? Ich wusste nicht, dass die 0 automatisch falsch ausgewertet
Alfie Goodacre
Ah, ich habe es in C ++ versucht, ja, es funktioniert nicht mit C #.
John Hamilton
6

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).

Dada
quelle
6

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!

fehlerhaft
quelle
@(n)find(mod(n,1:n+1),1)ist kürzer, nicht wahr?
Giuseppe
es ist in der Tat danke!
Fehler
5

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
steenbergh
quelle
Ich kenne Jelly nicht, aber können Sie ein Byte sparen, indem Sie N erhöhen, bevor Sie den Bereich generieren?
Emigna
@Emigna Ich kenne Jelly auch nicht;) Ich verstehe nicht, wie: Wenn Sie es früher erhöhen, wird auch der Modulo-Test gegen N + 1 durchgeführt, oder die verbleibenden Werte werden erhöht [1, 1, 1, 1, 5, ...].
Steenbergh
Ah ich sehe. Ich dachte, es könnte möglich sein, den N% -Bereich (1, N + 1) zu machen, aber wenn er in beiden Fällen den N-Wert erhöht, ist das nicht gut.
Emigna
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 .. *
}
Brad Gilbert b2gills
quelle
5

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.
Magische Kraken-Urne
quelle
@Zgarb hat diesen Teil verpasst, das anfängliche Inkrement um 2 behebt das Problem.
Magic Octopus Urn
1
Nett! Ich vergesse immer, dass 05ab1e eine Divisor-Funktion hat :)
Emigna
5

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.
Dennis
quelle
4

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 .

xnor
quelle
3

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
Mego
quelle
3

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!

fehlerhaft
quelle
3

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.

Adam
quelle
3

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

rahnema1
quelle
3

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]
steenbergh
quelle
3

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;
Arthur Shveida
quelle
3
IIRC, das <?muss nicht Teil Ihrer Byteanzahl sein (da PHP über einen Befehlszeilenmodus verfügt, der dies nicht erfordert).
3
Der alte Trick: Vergleichen gegen <1statt ==0.
Manatwork
Dang. Ich griff nach for(;!($argv[1]%$i);$i++);echo$i;. Dein ist die natürliche Entwicklung von mir. Das hat meine Zustimmung!
Ismael Miguel
3

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.

Gedächtnisstütze
quelle
I2/L/);?%<@Ofür ein paar Bytes weniger. Gleicher allgemeiner Prozess, nur ein anderer Weg
MickyT
2

> <> , 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!

Sok
quelle
2

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.

Zgarb
quelle