Kleinster Prime mit einem Twist (A068103)


33

Die Aufgabe besteht darin, bei gegebener Zahl ndie kleinste Primzahl zu finden, die mit MINDESTEN n der Zahl 2am Anfang der Zahl beginnt . Dies ist eine Sequenz, die ich in OEIS ( A068103 ) gefunden habe.

Die ersten 17 Zahlen in der Sequenz sind unten angegeben. Wenn Sie mehr wollen, muss ich die Sequenz tatsächlich implementieren, was mir nichts ausmacht.

0  = 2
1  = 2
2  = 223
3  = 2221
4  = 22229
5  = 2222203
6  = 22222223                # Notice how 6 and 7 are the same! 
7  = 22222223                # It must be **AT LEAST** 6, but no more than necessary.
8  = 222222227
9  = 22222222223             # Notice how 9 and 10 are the same!
10 = 22222222223             # It must be **AT LEAST** 9, but no more than necessary.
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221

Ich dachte, dies wäre eine coole Kombination aus String-Manipulation, Prim-Erkennung und Sequenzen. Dies ist , die niedrigste Anzahl von Bytes wird wahrscheinlich Ende des Monats zum Gewinner erklärt.


5
Gibt es eine Untergrenze für die Höhe eines Inputs, den wir unterstützen müssen?
ETHproductions

1
Gibt es eine zeitliche Begrenzung?
Brad Gilbert b2gills

@ETHProductions sorry, ging ziemlich schnell nach dem Schreiben dieses. Wenn Sie Ihre Eingabe einschränken müssen, muss die Einschränkung mit einem logischen Argument belegt werden, warum die Sprache keine höheren Zahlen als unterstützt x. Wenn Ihre Sprache beispielsweise nur 32-Bit-Ganzzahlen unterstützt, können Sie dies erklären.
Magic Octopus Urn

Antworten:


12

Brachylog , 12 11 Bytes

:2rj:Acb#p=

Probieren Sie es online!

Dies führt überraschend direkt zu Brachylog. Dies ist eine Funktion, kein vollständiges Programm (auch wenn der Interpreter Zals Befehlszeilenargument angegeben wird, fügt er den entsprechenden Wrapper hinzu, um die Funktion in ein Programm umzuwandeln; das habe ich getan, damit die TIO-Verknüpfung funktioniert). Es ist auch ziemlich bedauerlich, dass jder Index -1 ist und eine Korrektur benötigt, um dies zu berücksichtigen.

Sie können ein vernünftiges Argument dafür vorbringen, dass das =nicht notwendig ist, aber ich denke, dass es das ist, wenn man bedenkt, wie das Problem formuliert ist. ohne, ist die Funktion die Menge aller Primzahlen zu beschreiben , die mit der gegebenen Anzahl von beginnen 2s, und ohne eine ausdrückliche Erklärung , dass das Programm tun , etwas mit dieser Beschreibung (in diesem Fall den ersten Wert zu erzeugen), hat es wahrscheinlich nicht Die Spezifikation einhalten.

Erläuterung

:2rjbAcb#p=
:2rj         2 repeated a number of times equal to the input plus one
    :Ac      with something appended to it
       b     minus the first element
        #p   is prime;
          =  figure out what the resulting values are and return them

Bei Verwendung als eine Funktion, die eine Ganzzahl zurückgibt, werden niemals Werte nach dem ersten angefordert, so dass wir uns nur um den ersten Gedanken machen müssen.

Eine Subtilität (in den Kommentaren hervorgehoben): :Acbund b:Acsind mathematisch äquivalent (da eine vom Anfang entfernt und die andere zum Ende hinzugefügt wird, wobei sich die Region dazwischen nie überlappt); Ich hatte vorher b:Ac, was natürlicher ist, aber es bricht bei Eingabe 0 ab (was ich vermute, ist, weil es sich cweigert, eine leere Liste mit irgendetwas zu verknüpfen; viele Brachylog-Builtins neigen aus irgendeinem Grund dazu, bei leeren Listen zu brechen). :Acbstellt sicher, dass cniemals eine leere Liste angezeigt werden muss, sodass der Fall von Eingang 0 jetzt auch funktionieren kann.


