Jest to sekwencja A054261 .

p liczbę pierwszą obudowy jest najniższy numer, który zawiera pierwsze liczb pierwszych jak podciągów. Na przykład liczba jest najniższą liczbą zawierającą pierwsze 3 liczby pierwsze jako podciągi, co czyni ją trzecią liczbą przechowującą pierwszą liczbę.$n$$n$$235$

Trywialne jest stwierdzenie, że pierwsze cztery pierwsze liczby przechowujące to , , i , ale potem staje się bardziej interesujące. Ponieważ następna liczba pierwsza to 11, kolejnym numerem przechowującym nie jest , ale ponieważ jest zdefiniowana jako najmniejsza liczba z właściwością.$2$$23$$235$$2357$$235711$$112357$

Jednak prawdziwe wyzwanie pojawia się, gdy przekroczysz 11. Następna główna liczba przechowalni to . Zauważ, że pod tym numerem podciągi i nachodzą na siebie. Liczba również pokrywa się z liczbą .$113257$1113313

Łatwo jest udowodnić, że ta sekwencja rośnie, ponieważ następna liczba musi spełniać wszystkie kryteria liczby przed nią i mieć jeszcze jeden podciąg. Jednak sekwencja nie zwiększa się ściśle, jak pokazują wyniki dla n=10i n=11.

Wkład

Pojedyncza liczba całkowita n>0(przypuszczam, że można ją również indeksować 0, a następnie tworzyć n>=0)

Wydajność

Albo npierwsza liczba przechowująca, albo lista zawierająca pierwsze npierwsze liczby przechowujące.

Znalezione do tej pory liczby to:

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

Zauważ, że n = 10i n = 11są tym samym numerem, ponieważ jest najniższą liczbą, która zawiera wszystkie liczby , ale zawiera także .$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

Ponieważ jest to oznaczone kodem golfowym, zacznij grać w golfa! Rozwiązania z użyciem siły brute są dozwolone, ale twój kod musi działać na wszelkie dane teoretyczne (co oznacza, że ​​nie możesz po prostu połączyć pierwszych n liczb pierwszych). Miłej gry w golfa!

05AB1E , 8 bajtów

∞.ΔIÅpåP

Wypróbuj online!

Wyjaśnienie

           # 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

Galaretka , 11 bajtów

³ÆN€ẇ€µẠ$1#

Wypróbuj online!

Prosta brutalna siła. Nie jestem całkowicie pewien, jak #działa arity, więc może być miejsce na ulepszenia.

Jak to działa

³Æ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 bajty

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;}

Wypróbuj online.
UWAGI:

1. Upłynęły czasy powyżej n=7.
2. Biorąc pod uwagę wystarczającą ilość czasu i zasobów, działa tylko maksymalnie ze n=9względu na limit wielkości int(maksymalnie 2,147,483,647).
   • Przy +4 bajtach zmieniających się intna along , maksimum jest zwiększane do wyjścia poniżej 9,223,372,036,854,775,807( n=20myślę, że?)
   • Używając java.math.BigIntegermaksimum można zwiększyć do dowolnego rozmiaru (teoretycznie), ale będzie to około +200 bajtów przynajmniej ze względu na szczegółowość java.math.BigIntegermetod.

Wyjaśnienie:

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 bajtów

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(;`

Wypróbuj online!

W jaki sposób?

$n$

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

$n$

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

Skomentował

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(;" ]

Rubinowy , 58 bajtów

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

Wypróbuj online!

Brute-force, działa do 7 w TIO.

Pyth , 14 bajtów

$n>5$

f@I`M.fP_ZQ1y`

Wypróbuj 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 bajtów

Nieco szybciej, ale 1 bajt dłużej.

f.A/L`T`M.fP_ZQ

Wypróbuj 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.

Galaretka , 14 bajtów

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

Wypróbuj online!

Węgiel drzewny , 42 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Zbuduj pierwsze nliczby pierwsze, dzieląc próbnie wszystkie liczby całkowite przez wszystkie wcześniej znalezione liczby pierwsze.

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

Zapętlaj wszystkie liczby całkowite, aż znajdziemy taki, który zawiera wszystkie liczby pierwsze jako podłańcuchy.

Ｉη

Rzuć wynik na ciąg i niejawnie wydrukuj.

Prędkość programu może zostać podwojona kosztem bajt zastępując ostatnią ≦⊕ηz ≦⁺²ηale to wciąż zbyt wolno, aby obliczyć n>6.

Perl 6 , 63 59 bajtów

-4 bajty dzięki nwellnhof

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

Wypróbuj online!

Brute force rozwiązania, które przekraczają limit czasu dla TIO dla liczb powyżej 5, ale jestem pewien, że działa poprawnie. Znajduje pierwszą liczbę dodatnią, która zawiera pierwsze nliczby pierwsze. Oto rozwiązanie, na które nie ma czasu n=6.

Wyjaśnienie:

{                                                             } # 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 bajtów

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)

Wypróbuj online!

f jest funkcją.

Python 2 , 91 bajtów

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

Wypróbuj online!

SAS, 149 bajtów

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; 

Dane wejściowe są wprowadzane zgodnie z cards;instrukcją:

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

Wysyła zestaw danych p, z wynikiem v, z wierszem wyjściowym dla każdej wartości wejściowej. Powinien technicznie działać dla wszystkich podanych przypadków testowych (maksymalna liczba całkowita z pełną precyzją w SAS wynosi 9 007,199,254,740,992), ale poddałem się, pozwalając mu myśleć przez 5 minut na n = 8.

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

Wyjaśnienie / Niegolfowany

Ponieważ już Data.Listzaimportowaliśmy, równie dobrze możemy go użyć: zamiast starego dobrego take n[p|p<-[2..],all((>0).mod p)[2..p-1]]możemy użyć innego sposobu generowania wszystkich liczb pierwszych, których potrzebujemy. Mianowicie, generujemy wystarczającą ilość kompozytów i używamy ich razem z (\\):

[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 18 bajtów

Daleko od mojej najlepszej pracy, po prostu cieszyłem się, że mogę ją uruchomić po dniu, który miałem. Jestem pewien, że skończę później, popijając go alkoholem!

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

Spróbuj - potrzeba 13 sekund, aby uruchomić dane wejściowe 7, po czym rzuca niepewnie (zaktualizowana wersja jest 5dla mnie dostępna, ale może to być po prostu mój telefon).