Dies ist die Sequenz A054261 .

Die te Primzahl ist die niedrigste Zahl, die die ersten Primzahlen als Teilzeichenfolgen enthält. Zum Beispiel ist die Zahl die niedrigste Zahl, die die ersten 3 Primzahlen als Teilzeichenfolgen enthält, was sie zur dritten Primzahl macht.$n$$n$$235$

Es ist trivial herauszufinden, dass die ersten vier Primzahlen , , und , aber dann wird es interessanter. Da die nächste Primzahl 11 ist, ist die nächste Primzahl nicht , sondern da sie als die kleinste Zahl mit der Eigenschaft definiert ist.$2$$23$$235$$2357$$235711$$112357$

Die eigentliche Herausforderung ergibt sich jedoch, wenn Sie über 11 hinausgehen. Die nächste Primzahl lautet . Beachten Sie, dass sich in dieser Nummer die Teilzeichenfolgen und überlappen. Die Nummer überschneidet sich auch mit der Nummer .$113257$1113313

Es ist leicht zu beweisen, dass diese Folge zunimmt, da die nächste Zahl alle Kriterien der Zahl davor erfüllen und eine weitere Teilzeichenfolge haben muss. Die Sequenz nimmt jedoch nicht unbedingt zu, wie die Ergebnisse für n=10und zeigen n=11.

Eingang

Eine einzelne Ganzzahl n>0(ich nehme an, Sie könnten sie auch 0-indizieren lassen und dann machen n>=0)

Ausgabe

Entweder die nth Prim Containment-Nummer oder eine Liste mit den ersten nPrim Containment-Nummern.

Die Zahlen, die ich bisher gefunden habe, sind:

 1 =>             2
 2 =>            23
 3 =>           235
 4 =>          2357
 5 =>        112357
 6 =>        113257
 7 =>       1131725
 8 =>     113171925
 9 =>    1131719235
10 =>  113171923295
11 =>  113171923295
12 => 1131719237295

Beachten Sie, dass n = 10und n = 11dieselbe Nummer sind, da die niedrigste Nummer ist, die alle Nummern , aber auch .$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

Da dies Code Golf markiert ist, erhalten Sie Golf! Brute-Force-Lösungen sind zulässig, aber Ihr Code muss theoretisch für jede Eingabe geeignet sein (dh, Sie können nicht nur die ersten n Primzahlen verketten). Viel Spaß beim Golfen!

05AB1E , 8 Bytes

∞.ΔIÅpåP

Probieren Sie es online!

Erläuterung

           # from
∞          # a list of infinite positive integers
 .Δ        # find the first which satisfies the condition:
       P   # all
   IÅp     # of the first <input> prime numbers
      å    # are contained in the number

Jelly , 11 Bytes

³ÆN€ẇ€µẠ$1#

Probieren Sie es online!

Einfache rohe Gewalt. Ich bin mir nicht ganz sicher, wie #die Arität funktioniert, daher gibt es möglicherweise Raum für Verbesserungen.

Wie es funktioniert

³ÆN€ẇ€µẠ$1#    Main link. Input: Index n.
         1#    Find the first natural number N that satisfies:
³ÆN€             First n primes...
    ẇ€           ...are substrings of N
      µẠ$        All of them are true

Java 8, 143 Bytes

n->{int r=1,f=1,c,i,j,k;for(;f>0;r++)for(i=2,f=c=n;c>0;c-=j>1?1+0*(f-=(r+"").contains(j+"")?1:0):0)for(j=i++,k=2;k<j;)j=j%k++<1?0:j;return~-r;}

Probieren Sie es online aus.
ANMERKUNGEN:

1. Mal oben raus n=7.
2. Wenn genügend Zeit und Ressourcen zur Verfügung stehen, funktioniert dies n=9aufgrund der Größenbeschränkung von int(maximal 2,147,483,647) nur bis zu maximal .
   • Mit +4 Bytes, die sich intin a ändernlong , wird das Maximum auf eine Ausgabe darunter erhöht 9,223,372,036,854,775,807(ungefähr n=20denke ich?)
   • Durch die Verwendung java.math.BigIntegerdes Maximums kann es (theoretisch) auf jede beliebige Größe erhöht werden, aber es wird etwa +200 Bytes betragen, zumindest aufgrund der Ausführlichkeit der java.math.BigIntegerMethoden.

Erläuterung:

