Eine meiner Lieblingsdefinitionen der Primzahlen lautet:

• 2 ist die kleinste Primzahl.

• Zahlen größer als 2 sind Primzahlen, wenn sie nicht durch eine kleinere Primzahl teilbar sind.

Wie auch immer diese Definition willkürlich erscheint, warum 2? Warum nicht eine andere Nummer? Versuchen wir es mit einigen anderen Zahlen, die n-Primzahlen definieren

• n ist die kleinste n-Primzahl.

• Zahlen größer als n sind n-Primzahlen, wenn sie nicht durch eine kleinere n-Primzahl teilbar sind.

Aufgabe

Die Aufgabe hier ist es, ein Programm zu schreiben, das zwei Eingaben annimmt, eine positive ganze Zahl n und eine positive ganze Zahl a . Es wird dann entscheiden , ob eine ist n -Prime. Ihr Programm sollte zwei unterschiedliche Werte ausgeben, einen für "Ja, es ist n-prim" und einen für "Nein, es ist nicht n-prim".

Dies ist eine Code-Golf-Frage, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Tests

Hier sind Listen der ersten 31 Primzahlen für n = 2 bis n = 12 (1 ist die einzige 1-Primzahl)

n=2: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=3: [3,4,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=4: [4,5,6,7,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=5: [5,6,7,8,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=6: [6,7,8,9,10,11,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=7: [7,8,9,10,11,12,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=8: [8,9,10,11,12,13,14,15,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=9: [9,10,11,12,13,14,15,16,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=10: [10,11,12,13,14,15,16,17,18,19,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=11: [11,12,13,14,15,16,17,18,19,20,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=12: [12,13,14,15,16,17,18,19,20,21,22,23,25,27,29,31,33,35,37,41,43,47,49,53,55,59,61,67,71,73,77]

Haskell , 45 Bytes

n!a=not$any(n!)[x|x<-[n..a-1],mod a x<1]||n>a

Probieren Sie es online!

Ich definiere eine nette rekursive Funktion (!):

n!aprüft, ob ein Faktor ain dem Bereich [n,a-1]ein ist n-prime. Dann wird das Ergebnis negiert. Es stellt auch sicher, dassn>a

Python 2 , 39 37 Bytes

Vielen Dank an Halvard Hummel für -2 Bytes.

f=lambda n,i:n==i or i>i%n>0<f(n+1,i)

Probieren Sie es online!

Python 3 , 45 Bytes

lambda i,k:(i>k)<all(k%r for r in range(i,k))

Probieren Sie es online!

Wie es funktioniert

Dies nimmt zwei ganze Zahlen als Eingabe, i und k . Zuerst wird geprüft, ob k ≥ i ist . Erzeugt dann den Bereich [i, k) und für jede ganze Zahl N in diesem Bereich liegt, wird geprüft , ob N teilerfremd ist zu k . Sind beide Bedingungen erfüllt, so ist k ein i -Prom.

Schale , 6 5 Bytes

εf≥⁰Ḋ

Probieren Sie es online! oder sehen Ergebnisse bis zu 80 .

Danke an Leo für -1 Byte.

Erläuterung

εf≥⁰Ḋ  Inputs are n and k.
    Ḋ  Divisors of k.
 f     Keep those that are
  ≥⁰   at least n.
ε      Is the result a one-element list?

R , 44 37 Bytes

function(a,n)a==n|a>n&all(a%%n:(a-1))

Probieren Sie es online!

-7 Bytes dank Giuseppe

Gibt zurück, TRUEwenn

• aist gleich noder ( a==n|)
• aist größer als n und ( a>n&) für jede Zahl k von nbis a-1, aist nicht gleichmäßig teilbar durch k ( all(a%%n:(a-1)))

Kehrt FALSEsonst zurück

J, 30 Bytes

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:

Probieren Sie es online!

Nimmt den Startwert als rechtes Argument und den zu überprüfenden Wert als linkes Argument.

Ursprünglich habe ich alles durcheinander gebracht und nicht weniger als die Start-Primzahl für übrige Argumente verantwortlich gemacht. Ich bin jetzt etwas unzufrieden mit der Länge meiner Lösung.

Erläuterung

Sei xdas linke Argument (der zu prüfende Wert) und ysei das rechte Argument (der Startprimus).

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:
                          ^:>:  Execute left argument if x >= y
                     i.@[         Create range [0..x]
                   ]+             Add y to it (range now: [y..x+y])
                |/~               Form table of residues
            0=                    Equate each element to 0
          +/                      Sum columns
      1=                          Equate to 1
    -{                            Take the element at position x-y
>:*                             Multiply by result of x >= y

Anmerkungen

Das Element an Position x-yist das Ergebnis des Primärtests für x(da wir yden ursprünglichen Bereich erweitert haben).

Das Multiplizieren mit x >: ystellt sicher, dass wir einen Falsey-Wert ( 0) für xweniger als erhalten y.

JavaScript (ES6), 33 32 30 Byte

Übernimmt Eingaben in der Currying-Syntax (n)(a). Gibt einen Booleschen Wert zurück.

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

Demo

let f =

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

for(n = 2; n <= 12; n++) {
  for(a = n, P = []; P.length < 31; a++) {
    f(n)(a) && P.push(a);
  }
  O.innerText += 'n=' + n + ': ' + P.join(',') + '\n';
}

<pre id=O></pre>

Haskell , 30 Bytes

Dank der Idee von H.PWiz, die aus der Antwort von flawr entlehnt wurde, konnten 2 Byte eingespart werden

n!a=[1]==[1|0<-mod a<$>[n..a]]

Probieren Sie es online!

Ok, seit einiger Zeit, und die einzige Antwort von Haskell sind 45 Btyes. Ich habe beschlossen, meine eigene Antwort zu posten.

Erläuterung

Diese Funktion prüft, ob die einzige Zahl zwischen n und a , durch die a teilbar ist, a ist selbst ist.

Jetzt werden in der Definition nur n- Zeiten kleiner als a erwähnt . Warum überprüfen wir also alle diese zusätzlichen Zahlen? Haben wir keine Probleme, wenn a durch ein n- Komposit größer als n teilbar ist ?

Wir werden es nicht tun, denn wenn es ein n- Komposit gibt, das größer als n ist , muss es per Definition durch ein kleineres n- Prime teilbar sein . Wenn also a geteilt wird , muss das kleinere n -Prom sein.

Wenn a kleiner als n [n..a] ist, []kann dies nicht dazu führen, [1]dass die Prüfung fehlschlägt.

Gelee , 8 Bytes

rṖ⁴%$Ạ×<

Probieren Sie es online!

Pip , 23 19 14 Bytes

b>=a&$&b%(a,b)

Die kürzeste Methode ist eine Portierung von Mr. Xcoders Python-Antwort . Nimmt die kleinste Primzahl und die zu testende Zahl als Befehlszeilenargumente. Probieren Sie es online!

C 55 Bytes

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return-1<i;}

Probieren Sie es online!

53 Bytes, wenn mehrere wahrheitsgemäße Rückgabewerte zulässig sind:

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return~i;}

Probieren Sie es online!

Gleichstrom , _{40 34} 37 Bytes

[0p3Q]sf?se[dler%0=f1+dle>u]sudle>u1p

Ich hätte einen TIO-Link eingefügt, aber TIO scheint eine fehlerhafte Distribution zu haben dc, da es so funktioniert, wie es auf meinem System beabsichtigt ist, aber der QBefehl auf TIO fehlerhaft funktioniert. Stattdessen finden Sie hier einen Link zu einem bashTestgelände mit einer korrekt funktionierenden Version vondc :

Demo It!

APL (Dyalog) , 24 Bytes

{⍵∊o/⍨1=+/¨0=o|⍨⊂o←⍺↓⍳⍵}

Probieren Sie es online!

Wie?

⍳⍵- 1bisa

o←⍺↓- nbis a, speichern biso

o|⍨⊂o- Modulo jedes Element in omit jedem Element ino

0= - Überprüfen Sie, wo es gleich ist 0 (dividiert)

+/¨ - Summiere die Anzahl der Unterteilungen

1= - Wenn wir nur eine haben, wird die Zahl nur durch sich selbst geteilt

o/⍨ - Also behalten wir diese Vorkommnisse

⍵∊- Ist ain diesem Restarray?

JavaScript (Node.js) , 27 Byte

i=>f=n=>i==n||i>i%n&&f(n+1)

Probieren Sie es online!

Port meiner Python-Antwort, nimmt Eingaben in der aktuellen Syntax vor: m(number)(first prime)

JavaScript ES5, 34 Bytes

for(a=i=(p=prompt)();a%--i;);i<p()

Add ++ , 20 Bytes

L,2Dx@rBcB%B]b*!!A>*

Probieren Sie es online!

L,   - Create a lambda function
     - Example arguments:  [5 9]
  2D - Copy below; STACK = [5 9 5]
  x  - Repeat;     STACK = [5 9 [9 9 9 9 9]]
  @  - Reverse;    STACK = [[9 9 9 9 9] 5 19] 
  r  - Range;      STACK = [[9 9 9 9 9] [5 6 7 8 9]]
  Bc - Zip;        STACK = [[9 5] [9 6] [9 7] [9 8] [9 9]]
  B% - Modulo;     STACK = [4 3 2 1]
  B] - Wrap;       STACK = [[4 3 2 1]]
  b* - Product;    STACK = [24]
  !! - Boolean;    STACK = [1]
  A  - Arguments;  STACK = [1 5 9]
  >  - Greater;    STACK = [1 1]
  *  - Product;    STACK = [1]