Đây là trình tự A054261 .

Số ngăn chứa số nguyên tố thứ $n$ là số thấp nhất chứa số nguyên tố thứ $n$ đầu tiên làm chuỗi con. Ví dụ, số là số thấp nhất chứa 3 số nguyên tố đầu tiên làm chuỗi con, làm cho số thứ ba chứa số nguyên tố thứ ba.$235$

Thật là tầm thường khi chỉ ra rằng bốn số nguyên tố đầu tiên là , , và , nhưng sau đó nó trở nên thú vị hơn. Vì số nguyên tố tiếp theo là 11, số ngăn chứa số nguyên tố tiếp theo không phải là , nhưng nó là vì nó được định nghĩa là số nhỏ nhất với thuộc tính.$2$$23$$235$$2357$$235711$$112357$

Tuy nhiên, thử thách thực sự đến khi bạn vượt quá 11. Số ngăn chặn chính tiếp theo là . Lưu ý rằng trong số này, các chuỗi con và được chồng chéo. Số cũng trùng với số .$113257$1113313

Thật dễ dàng để chứng minh rằng chuỗi này đang tăng lên, vì số tiếp theo cần phải hoàn thành tất cả các tiêu chí của số trước nó và có thêm một chuỗi con. Tuy nhiên, trình tự không nghiêm ngặt tăng, như được hiển thị bởi các kết quả cho n=10và n=11.

Đầu vào

Một số nguyên duy nhất n>0(tôi cho rằng bạn cũng có thể có chỉ số 0, sau đó thực hiện n>=0)

Đầu ra

Hoặc là nsố thứ thủ ngăn chặn, hoặc một danh sách chứa các đầu nsố ngăn chặn thủ.

Những con số tôi đã tìm thấy cho đến nay là:

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

Lưu ý rằng n = 10và n = 11là cùng một số, vì là số thấp nhất chứa tất cả các số , nhưng nó cũng chứa .$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

Vì đây được đánh dấu mã golf, hãy chơi golf! Các giải pháp vũ lực được cho phép, nhưng mã của bạn phải hoạt động cho bất kỳ đầu vào nào trong lý thuyết (có nghĩa là bạn không thể nối các số nguyên tố đầu tiên). Chúc bạn chơi golf vui vẻ!

05AB1E , 8 byte

∞.ΔIÅpåP

Hãy thử trực tuyến!

Giải trình

           # 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

Thạch , 11 byte

³ÆN€ẇ€µẠ$1#

Hãy thử trực tuyến!

Lực lượng vũ phu đơn giản. Không hoàn toàn chắc chắn làm thế nào #arity hoạt động, vì vậy có thể có một số chỗ để cải thiện.

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến.
GHI CHÚ:

1. Lần ra ở trên n=7.
2. Cho đủ thời gian và tài nguyên, nó chỉ hoạt động tối đa n=9do giới hạn kích thước int(tối đa 2,147,483,647).
   • Với +4 byte thay đổi intthành along , mức tối đa được tăng lên thành đầu ra bên dưới 9,223,372,036,854,775,807( n=20tôi nghĩ sao?)
   • Bằng cách sử dụng java.math.BigIntegertối đa có thể được tăng lên đến bất kỳ kích thước nào (theo lý thuyết), nhưng ít nhất nó sẽ có khoảng +200 byte do tính dài dòng java.math.BigIntegercủa các phương thức ..

Giải trình:

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

Hãy thử trực tuyến!

Làm sao?

$n$

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

$n$

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

Đã bình luận

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}

Hãy thử trực tuyến!

Brute-force, hoạt động tới 7 trên TIO.

Bình thường , 14 byte

$n>5$

f@I`M.fP_ZQ1y`

Hãy thử trực tuyến!

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.

Bình thường , 15 byte

Nhanh hơn một chút nhưng dài hơn 1 byte.

f.A/L`T`M.fP_ZQ

Hãy thử trực tuyến!

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.

Thạch , 14 byte

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

Hãy thử trực tuyến!

Than , 42 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Xây dựng các nsố nguyên tố đầu tiên bằng cách chia thử nghiệm tất cả các số nguyên cho tất cả các số nguyên tố được tìm thấy trước đó.

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

Lặp lại tất cả các số nguyên cho đến khi chúng ta tìm thấy một số chứa tất cả các số nguyên tố dưới dạng chuỗi con.

Ｉη

Truyền kết quả thành chuỗi và in ngầm.

Tốc độ của chương trình có thể tăng gấp đôi với chi phí một byte bằng cách thay thế lần cuối ≦⊕ηbằng ≦⁺²ηnhưng vẫn còn quá chậm để tính toán n>6.

Perl 6 , 63 59 byte

-4 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Một giải pháp vũ lực vượt thời gian trên TIO cho các số trên 5, nhưng tôi khá chắc chắn rằng nó hoạt động chính xác. Tìm số dương đầu tiên có chứa các nsố nguyên tố đầu tiên . Đây là một giải pháp không hết thời gian n=6.

Giải trình:

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

Hãy thử trực tuyến!

f là chức năng.

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

Hãy thử trực tuyến!

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; 

Đầu vào được nhập theo cards;câu lệnh, như vậy:

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

Xuất ra một tập dữ liệu p, với kết quả v, với một hàng đầu ra cho mỗi giá trị đầu vào. Về mặt kỹ thuật nên hoạt động cho tất cả các trường hợp thử nghiệm đã cho (số nguyên tối đa với độ chính xác đầy đủ trong SAS là 9,007,199,254,740,992), nhưng tôi đã bỏ cuộc sau khi để nó suy nghĩ trong 5 phút trên n = 8.

Giải trình:

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

Hãy thử trực tuyến!

Giải thích / Ungolfed

Vì chúng tôi đã Data.Listnhập, chúng tôi cũng có thể sử dụng nó: Thay vì cũ, take n[p|p<-[2..],all((>0).mod p)[2..p-1]]chúng tôi có thể sử dụng một cách khác để tạo tất cả các số nguyên tố chúng tôi cần. Cụ thể, chúng tôi tạo ra một lượng vật liệu tổng hợp đủ và sử dụng chúng cùng với (\\):

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

Sử dụng n*nđủ vì$\pi(n) < \frac{n^2}{\log(n^2)}$. Phần còn lại chỉ là một sự hiểu biết danh sách đơn giản:

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

Japt, 20 18 byte

Khác xa với công việc tốt nhất của tôi, tôi rất vui khi nó hoạt động sau ngày tôi có. Tôi chắc chắn rằng tôi sẽ kết thúc với nó xuống boozer sau!

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

Hãy thử nó - mất 13 giây để chạy cho đầu vào 7, ném một cách chao đảo sau đó (phiên bản cập nhật 5phù hợp với tôi, nhưng đó có thể chỉ là điện thoại của tôi).