n->{                   // Method with integer as both parameter and return-type
  int r=1,             //  Result-integer, starting at 1
      f=1,             //  Flag-integer, starting at 1 as well
      c,               //  Counter-integer, starting uninitialized
      i,j,k;           //  Index integers
  for(;f>0;            //  Loop as long as the flag is not 0 yet
      r++)             //    After every iteration, increase the result by 1
    for(i=2,           //   Reset `i` to 2
        f=c=n;         //   Reset both `f` and `c` to the input `n`
        c>0;           //   Inner loop as long as the counter is not 0 yet
        c-=            //     After every iteration, decrease the counter by:
           j>1?        //      If `j` is a prime:
            1          //       Decrease the counter by 1
            +0*(f-=    //       And also decrease the flag by:
                   (r+"").contains(j+"")?
                       //        If the result `r` contains the prime `j` as substring
                    1  //         Decrease the flag by 1
                   :   //        Else:
                    0) //         Leave the flag the same
           :           //      Else:
            0)         //       Leave the counter the same
      for(j=i++,       //    Set `j` to the current `i`,
                       //    (and increase `i` by 1 afterwards with `i++`)
          k=2;         //    Set `k` to 2 (the first prime)
          k<j;)        //    Inner loop as long as `k` is smaller than `j`
        j=j%k++<1?     //     If `j` is divisible by `k`
           0           //      Set `j` to 0
          :            //     Else:
           j;          //      Leave `j` the same
                       //    (If `j` is unchanged after this inner-most loop,
                       //     it means `j` is a prime)
  return~-r;}          //  Return `r-1` as result

JavaScript (ES6),  105 ... 92  91 Bytes

n=>(k=1,g=(s,d=k++)=>n?k%d--?g(s,d):g(d?s:s+`-!/${n--,k}/.test(n)`):eval(s+';)++n'))`for(;`

Probieren Sie es online!

Wie?

$n$

"-!/2/.test(n)-!/3/.test(n)-!/5/.test(n)-!/7/.test(n)-!/11/.test(n)..."

$n$

eval('for(;' + <conditions> + ';)++n')

Kommentiert

n => (                             // main function taking n
  k = 1,                           // k = current prime candidate, initialized to 1
  g = (s,                          // g = recursive function taking the code string s
          d = k++) =>              //     and the divisor d
    n ?                            // if n is not equal to 0:
      k % d-- ?                    //   if d is not a divisor of k:
        g(s, d)                    //     recursive call to test the next divisor
      :                            //   else:
        g(                         //     recursive call with s updated and d undefined:
          d ?                      //       if d is not equal to 0 (i.e. k is composite):
            s                      //         leave s unchanged
          :                        //       else (k is prime):
            s +                    //         decrement n and add to s
            `-!/${n--,k}/.test(n)` //         the next condition based on the prime k
                                   //       the lack of 2nd argument triggers 'd = k++'
        )                          //     end of recursive call
    :                              // else (n = 0):
      eval(s + ';)++n')            //   complete and evaluate the code string
)`for(;`                           // initial call to g with s = [ "for(;" ]

Ruby , 58 Bytes

