这是序列A054261。

第$n$个素数包含数是包含前素数作为子串的最小数。例如，数字是最低的数字，其中包含前3个素数作为子字符串，使其成为第3个素数包含数。$n$$235$

这是微不足道弄清楚前四个遏制素数是，，和，但随后变得更有趣。由于下一个素数是11，所以下一个素数包含数不是，而是因为它被定义为具有该属性的最小数。$2$$23$$235$$2357$$235711$$112357$

但是，当您超过11时，真正的挑战就来了。下一个主要收容编号为。请注意，在此数字中，子字符串和 是重叠的。该数字也与数字重叠。$113257$1113313

很容易证明此序列在增加，因为下一个数字需要满足该数字之前的所有条件，并且还要有一个子字符串。但是，该序列并不严格增加，如n=10和结果所示n=11。

输入项

一个整数n>0（我想您也可以将它的索引设为0，然后设为n>=0）

输出量

无论是n个素数遏制，或包含第一清单n素遏制号码。

到目前为止，我发现的数字是：

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

请注意，n = 10和n = 11是相同的数字，因为是包含所有数字的最低数字，但它也包含。$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

由于这是标记为高尔夫的代码，因此开始高尔夫吧！允许使用蛮力解，但是您的代码必须能够在理论上适用于任何输入（这意味着您不能仅将前n个素数连接在一起）。打高尔夫球快乐！

05AB1E，8个字节

∞.ΔIÅpåP

在线尝试！

说明

           # 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

果冻，11字节

³ÆN€ẇ€µẠ$1#

在线尝试！

简单的蛮力。#无法完全确定ar的工作原理，因此可能还有一些改进的空间。

怎么运行的

³Æ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字节

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

在线尝试。
笔记：

1. 超时以上n=7。
2. 如果有足够的时间和资源，它只能最多的n=9，由于尺寸限制int（最大的2,147,483,647）。
   • 随着+4个字节将更int改为along，最大值增加到下面的输出9,223,372,036,854,775,807（大约n=20我认为呢？）
   • 通过使用java.math.BigInteger最大值，可以将其增加到任何大小（理论上），但是至少由于java.math.BigInteger的方法的冗长，它将增加约200个字节。

说明：

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字节

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

在线尝试！

怎么样？

$n$

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

$n$

eval('for(;' + <conditions> + ';)++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(;" ]

红宝石，58字节

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

在线尝试！

暴力破解，在TIO上最多可以工作7次。

Pyth，14个字节

$n>5$

f@I`M.fP_ZQ1y`

在线尝试！

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个字节

速度稍快，但增加了1个字节。

f.A/L`T`M.fP_ZQ

在线尝试！

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.

果冻，14字节

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

在线尝试！

木炭，42字节

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

在线尝试！链接是详细版本的代码。说明：

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

建立第一个n由所有先前发现的素数的所有整数的审判庭素数。

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

遍历所有整数，直到找到一个包含所有素数作为子串的整数。

Ｉη

将结果转换为字符串并隐式打印。

通过用替换最后一个≦⊕η，程序的速度可以增加一倍，而只花费一个字节，≦⁺²η但是它仍然太慢而无法计算n>6。

Perl 6的，63 59个字节

-4字节归功于nwellnhof

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

在线尝试！

蛮力解决方案在TIO上对5以上的数字超时，但是我很确定它可以正常工作。查找包含第一个质n数的第一个正数。这是一个永不超时的解决方案n=6。

说明：

{                                                             } # 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字节

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)

在线尝试！

f 是功能。

Python 2，91字节

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

在线尝试！

SAS，149字节

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; 

在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

输出数据集p，结果v为，每个输入值都有一个输出行。从技术上讲应该可以在所有给定的测试用例中使用（SAS中具有全精度的最大整数是9,007,199,254,740,992），但是我让它在n = 8上思考了5分钟之后就放弃了。

说明：

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字节

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

在线尝试！

解释/取消包装

既然我们已经Data.List导入了，我们不妨使用它：除了很好的旧take n[p|p<-[2..],all((>0).mod p)[2..p-1]]用法，我们还可以使用另一种方式生成所需的所有素数。即，我们生成了足够数量的复合材料，并将它们与一起使用(\\)：

[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字节

远非我最出色的工作，我很乐意在一天过后让它工作。我确定以后我会在酒杯上敲打它！

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

尝试 -输入，需要13秒才能运行7，然后引发一阵颤抖（更新后的版本5对我不利，但这可能只是我的手机）。