Il s'agit de la séquence A054261 .

Le $n$ ème nombre de confinement premier est le plus petit nombre qui contient les $n$ premiers nombres premiers comme sous-chaînes. Par exemple, le nombre est le nombre le plus bas qui contient les 3 premiers nombres premiers comme sous-chaînes, ce qui en fait le 3ème nombre de confinement principal.$235$

Il est trivial de comprendre que les quatre premiers nombres premiers de confinement sont , , et , mais cela devient plus intéressant. Étant donné que le premier nombre premier est 11, le numéro de confinement premier suivant n'est pas , mais il est car il est défini comme le plus petit nombre avec la propriété.$2$$23$$235$$2357$$235711$$112357$

Cependant, le vrai défi vient quand vous allez au-delà de 11. Le prochain nombre de confinement principal est . Notez que dans ce nombre, les sous - chaînes et se chevauchent. Le nombre chevauche également le nombre .$113257$1113313

Il est facile de prouver que cette séquence est en augmentation, car le nombre suivant doit remplir tous les critères du nombre précédent et avoir une sous-chaîne de plus. Cependant, la séquence n'est pas strictement croissante, comme le montrent les résultats pour n=10et n=11.

Contribution

Un seul entier n>0(je suppose que vous pourriez aussi l'avoir indexé 0, puis faire n>=0)

Production

Soit le nnuméro de confinement principal, soit une liste contenant les npremiers numéros de confinement principaux.

Les chiffres que j'ai trouvés jusqu'à présent sont les suivants:

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

Notez que n = 10et n = 11sont le même nombre, puisque $113171923295$ est le nombre le plus bas qui contient tous les nombres $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$ , mais il contient également $31$ .

Puisqu'il s'agit du golf à code marqué, faites du golf! Les solutions de force brute sont autorisées, mais votre code doit fonctionner pour n'importe quelle entrée en théorie (ce qui signifie que vous ne pouvez pas simplement concaténer les n premiers nombres premiers). Bon golf!

05AB1E , 8 octets

∞.ΔIÅpåP

Essayez-le en ligne!

Explication

           # 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

Gelée , 11 octets

³ÆN€ẇ€µẠ$1#

Essayez-le en ligne!

Force brute simple. Je ne sais pas exactement comment fonctionne l #'arité, il peut donc y avoir une marge d' amélioration.

Comment ça marche

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

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

Essayez-le en ligne.
REMARQUES:

1. Délais ci-dessus n=7.
2. Avec suffisamment de temps et de ressources, il ne fonctionne que jusqu'à un maximum de en n=9raison de la taille limite de int(maximum de 2,147,483,647).
   • Avec +4 octets changeant le inten along , le maximum est augmenté à une sortie ci-dessous 9,223,372,036,854,775,807(environ n=20je pense?)
   • En utilisant java.math.BigIntegerle maximum peut être augmenté à n'importe quelle taille (en théorie), mais il sera d'environ +200 octets au moins en raison de la verbosité des java.math.BigIntegerméthodes de.

Explication:

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 octets

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

Essayez-le en ligne!

Comment?

Nous construisons récursivement une concaténation de conditions basée sur le premier $n$ premiers nombres premiers:

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

On cherche alors le plus petit $n$ tel que toutes les conditions soient fausses :

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

Commenté

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(;" ]

Rubis , 58 octets

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

Essayez-le en ligne!

Brute-force, fonctionne jusqu'à 7 sur TIO.

Pyth , 14 octets

Extrêmement, extrêmement lent, expire pour $n>5$ sur TIO.

f@I`M.fP_ZQ1y`

Essayez-le en ligne!

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 octets

Légèrement plus rapide mais 1 octet de plus.

f.A/L`T`M.fP_ZQ

Essayez-le en ligne!

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.

Gelée , 14 octets

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

Essayez-le en ligne!

Fusain , 42 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Construisez les npremiers nombres premiers par division d'essai de tous les entiers par tous les nombres premiers trouvés précédemment.

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

Parcourez tous les entiers jusqu'à ce que nous en trouvions un qui contienne tous les nombres premiers sous forme de sous-chaînes.

Ｉη

Convertissez le résultat en chaîne et imprimez implicitement.

La vitesse du programme peut être doublée au prix d'un octet en remplaçant le dernier ≦⊕ηpar ≦⁺²ηmais elle est encore trop lente à calculer n>6.

Perl 6 , 63 59 octets

-4 octets grâce à nwellnhof

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

Essayez-le en ligne!

Une solution de force brute qui expire sur TIO pour les nombres supérieurs à 5, mais je suis presque sûr que cela fonctionne correctement. Recherche le premier nombre positif qui contient les premiers nnombres premiers. Voici une solution qui n'expire pas n=6.

Explication:

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

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)

Essayez-le en ligne!

f est la fonction.

Python 2 , 91 octets

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

Essayez-le en ligne!

SAS, 149 octets

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; 

L'entrée est entrée après l' cards;instruction, comme ceci:

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

Génère un jeu de données p, avec le résultatv , avec une ligne de sortie pour chaque valeur d'entrée. Devrait techniquement fonctionner pour tous les cas de test donnés (l'entier max avec une précision totale dans SAS est 9,007,199,254,740,992), mais j'ai abandonné après l'avoir laissé réfléchir pendant 5 minutes sur n = 8.

Explication:

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 octets

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

Essayez-le en ligne!

Explication / Non golfé

Puisque nous avons déjà Data.Listimporté, nous pourrions aussi bien l'utiliser: au lieu du bon vieux, take n[p|p<-[2..],all((>0).mod p)[2..p-1]]nous pouvons utiliser une autre façon de générer tous les nombres premiers dont nous avons besoin. À savoir, nous générons une quantité suffisante de composites et les utilisons avec (\\):

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

Utiliser n*nsuffit car$\pi(n) < \frac{n^2}{\log(n^2)}$. Le reste n'est qu'une simple compréhension de liste:

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

Japt, 20 18 octets

Loin de mon meilleur travail, j'étais simplement heureux de le faire fonctionner après la journée que j'ai passée. Je suis sûr que je finirai par taper dans le boozer plus tard!

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

Essayez-le - il faut 13 secondes pour exécuter une entrée de 7, jette un tremblement après cela (la version mise à jour craque 5pour moi, mais cela pourrait bien être mon téléphone).