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 Code-Golf , die niedrigste Anzahl von Bytes wird wahrscheinlich Ende des Monats zum Gewinner erklärt.

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.

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!

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.

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

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 .

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.

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.

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..*
}

Jelly , 14 Bytes

D=2×\S:³aÆPµ1#

Sehr ineffizient. Probieren Sie es online!

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"

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.

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

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.

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)

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

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.

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.

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.