Esta es la secuencia A054261 .

El ésimo número de contención prime es el número más bajo que contiene los primeros números primos como subcadenas. Por ejemplo, el número es el número más bajo que contiene los primeros 3 primos como subcadenas, lo que lo convierte en el tercer número de contención de primos.$n$$n$$235$

Es trivial descubrir que los primeros cuatro números de contención primos son , , y , pero luego se vuelve más interesante. Como el próximo número primo es 11, el siguiente número de contención primo no es , pero es ya que se define como el número más pequeño con la propiedad.$2$$23$$235$$2357$$235711$$112357$

Sin embargo, el verdadero desafío llega cuando vas más allá de 11. El siguiente número de contención principal es . Tenga en cuenta que en este número, las subcadenas y se superponen. El número también se superpone con el número .$113257$1113313

Es fácil demostrar que esta secuencia está aumentando, ya que el siguiente número debe cumplir con todos los criterios del número anterior y tener una subcadena más. Sin embargo, la secuencia no está aumentando estrictamente, como lo demuestran los resultados para n=10y n=11.

Entrada

Un solo entero n>0(supongo que también podría tenerlo indexado en 0, luego haciendo n>=0)

Salida

O el nnúmero de contención primo th, o una lista que contiene los primeros nnúmeros de contención primos.

Los números que he encontrado hasta ahora son:

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

Tenga en cuenta que n = 10y n = 11son el mismo número, ya que es el número más bajo que contiene todos los números , pero también contiene .$113171923295$$[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$$31$

Dado que este es el código de golf marcado, ¡juegue al golf! Se permiten soluciones de fuerza bruta, pero su código tiene que funcionar para cualquier entrada en teoría (lo que significa que no puede concatenar los primeros n primos). ¡Feliz golf!

05AB1E , 8 bytes

∞.ΔIÅpåP

Pruébalo en línea!

Explicación

           # 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

Jalea , 11 bytes

³ÆN€ẇ€µẠ$1#

Pruébalo en línea!

Fuerza bruta simple. No estoy completamente seguro de cómo #funciona el arity, por lo que puede haber margen de mejora.

Cómo funciona

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

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

Pruébalo en línea.
NOTAS

1. Tiempos de espera arriba n=7.
2. Dado el tiempo y los recursos suficientes, solo funciona hasta un máximo n=9debido al límite de tamaño de int(máximo de 2,147,483,647).
   • Con +4 bytes cambiando el inta along , el máximo se incrementa a una salida por debajo 9,223,372,036,854,775,807(¿sobre n=20qué creo?)
   • Al usar java.math.BigIntegerel máximo se puede aumentar a cualquier tamaño (en teoría), pero será de alrededor de +200 bytes al menos debido a la verbosidad de java.math.BigIntegerlos métodos.

Explicación:

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 bytes

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

Pruébalo en línea!

¿Cómo?

$n$

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

$n$

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

Comentado

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 bytes

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

Pruébalo en línea!

Fuerza bruta, funciona hasta 7 en TIO.

Pyth , 14 bytes

$n>5$

f@I`M.fP_ZQ1y`

Pruébalo en línea!

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 bytes

Ligeramente más rápido pero 1 byte más largo.

f.A/L`T`M.fP_ZQ

Pruébalo en línea!

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.

Jalea , 14 bytes

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

Pruébalo en línea!

Carbón , 42 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Construya los primeros nnúmeros primos por división de prueba de todos los enteros por todos los números primos encontrados previamente.

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

Recorre todos los enteros hasta encontrar uno que contenga todos los números primos como subcadenas.

Ｉη

Transmita el resultado a una cadena e imprima implícitamente.

La velocidad del programa se puede duplicar a un costo de un byte reemplazando el último ≦⊕ηcon, ≦⁺²ηpero aún es demasiado lento para calcular n>6.

Perl 6 , 63 59 bytes

-4 bytes gracias a nwellnhof

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

Pruébalo en línea!

Una solución de fuerza bruta que agota el tiempo en TIO para números superiores a 5, pero estoy bastante seguro de que funciona correctamente. Encuentra el primer número positivo que contiene los primeros nnúmeros primos. Aquí hay una solución que no se agota n=6.

Explicación:

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

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)

Pruébalo en línea!

f Es la función.

Python 2 , 91 bytes

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

Pruébalo en línea!

SAS, 149 bytes

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; 

La entrada se ingresa después de la cards;declaración, así:

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

Da salida a un conjunto de datos p , con el resultado v, con una fila de salida para cada valor de entrada. Técnicamente debería funcionar para todos los casos de prueba dados (el número entero máximo con precisión total en SAS es 9,007,199,254,740,992), pero me di por vencido después de dejarlo pensar durante 5 minutos en n = 8.

Explicación:

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 bytes

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

Pruébalo en línea!

Explicación / Ungolfed

Como ya hemos Data.Listimportado, también podríamos usarlo: en lugar de lo viejo take n[p|p<-[2..],all((>0).mod p)[2..p-1]], podemos usar otra forma de generar todos los números primos que necesitamos. Es decir, generamos una cantidad suficiente de compuestos y los utilizamos junto con (\\):

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

Usar n*nbasta porque$\pi(n) < \frac{n^2}{\log(n^2)}$. El resto es solo una simple lista de comprensión:

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

Japt, 20 18 bytes

Lejos de mi mejor trabajo, estaba feliz de hacerlo funcionar después del día que tuve. ¡Estoy seguro de que terminaré golpeándolo en el alcohol más tarde!

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

Pruébelo : tarda 13 segundos en ejecutarse para una entrada de 7, arroja un tambaleante después de eso (la versión actualizada es una mierda 5para mí, pero ese podría ser mi teléfono).