시퀀스 A054261 입니다.

$n$ 프라임 수납 번호 제는 제 들어 낮은 번호 $n$ 문자열로서 소수를. 예를 들어 숫자 $235$ 는 하위 문자열로 처음 3 개의 소수를 포함하는 가장 낮은 숫자이며 이는 3 번째 소수를 포함합니다.

처음 네 개의 소수 격리 번호가 $2$ , $23$ , $235$ 및 $2357$ 이라는 것을 알아내는 것은 사소한 일이지만 더 흥미로워집니다. 다음 소수는 11이므로 다음 소수는 $235711$ 이 아니지만 속성이있는 가장 작은 숫자로 정의되므로 $112357$ 입니다.

그러나 진정한 도전은 11을 넘어 설 때 발생합니다. 다음 주요 격리 번호는 $113257$ 입니다. 이 숫자에서는 부분 문자열 11과 13겹칩니다. 숫자 3도 숫자 와 겹칩니다 13.

다음 숫자가 숫자의 모든 기준을 충족해야하고 하나 이상의 하위 문자열이 필요하므로이 순서가 증가하고 있음을 쉽게 증명할 수 있습니다. 그러나 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#

온라인으로 사용해보십시오!

단순한 무차별 대입. #Arity의 작동 방식을 완전히 모르므로 개선의 여지가있을 수 있습니다.

작동 원리

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

자바 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 바이트 intA와는long , 최대 값은 아래의 출력 증가 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

자바 스크립트 (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}

온라인으로 사용해보십시오!

Brute-force는 TIO에서 최대 7 개까지 작동합니다.

피스 , 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.

피스 , 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.

펄 6 , 63 59 바이트

nwellnhof 덕분에 -4 바이트

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

온라인으로 사용해보십시오!

5 이상의 숫자에 대해 TIO에서 시간 초과되는 무차별 대입 솔루션이지만 제대로 작동한다고 확신합니다. 첫 번째 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

파이썬 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 기능입니다.

파이썬 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

하스켈 , 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

apt, 20 18 바이트

내 최고의 작품과는 거리가 먼 날 하루를 보낸 후에 일하게되어 기뻤습니다. 나중에 부저 아래로 두드리게 될 것입니다!

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

시도해보십시오 -의 입력을 위해 13 초가 걸리고 7그 후에 흔들 리게됩니다 (업데이트 된 버전 5은 나를 위해 엉망 이지만 내 전화 일 수 있습니다).