Bu, A054261 dizisidir .

$n$ asal kapsama numarası inci ilk içermektedir düşük sayıdır $n$ alt dizeleri olarak asal sayılar. Örneğin, $235$ sayısı, ilk 3 astarı alt diziler olarak içeren en düşük sayıdır, bu da onu 3. asal içerme numarası yapar.

İlk dört ana çevreleme sayısının $2$ , $23$ , $235$ ve $2357$ olduğunu anlamak önemsizdir , ancak daha ilginç hale gelir. Bir sonraki asal sayı 11 olduğundan, bir sonraki asal $235711$ numarası 235711 değildir , ancak mülkiyeti olan en küçük sayı olarak tanımlandığı için $112357$ .

Bununla birlikte, asıl zorluk 11'in ötesine $113257$ . Bir sonraki birincil çevreleme numarası 113257'dir . Bu numarada, alt dizgilerin 11ve 13örtüştüğüne dikkat edin. Numara 3, numarayla da örtüşüyor 13.

Bir sonraki sayının kendisinden önceki sayının tüm kriterlerini yerine getirmesi ve bir tane daha alt dize alması gerektiğinden, bu sıranın arttığını kanıtlamak kolaydır. Bununla birlikte, dizi katı olarak sonuçları ile gösterilmiştir, artmamakta n=10ve n=11.

Giriş

Tek bir tamsayı n>0(Sanırım 0 dizine eklenmiş, daha sonra yapabilir n>=0)

Çıktı

Ya ninci asal çevreleme numarası veya birinci içeren bir liste nasal kapsama numaralarını.

Şu ana kadar bulduğum rakamlar:

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

Not bu n = 10ve n = 11çünkü aynı sayıda $113171923295$ tüm numaraları içerir düşük sayıdır $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$ , ama aynı zamanda içeren $31$ .

Bu kod golf olarak işaretlendiğinden, golf oynayın! Kaba kuvvet çözümlerine izin verilir, ancak kodunuz teoride herhangi bir girdi için çalışmak zorundadır (bu, yalnızca ilk n harfini birleştiremeyeceğiniz anlamına gelir). Mutlu golf!

05AB1E , 8 bayt

∞.ΔIÅpåP

Çevrimiçi deneyin!

açıklama

           # 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

Jöle , 11 bayt

³ÆN€ẇ€µẠ$1#

Çevrimiçi deneyin!

Basit kaba kuvvet. #Aritenin nasıl çalıştığından tam olarak emin değiliz, bu yüzden iyileştirme için bir yer olabilir.

Nasıl çalışır

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

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

Çevrimiçi deneyin.
NOTLAR:

1. Yukarıdaki zaman aşımına uğradı n=7.
2. Yeterli zaman ve kaynak göz önüne alındığında, yalnızca (maksimum ) n=9boyut sınırından dolayı maksimum değere çalışır . int2,147,483,647
   • İle değişen 4 bayt intbir etmeklong , maksimum altında bir çıkışa artar 9,223,372,036,854,775,807(yaklaşık n=20sanırım?)
   • java.math.BigIntegerMaksimum kullanılarak herhangi bir boyuta yükseltilebilir (teoride), ancak en azından java.math.BigIntegeryöntemlerinin ayrıntılarından dolayı +200 bayt civarında olacaktır .

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Nasıl?

$n$

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

$n$

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

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Brute-force, TIO'da 7'ye kadar çalışıyor.

Pyth , 14 bayt

$n>5$

f@I`M.fP_ZQ1y`

Çevrimiçi deneyin!

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 bayt

Biraz daha hızlı ancak 1 bayt daha uzun.

f.A/L`T`M.fP_ZQ

Çevrimiçi deneyin!

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.

Jöle , 14 bayt

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

Çevrimiçi deneyin!

Kömür , 42 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

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

İlk nasal sayıları, daha önce bulunan asal sayılar tarafından tüm tam sayıların deneme bölünmesi ile oluşturun.

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

Tüm asalları alt dizge içeren bir tane bulana kadar tüm tamsayılar arasında dolaşın.

Ｉη

Sonuç dizgeye yayınlanır ve örtük olarak yazdırılır.

Programın hızı son değiştirerek byte bir maliyetle katına edilebilir ≦⊕ηile ≦⁺²ηancak hesapla çok yavaş hala n>6.

Perl 6 , 63 59 bayt

Nwellnhof sayesinde -4 bayt

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

Çevrimiçi deneyin!

5'in üzerindeki sayılar için TIO'da zaman aşımına uğrayan kaba kuvvet çözümleri, ancak doğru çalıştığından eminim. İlk nastarları içeren ilk pozitif sayıyı bulur . İşte zaman aşımına uğramamış bir çözümn=6 .

Açıklama:

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

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)

Çevrimiçi deneyin!

f fonksiyondur.

Python 2 , 91 bayt

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

Çevrimiçi deneyin!

SAS, 149 bayt

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; 

Aşağıdaki cards;gibi ifadeden sonra giriş girilir :

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

pSonuçta v, her giriş değeri için bir çıkış satırına sahip bir veri kümesi çıkarır . Verilen tüm test durumları için teknik olarak çalışmalı (SAS'ta tam hassasiyetli maksimum tamsayı 9,007,199,254,740,992'dir), ancak n = 8'de 5 dakika düşünmesine izin verdikten sonra pes ettim.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Açıklama / Ungolfed

Zaten Data.Listithal ettiğimiz için onu da kullanabiliriz: İyi olanın yerine, take n[p|p<-[2..],all((>0).mod p)[2..p-1]]ihtiyacımız olan tüm primerleri oluşturmak için başka bir yol kullanabiliriz. Yani, yeterli miktarda kompozit üretiyoruz ve bunları birlikte kullanıyoruz (\\):

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

Kullanma n*nyeterli çünkü$\pi(n) < \frac{n^2}{\log(n^2)}$. Gerisi sadece basit bir liste anlamadır:

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

Japt, 20 18 bayt

En iyi işimden uzakta olduğum günden sonra çalışabildiğim için mutluydum. Eminim daha sonra içkiyi aşağı çekip bırakacağım!

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

Deneyin - bir giriş için çalıştırmak için 13 saniye sürer 7, bundan sonra titrek bir şekilde fırlatır (güncellenmiş sürüm 5benim için can atıyor , ancak bu benim telefonum olabilir).