@muddyfish: Das tut es. Es hat jedoch 0ohne ersichtlichen Grund nicht funktioniert (Brachylog scheint aus irgendeinem Grund allergisch gegen Nullen zu sein; ich vermute, das cist dafür verantwortlich). Das heißt, es ist leicht zu beheben, also werde ich das jetzt beheben.

b:Acfunktioniert nicht, weil für die Eingabe, die 0Sie erhalten 2b:Ac: 2bgibt 0und Sie nicht cmit einer führenden Null verwenden können. Der Grund dafür ist die Vermeidung von Endlosschleifen in dem allgemeinen Fall, dass Sie immer eine Null voranstellen und die gleichen Ergebnisse erzielen könnten.
Fatalize

Sie können dies auch um ein Byte verkürzen, indem Sie :2rj,2:?j
Folgendes

Ich habe es vergessen r; Das ist nur eine deutliche Verbesserung. Ich verstehe, was los ist c(Sie wollen nicht unendlich viele Ergebnisse, wenn Sie rückwärts laufen); Eine wahrscheinliche Verbesserung besteht darin, dass entartete Eingaben nur dann nicht zugelassen werden, wenn sie nicht gebunden sind, während sie zugelassen werden, wenn die Eingabe bereits an einen entarteten Wert gebunden ist.

Dies ist definitiv machbar und ich werde es im Github-Tracker hinzufügen. Obwohl die Implementierung von concatenate bereits fast 100 Zeilen lang ist, ist dies eine Menge für ein Prolog-Prädikat.
Fatalize

15

Java (OpenJDK 8) , 164 - 110 Byte

a->{int i=0;for(;!(i+"").matches("2{"+a+"}.*")|new String(new char[i]).matches(".?|(..+)\\1+");i++);return i;}

Vielen Dank an @FryAmTheEggman für ein paar Bytes!

Probieren Sie es online!


2
Können Sie erklären, wie ein regulärer Ausdruck funktioniert?
J. Antonio Perez

Ich habe keine Ahnung. Es ist nicht meins und ich weiß nicht, wer der ursprüngliche Schöpfer ist. Ich habe gerade eine Zeichenfolge der Länge n und passt, wenn n nicht Primzahl ist.
Pavel

Wissen Sie, was die ursprüngliche Quelle ist? Wo hast du davon erfahren? Hast du deinen Code getestet?
J. Antonio Perez

3
@Pavel Diese Regex zur Überprüfung der Primalität macht diese Antwort unglaublich, auch wenn Sie es nicht geschafft haben. Sie sollten das dem Thread "Tips for Golfing in Java" hinzufügen.
Magic Octopus Urn

3
Ich kann den Code derzeit nicht testen, aber ich bin mir ziemlich sicher, dass der reguläre Ausdruck folgendermaßen funktioniert: Er erstellt new String(new char[i]))eine unäre Zeichenfolge mit der Länge gleich der Zahl. Der reguläre Ausdruck stimmt dann mit einer zusammengesetzten Zahl überein, indem geprüft wird, ob die Wiederholung eines Ziffernsatzes für die gesamte Zeichenfolge geeignet ist (im Grunde genommen Testteilung). Wenn ich richtig liege, bedeutet das, dass Sie in der Lage sein sollten, den zweiten Teil zu spielen, ohne einen zu haben ?, werde ich Sie sicher informieren, wenn ich an einen Computer komme.
FryAmTheEggman

5

Pyth, 12 Bytes

f&!x`T*Q\2P_

Im Pseudocode:

f                key_of_first_truthy_value( lambda T:
  !                  not (
   x`T*Q\2               repr(T).index(input()*'2')
                     )
 &                   and
          P_T        is_prime(T)
                 )

Schleift den lambdaStart ab T=1und erhöht sich um 1, bis die Bedingung erfüllt ist. Die Zeichenfolge von 2s muss eine Teilzeichenfolge vom Anfang der Zeichenfolge sein, dh die Indexmethode muss zurückgeben 0. Wenn die Teilzeichenfolge nicht gefunden wird, wird sie zurückgegeben, -1was in geeigneter Weise auch wahr ist, sodass kein Ausnahmefall vorliegt.