->n,i=1{i+=1until Prime.take(n).all?{|x|/#{x}/=~"#{i}"};i}

Probieren Sie es online!

Brute-Force, arbeitet bis zu 7 auf TIO.

Pyth , 14 Bytes

$n>5$

f@I`M.fP_ZQ1y`

Probieren Sie es online!

f@I`M.fP_ZQ1y`     Full program. Q is the input.
f                  Find the first positive integer that fulfils the condition.
 @I`M.fP_ZQ1y`     Filtering condition, uses T to refer to the number being tested.
     .f   Q1       Starting at 1, find the first Q positive integers (.f...Q1) that
       P_Z         Are prime.
   `M              Convert all of those primes to strings.
  I                Check whether the result is invariant (i.e. doesn't change) when...
 @          y`     Intersecting this list with the powerset of T as a string.

Pyth , 15 Bytes

Etwas schneller, aber 1 Byte länger.

f.A/L`T`M.fP_ZQ

Probieren Sie es online!

f.A/L`T`M.fP_ZQ     Full program. Q is the input.
f                   Find the first positive integer that fulfils the condition.
 .A/L`T`M.fP_ZQ     Filtering condition, uses T to refer to the number being tested.
         .f   Q     Starting at 1, find the first Q positive integers (.f...Q) that
           P_Z      Are prime.
       `M           Convert all of those primes to strings.
 .A/L               And make sure that they all (.A) occur in (/L)...
     `T             The string representation of T.

Jelly , 14 Bytes

³RÆNṾ€ẇ€ṾȦ
Ç1#

Probieren Sie es online!

Holzkohle , 42 Bytes

≔¹ηＷ‹ＬυＩθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»≔¹ηＷΦυ¬№ＩηＩκ≦⊕ηＩη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔¹ηＷ‹ＬυＩθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»

Bauen Sie die ersten nPrimzahlen durch Versuchsteilung aller ganzen Zahlen durch alle zuvor gefundenen Primzahlen auf.

≔¹ηＷΦυ¬№ＩηＩκ≦⊕η

Durchlaufen Sie alle Ganzzahlen, bis Sie eine finden, die alle Primzahlen als Teilzeichenfolgen enthält.

Ｉη

Wandle das Ergebnis in einen String um und drucke implizit.

Die Geschwindigkeit des Programms kann durch Ersetzen des letzten zu einem Preis von einem Byte verdoppelt werden ≦⊕ηmit , ≦⁺²ηaber es ist immer noch zu langsam zu berechnen n>6.

Perl 6 , 63 59 Bytes

-4 bytes dank nwellnhof

{+(1...->\a{!grep {a~~!/$^b/},(grep &is-prime,2..*)[^$_]})}

Probieren Sie es online!

Eine Brute-Force-Lösung, die bei TIO eine Zeitüberschreitung für Zahlen über 5 aufweist, aber ich bin mir ziemlich sicher, dass sie richtig funktioniert. Findet die erste positive Zahl, die die ersten nPrimzahlen enthält . Hier ist eine Lösung , für die es keine Zeitüberschreitung gibt n=6.

Erläuterung:

{                                                             } # Anonymous code block
 first                                                    2..*  # Find the first number
       ->\a{                                            }       # Where:
            !grep     # None of
                                                   [^$_]  # The first n
                              (grep &is-prime,2..*)       # primes
                  {a~~!/$^b/},   # Are not in the current number

Python 2 , 131 Bytes

f=lambda n,x=2:x*all(i in`x`for i in g(n,2))or f(n,x+1)
def g(n,x):p=all(x%i for i in range(2,x));return[0]*n and[`x`]*p+g(n-p,x+1)

Probieren Sie es online!

f ist die Funktion.

Python 2 , 91 Bytes

n=input();l=[]
P=k=1
while~-all(`x`in`k`for x in(l+[l])[:n]):P*=k*k;k+=1;l+=P%k*[k]
print k

Probieren Sie es online!

SAS, 149 Bytes

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards; 

Die Eingabe erfolgt wie folgt cards;:

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards; 
1
2
3
4
5
6
7

Gibt einen Datensatz pmit dem Ergebnis vmit einer Ausgabezeile für jeden Eingabewert aus. Sollte technisch für alle gegebenen Testfälle funktionieren (die maximale Ganzzahl mit voller Genauigkeit in SAS ist 9.007.199.254.740.992), aber ich habe aufgegeben, nachdem ich es 5 Minuten lang über n = 8 nachdenken ließ.

Erläuterung:

data p;
input n; /* Read a line of input */

z: /* Jump label (not proud of this) */
    i=1; /* i is the current value which we are checking for primality */
    a=0; /* a is the number of primes we've found so far */
    v+1; /* v is the final output value which we'll look for substrings in */ 

    do while(a<n); /* Loop until we find the Nth prime */
        i+1; 
        do j=2 to i while(mod(i,j));end; /* Prime sieve: If mod(i,j) != 0 for all j = 2 to i, then i is prime. This could be faster by only looping to sqrt(i), but would take more bytes */
        if j=i then do; /* If i is prime (ie, we made it to the end of the prime sieve)... */
            a+1;
            if find(cat(v),cat(i))=0 then goto z; /* If i does not appear as a substring of v, then start all over again with the next v */
        end;
    end;

/* Input values, separated by newlines */
cards; 
1
2
3
4
5
6
7

Haskell , 102 Bytes

import Data.List
f n|x<-[2..n*n]=[a|a<-[2..],all(`isInfixOf`show a).take n$show<$>x\\((*)<$>x<*>x)]!!0

Probieren Sie es online!

Erklärung / Ungolfed

Da wir bereits Data.Listimportiert haben , können wir es genauso gut verwenden: Anstelle des guten alten können take n[p|p<-[2..],all((>0).mod p)[2..p-1]]wir auch eine andere Methode verwenden, um alle Primzahlen zu generieren, die wir benötigen. Wir erzeugen nämlich eine ausreichende Menge an Verbundwerkstoffen und verwenden diese zusammen mit (\\):

[2..n*n] \\ ( (*) <$> [2..n*n] <*> [2..n*n] )

n*n$\pi(n) < \frac{n^2}{\log(n^2)}$

[ a | a <- [2..], all (`isInfixOf` show a) . take n $ enoughPrimes ] !!0

Japt, 20 bis 18 Bytes

Weit entfernt von meiner besten Arbeit, war ich einfach froh, dass es nach dem Tag, den ich hatte, funktioniert. Ich bin mir sicher, dass ich es später im Säufer abklopfen werde!

_õ fj ¯U e!øZs}aUÄ

Probieren Sie es aus - es dauert 13 Sekunden, bis eine Eingabe von ausgeführt wird 7, und danach wird ein Wackeleffekt ausgelöst (die aktualisierte Version ist 5für mich ein Würfelspiel , aber das könnte nur mein Telefon sein).