Ini adalah urutan A054261 .

The th nomor penahanan utama adalah jumlah terendah yang berisi pertama bilangan prima sebagai substring. Misalnya, angka adalah angka terendah yang berisi 3 bilangan prima pertama sebagai substring, menjadikannya bilangan penampung prima ke-3.$n$$n$$235$

Sepele untuk mengetahui bahwa empat nomor penahanan prima pertama adalah , , 235 dan 2357 , tetapi kemudian semakin menarik. Karena bilangan prima berikutnya adalah 11, bilangan penampung perdana berikutnya bukan 235711 , tetapi angka 112357 karena bilangan prima terkecil dengan properti.$2$$23$$235$$2357$$235711$$112357$

Namun, tantangan sebenarnya datang ketika Anda melampaui 11. Nomor penahanan utama berikutnya adalah $113257$ . Perhatikan bahwa dalam nomor ini, substring 11dan 13tumpang tindih. Jumlahnya 3juga tumpang tindih dengan nomor tersebut 13.

Mudah untuk membuktikan bahwa urutan ini meningkat, karena nomor berikutnya harus memenuhi semua kriteria nomor sebelum itu, dan memiliki satu substring lagi. Namun, urutannya tidak meningkat secara ketat, seperti yang ditunjukkan oleh hasil untuk n=10dan n=11.

Memasukkan

Bilangan bulat tunggal n>0(saya kira Anda juga bisa memilikinya 0-diindeks, kemudian membuat n>=0)

Keluaran

Entah nnomor penahanan utama th, atau daftar yang berisi nnomor penahanan perdana pertama .

Angka yang saya temukan sejauh ini adalah:

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

Perhatikan bahwa n = 10dan n = 11adalah angka yang sama, karena adalah angka terendah yang berisi semua angka , tetapi juga berisi .$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

Karena ini ditandai kode golf, dapatkan golf! Solusi brute force diperbolehkan, tetapi kode Anda harus bekerja untuk setiap input dalam teori (yang berarti bahwa Anda tidak bisa hanya menggabungkan bilangan prima n pertama). Selamat bermain golf!

05AB1E , 8 byte

∞.ΔIÅpåP

Cobalah online!

Penjelasan

           # 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 byte

³ÆN€ẇ€µẠ$1#

Cobalah online!

Kekuatan kasar sederhana. Tidak sepenuhnya yakin bagaimana #arity bekerja, jadi mungkin ada ruang untuk perbaikan.

Bagaimana itu bekerja

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

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

Cobalah online.
CATATAN:

1. Waktu di atas n=7.
2. Diberikan cukup waktu dan sumber daya, itu hanya berfungsi hingga maksimum n=9karena batas ukuran int(maksimum 2,147,483,647).
   • Dengan +4 byte mengubah intkelong , maksimum ditingkatkan ke output di bawah ini 9,223,372,036,854,775,807(kira n=20-kira menurut saya?)
   • Dengan menggunakan java.math.BigIntegermaksimum dapat ditingkatkan ke ukuran apa pun (secara teori), tetapi akan menjadi sekitar +200 byte setidaknya karena verbositas java.math.BigIntegermetode.

Penjelasan:

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 byte

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

Cobalah online!

Bagaimana?

$n$

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

$n$

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

Berkomentar

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 byte

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

Cobalah online!

Brute-force, bekerja hingga 7 pada TIO.

Pyth , 14 byte

$n>5$

f@I`M.fP_ZQ1y`

Cobalah 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 byte

Sedikit lebih cepat tetapi 1 byte lebih lama.

f.A/L`T`M.fP_ZQ

Cobalah 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 byte

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

Cobalah online!

Arang , 42 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

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

Bangun nbilangan prima pertama dengan pembagian percobaan semua bilangan bulat dengan semua bilangan prima yang ditemukan sebelumnya.

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

Ulangi semua bilangan bulat sampai kami menemukan yang berisi semua bilangan prima sebagai substring.

Ｉη

Keluarkan hasilnya ke string dan cetak secara implisit.

Kecepatan program dapat dua kali lipat dengan biaya byte dengan mengganti terakhir ≦⊕ηdengan ≦⁺²ηtapi masih terlalu lambat untuk menghitung n>6.

Perl 6 , 63 59 byte

-4 byte terima kasih kepada nwellnhof

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

Cobalah online!

Solusi brute force yang keluar pada TIO untuk angka di atas 5, tapi saya cukup yakin itu berfungsi dengan benar. Menemukan angka positif pertama yang berisi nbilangan prima pertama . Inilah solusi yang tidak ada batas waktunya n=6.

Penjelasan:

{                                                             } # 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 byte

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)

Cobalah online!

f adalah fungsinya.

Python 2 , 91 byte

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

Cobalah online!

SAS, 149 byte

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; 

Input dimasukkan mengikuti cards;pernyataan, seperti:

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

Keluarkan dataset p, dengan hasilnya v, dengan baris output untuk setiap nilai input. Harus secara teknis bekerja untuk semua kasus uji yang diberikan (bilangan bulat maks dengan presisi penuh dalam SAS adalah 9.007.199.254.740.992), tetapi saya menyerah setelah membiarkannya berpikir selama 5 menit pada n = 8.

Penjelasan:

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 byte

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

Cobalah online!

Penjelasan / Tidak Diundang

Karena kita sudah Data.Listmengimpor kita mungkin juga menggunakannya: Daripada yang lama take n[p|p<-[2..],all((>0).mod p)[2..p-1]]kita bisa menggunakan cara lain untuk menghasilkan semua bilangan prima yang kita butuhkan. Yaitu, kami menghasilkan jumlah komposit yang cukup dan menggunakannya bersama-sama dengan (\\):

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

Menggunakan n*ncukup karena$\pi(n) < \frac{n^2}{\log(n^2)}$. Sisanya hanyalah pemahaman daftar sederhana:

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

Japt, 20 18 byte

Jauh dari pekerjaan terbaik saya, saya senang membuatnya bekerja setelah hari saya punya. Saya yakin saya akhirnya akan mengakhirinya di boozer nanti!

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

Cobalah - butuh 13 detik untuk menjalankan input 7, melempar dengan goyah setelah itu (versi yang diperbarui tidak berguna 5untuk saya, tetapi itu mungkin saja telepon saya).