Sie können es hier online ausprobieren , aber der Server erlaubt nur eine Eingabe von 4.


4

Perl, 50 Bytes

49 Byte Code + -pFlag.

++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{

Geben Sie den Eingang ohne letzte Zeile ein. Zum Beispiel:

echo -n 4 | perl -pE '++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{'

Es dauert eine Weile, bis eine Zahl größer als 4 ausgeführt wird, da jede Zahl getestet wird (es gibt 2 Tests: Der erste /^2{$_}/prüft, ob zu Beginn genug 2 vorhanden sind, und der zweite prüft, ob die (1x$\)!~/^1?$|^(11+)\1+$/Primzahl vorhanden ist (mit sehr schlechten Leistungen)).


3

Haskell, 73 Bytes

f n=[x|x<-[2..],all((>0).mod x)[3..x-1],take n(show x)==([1..n]>>"2")]!!0

Anwendungsbeispiel: f 3-> 2221.

Rohe Gewalt. [1..n]>>"2"Erstellt eine Liste von n 2s, die mit den ersten nZeichen in der Zeichenfolgendarstellung der aktuellen Primzahl verglichen wird .


3

Mathematica, 103 Bytes

ReplaceRepeated[0,i_/;!IntegerDigits@i~MatchQ~{2~Repeated~{#},___}||!PrimeQ@i:>i+1,MaxIterations->∞]&

Unbenannte Funktion, die ein nichtnegatives Ganzzahlargument verwendet #und eine Ganzzahl zurückgibt. Es testet buchstäblich alle positiven ganzen Zahlen, bis es eine findet, mit der beide beginnen# 2s und eine Primzahl ist. Schrecklich langsam für Eingaben über 5.

vorheriges Ergebnis: Mathematica, 155 Bytes

Mathematica wäre besser zum Golfen geeignet, wenn es nicht so stark getippt wäre. Wir müssen explizit zwischen Integer-, Listen- und String-Typen hin- und herschalten.

(d=FromDigits)[2&~Array~#~Join~{1}//.{j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}//.{a__,b_,10,c___}->{a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b})]/. 23->2&

Dieser Algorithmus arbeitet auf Listen der Stellen , seltsam, beginnend mit {2,...,2,1}. Solange dies nicht die Ziffern einer Primzahl sind, addiert es eine zur letzten Ziffer, wobei die Regel verwendet wird {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}... und implementiert dann manuell das Übertragen der Eins zur nächsten Ziffer, solange eine der Ziffern existiert Ziffern gleich 10 nach der Regel {a__,b_,10,c___}->{a,b+1,0,c}... und dann, wenn wir so weit gegangen sind, dass das letzte der führenden 2s zu a geworden ist 3, fängt es am Ende mit einer weiteren Ziffer nach der Regel von vorne an {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. Das /. 23->2am Ende behebt nur den Sonderfall, bei dem die Eingabe lautet 1: Die meisten Primzahlen können nicht enden 2, aber 2können. (Einige Fehler sind auf den Eingängen ausgespuckt0 und1 , aber die Funktion findet den Weg zur richtigen Antwort.)

Dieser Algorithmus ist ziemlich schnell: Auf meinem Laptop dauert es beispielsweise weniger als 3 Sekunden, um zu berechnen, dass die erste Primzahl, die mit 1.000 2s beginnt, ist 22...220521.


2

Pyth, 17 Bytes

f&q\2{<`T|Q1}TPTh

Kann nicht n = 4online zu lösen scheinen , aber es ist theoretisch korrekt.

Erläuterung

               Th    Starting from (input)+1, 
f                    find the first T so that
      <              the first
          Q          (input) characters
         | 1         or 1 character, if (input) == 0
       `T            of T's string representation
     {               with duplicates removed
  q\2                equal "2", 
 &                   and
            }T       T is found in
              PT     the list of T's prime factors.

2

Perl 6 , 53 Bytes

{($/=2 x$^n-1)~first {+($/~$_) .is-prime&&/^2/},0..*}

Versuch es

Erweitert:

{
  ( $/ = 2 x $^n-1 )       # add n-1 '2's to the front (cache in 「$/」)
  ~
  first {
    +( $/ ~ $_ ) .is-prime # find the first that when combined with 「$/」 is prime
    &&
    /^2/                   # that starts with a 2 (the rest are in 「$/」)
  },
  0..*
}


2

Pyke, 14 Bytes

.fj`Q\2*.^j_P&

Probieren Sie es hier aus!

.fj            - first number (asj)
   `    .^     -   str(i).startswith(V)
    Q\2*       -    input*"2"
             & -  ^ & V
          j_P  -   is_prime(j)

12 Bytes nach Bugfix und eine neue Funktion

~p#`Q\2*.^)h

Probieren Sie es hier aus!

~p           - all the primes
  #       )h - get the first where...
   `    .^   - str(i).startswith(V)
    Q\2*     -  input*"2"

2

Salbei, 69 68 Bytes

lambda n:(x for x in Primes()if '2'*len(`x`)=>'2'*n==`x`[:n]).next()

Verwendet einen Generator, um den ersten (daher kleinsten) von unendlich vielen Begriffen zu finden.


2

Japt, 20 Bytes

L²o@'2pU +Xs s1)nÃæj

Testen Sie es online! Auf meinem Computer wird es innerhalb von zwei Sekunden für alle Eingaben bis zu 14 Sekunden beendet, und danach verliert es natürlich an Genauigkeit (JavaScript hat nur eine ganzzahlige Genauigkeit von bis zu 2 53 ).

Vielen Dank an @obarakon für die Arbeit daran :-)

Erläuterung

                       // Implicit: U = input integer, L = 100
L²o                    // Generate the range [0...100²).
   @             Ã     // Map each item X through the following function:
    '2pU               //   Take a string of U "2"s.
         +Xs s1)n      //   Append all but the first digit of X, and cast to a number.
                       // If U = 3, we now have the list [222, 222, ..., 2220, 2221, ..., 222999].
                  æ    // Take the first item that returns a truthy value when:
                   j   //   it is checked for primality.
                       // This returns the first prime in the forementioned list.
                       // Implicit: output result of last expression

In der neuesten Version von Japt können dies 12 Bytes sein:

_n j}b!+'2pU   // Implicit: U = input integer
_   }b         // Return the first non-negative bijective base-10 integer that returns
               // a truthy value when run through this function, but first,
      !+       //   prepend to each integer
        '2pU   //   a string of U '2's.
               // Now back to the filter function:
 n j           //   Cast to a number and check for primality.
               // Implicit: output result of last expression

Testen Sie es online! Es endet innerhalb einer halben Sekunde auf meinem Computer für alle Eingaben bis zu 14.


Tolle Lösung!
Oliver

Dies schlägt am Eingang 5 fehl, da Sie niemals testen 2222203, nur 222223und bald danach 2222210. Es schlägt auch bei jeder Eingabe fehl, die drei oder mehr zusätzliche Ziffern nach der Zeichenfolge von 2s erfordert , z. B. Eingabe 15.
Greg Martin,

@ GregMartin Darn, du hast recht. Auf Kosten von 5 Bytes behoben.
ETHproductions

Dies behebt die Testfälle, der Algorithmus geht jedoch weiterhin davon aus, dass nie mehr als drei Stellen addiert werden müssen, um eine Primzahl zu finden, die für größere Eingaben falsch sein kann.
Greg Martin

@ GregMartin Dies funktioniert für alle Testfälle bis zu 14, und JS stößt in Fall 15 auf ganzzahlige Genauigkeitsprobleme. Ich glaube nicht, dass der Algorithmus nach 2 ^ 53 theoretisch korrekt sein muss, aber vielleicht irre ich mich ...
ETHproductions

2

PHP, 76 Bytes

for($h=str_pad(2,$i=$argv[1],2);$i>1;)for($i=$p=$h.++$n;$p%--$i;);echo$p?:2;

Nimmt Eingaben vom Kommandozeilenargument entgegen. Laufen Sie mit -r.

Nervenzusammenbruch

for($h=str_pad(2,$i=$argv[1],2) # init $h to required head
    ;$i>1;                      # start loop if $p>2; continue while $p is not prime
)
    for($i=$p=$h.++$n               # 1. $p = next number starting with $h
                                    #    (first iteration: $p is even and >2 => no prime)
    ;$p%--$i;);                     # 2. loop until $i<$p and $p%$i==0 ($i=1 for primes)
echo$p?:2;                      # print result; `2` if $p is unset (= loop not started)

1

Bash (+ Coreutils), 53 Bytes

Funktioniert bis zu 2 ^ 63-1 (9223372036854775807) , dauert es einige Zeit, bis N> 8 beendet ist.

Golf gespielt

seq $[2**63-1]|factor|grep -Pom1 "^2{$1}.*(?=: \S*$)"

Prüfung

>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

1

Python 3, 406 Bytes

w=2,3,5,7,11,13,17,19,23,29,31,37,41
def p(n):
 for q in w:
  if n%q<1:return n==q
  if q*q>n:return 1
 m=n-1;s,d=-1,m
 while d%2==0:s,d=s+1,d//2
 for a in w:
  x=pow(a,d,n)
  if x in(1,m):continue
  for _ in range(s):
   x=x*x%n
   if x==1:return 0
   if x==m:break
  else:return 0
 return 1
def f(i):
 if i<2:return 2
 k=1
 while k:
  k*=10;l=int('2'*i)*k
  for n in range(l+1,l+k,2):
   if p(n):return n

Testcode

for i in range(31):
    print('{:2} = {}'.format(i, f(i)))

Testausgang

 0 = 2
 1 = 2
 2 = 223
 3 = 2221
 4 = 22229
 5 = 2222203
 6 = 22222223
 7 = 22222223
 8 = 222222227
 9 = 22222222223
10 = 22222222223
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221
17 = 222222222222222221
18 = 22222222222222222253
19 = 222222222222222222277
20 = 2222222222222222222239
21 = 22222222222222222222201
22 = 222222222222222222222283
23 = 2222222222222222222222237
24 = 22222222222222222222222219
25 = 222222222222222222222222239
26 = 2222222222222222222222222209
27 = 2222222222222222222222222227
28 = 222222222222222222222222222269
29 = 2222222222222222222222222222201
30 = 222222222222222222222222222222053

Ich entschied mich für eine Geschwindigkeit über einen ziemlich großen Bereich anstatt einer Bytegröße. :) Ich verwende einen deterministischen Miller-Rabin-Primalitätstest, der mit diesem Satz von Zeugen bis zu 3317044064679887385961981 garantiert ist. Größere Primzahlen bestehen den Test immer erfolgreich, aber einige Verbundwerkstoffe bestehen möglicherweise auch, obwohl die Wahrscheinlichkeit äußerst gering ist. Ich habe jedoch auch die Ausgangszahlen für i> 22 mit pyecm, einem Programm zur Faktorisierung elliptischer Kurven , getestet und sie scheinen Primzahlen zu sein.


1
Zunächst einmal: Einreichungen müssen eine Wahrscheinlichkeit von 1 für eine korrekte Ausgabe haben. Zweitens ist das Codegolf, also muss man eigentlich die Bytegröße wählen. Ansonsten nett
Destructible Lemon

1
@DestructibleWatermelon Danke! Guter Punkt für die Bytegröße. Ich schätze, ich könnte den p()Anruf einbinden ... OTOH, es wäre schwierig, ein wesentlich kleineres Programm zu schreiben, das in weniger als einer Sekunde eine korrekte Ausgabe für i> 20 liefert (das "schummelt" nicht, wenn man ein eingebautes Programm aufruft Primalitätsprüfer). :)
PM 2Ring

Viele Programme können keine 33-stellige Nummer verarbeiten (n: = 30). Da der goldene Standard von OP nur bis zu 18 Stellen reicht und es keine von ihm / ihr festgelegte Grenze gibt, ist es vernünftig anzunehmen, dass n: = 30 gut genug für IMO ist.
user3819867

@ PM2Ring Es muss nicht "unter einer Sekunde" sein. Machen Sie den Code so kurz wie möglich und ignorieren Sie die Geschwindigkeit insgesamt. Das ist der Geist von [Code-Golf]. Ich werde meine Downvote in eine Upvote umwandeln, sobald Golf gespielt wird.
mbomb007

Tatsächlich funktioniert die Antwort mit der ersten Wahrscheinlichkeit, wenn die Ausgabe bis zum Limit korrekt ist.
Destructible Lemon

1

Python 3, 132 Bytes

def f(x):
 k=10;p=2*(k**x//9)
 while x>1:
  for n in range(p*k,p*k+k):
   if all(n%q for q in range(2,n)):return n
  k*=10
 return 2

Jede Hoffnung auf Leistung wurde für eine geringere Anzahl von Bytes geopfert.


-1

Java, 163 Bytes

BigInteger f(int a){for(int x=1;x>0;x+=2){BigInteger b=new BigInteger(new String(new char[a]).replace("\0","2")+x);if(b.isProbablePrime(99))return b;}return null;}

Testcode

    public static void main(String[] args) {
    for(int i = 2; i < 65; i++)
        System.out.println(i + " " + new Test20170105().f(i));
    }

Ausgabe:

2 223
3 2221
4 22229
5 2222219
6 22222223
7 22222223
8 222222227
9 22222222223
10 22222222223
11 2222222222243
12 22222222222229
13 22222222222229
14 222222222222227
15 222222222222222143
16 222222222222222221
17 222222222222222221
18 22222222222222222253
19 222222222222222222277
20 2222222222222222222239
21 22222222222222222222261
22 222222222222222222222283
23 2222222222222222222222237
24 22222222222222222222222219
25 222222222222222222222222239
26 2222222222222222222222222213
27 2222222222222222222222222227
28 222222222222222222222222222269
29 22222222222222222222222222222133
30 222222222222222222222222222222113
31 222222222222222222222222222222257
32 2222222222222222222222222222222243
33 22222222222222222222222222222222261
34 222222222222222222222222222222222223
35 222222222222222222222222222222222223
36 22222222222222222222222222222222222273
37 222222222222222222222222222222222222241
38 2222222222222222222222222222222222222287
39 22222222222222222222222222222222222222271
40 2222222222222222222222222222222222222222357
41 22222222222222222222222222222222222222222339
42 222222222222222222222222222222222222222222109
43 222222222222222222222222222222222222222222281
44 2222222222222222222222222222222222222222222297
45 22222222222222222222222222222222222222222222273
46 222222222222222222222222222222222222222222222253
47 2222222222222222222222222222222222222222222222219
48 22222222222222222222222222222222222222222222222219
49 2222222222222222222222222222222222222222222222222113
50 2222222222222222222222222222222222222222222222222279
51 22222222222222222222222222222222222222222222222222289
52 2222222222222222222222222222222222222222222222222222449
53 22222222222222222222222222222222222222222222222222222169
54 222222222222222222222222222222222222222222222222222222251
55 222222222222222222222222222222222222222222222222222222251
56 2222222222222222222222222222222222222222222222222222222213
57 222222222222222222222222222222222222222222222222222222222449
58 2222222222222222222222222222222222222222222222222222222222137
59 22222222222222222222222222222222222222222222222222222222222373
60 222222222222222222222222222222222222222222222222222222222222563
61 2222222222222222222222222222222222222222222222222222222222222129
62 2222222222222222222222222222222222222222222222222222222222222227
63 2222222222222222222222222222222222222222222222222222222222222227
64 2222222222222222222222222222222222222222222222222222222222222222203

582,5858 Millisekunden

Erläuterung: Schleifen über Ganzzahlen und Hinzufügen dieser als Zeichenfolgen zu der Stammzeichenfolge, bei der es sich um die angegebene Zeichenfolge "2" handelt, und Überprüfen, ob es sich um eine Primzahl handelt oder nicht.


3
isProbablePrimehat gelegentlich Fehlalarme . Dies würde die Antwort ungültig machen, da es Umstände gibt, unter denen der falsche Wert zurückgegeben wird.

Die Fehlerwahrscheinlichkeit liegt unter 2 ^ -99 (siehe Dokumentation ).
SamCle88,

@SamCle88 geringe Wahrscheinlichkeit oder nicht, dies ist aus technischer Sicht falsch. isProbablePrime ist für die Hauptüberprüfung nicht akzeptabel und wurde aufgrund anderer Herausforderungen abgelehnt.
Magic Octopus Urn
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.