Esta é a sequência A054261 .

O $n$ th número de contenção principal é o número mais baixo, que contém o primeiro$n$ primos números como subsequências. Por exemplo, o númeroé o número mais baixo que contém os 3 primeiros números primos como substrings, tornando-o o terceiro número de contenção principal.$235$

É trivial descobrir que os quatro primeiros números de contenção primos são , , e$2$$23$$235$$2357$235711 112357 , mas depois fica mais interessante. Como o próximo primo é 11, o próximo número de contenção do primo não é , mas é pois é definido como o menor número com a propriedade.$235711$$112357$

No entanto, o verdadeiro desafio surge quando você ultrapassa 11. O próximo número de contenção principal é . Observe que neste número, as substrings e estão sobrepostas. O número também se sobrepõe ao número .$113257$1113313

É fácil provar que essa sequência está aumentando, já que o próximo número precisa atender a todos os critérios do número anterior e ter mais uma substring. No entanto, a sequência não está aumentando estritamente, como é mostrado pelos resultados para n=10e n=11.

Entrada

Um único número inteiro n>0(suponho que você também possa indexá-lo em 0 e depois criar n>=0)

Saída

O nth número de contenção primária ou uma lista que contém os primeiros nnúmeros de contenção primária.

Os números que encontrei até agora são:

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

Observe que n = 10e n = 11são o mesmo número, pois $113171923295$ é o número mais baixo que contém todos os números $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$ , mas também contém $31$ .

Como esse código é marcado como golfe, comece a jogar golfe! Soluções de força bruta são permitidas, mas seu código precisa funcionar para qualquer entrada na teoria (o que significa que você não pode simplesmente concatenar os primeiros n primos). Feliz golfe!

05AB1E , 8 bytes

∞.ΔIÅpåP

Experimente online!

Explicação

           # 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

Gelatina , 11 bytes

³ÆN€ẇ€µẠ$1#

Experimente online!

Força bruta simples. Não totalmente certo de como #a aridade funciona, então pode haver algum espaço para melhorias.

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

Experimente online.
NOTAS:

1. Tempos acima n=7.
2. Com tempo e recursos suficientes, ele só funciona no máximo n=9devido ao limite de tamanho de int(máximo de 2,147,483,647).
   • Com +4 bytes mudando intpara along , o máximo é aumentado para uma saída abaixo 9,223,372,036,854,775,807(sobre n=20eu acho?)
   • O uso java.math.BigIntegerdo máximo pode ser aumentado para qualquer tamanho (em teoria), mas será em torno de 200 bytes, pelo menos devido à verbosidade dos java.math.BigIntegermétodos.

Explicação:

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

Experimente online!

Quão?

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

Experimente online!

Força bruta, trabalha até 7 no TIO.

Pitão , 14 bytes

$n>5$

f@I`M.fP_ZQ1y`

Experimente online!

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.

Pitão , 15 bytes

Um pouco mais rápido, mas com um byte a mais.

f.A/L`T`M.fP_ZQ

Experimente online!

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.

Gelatina , 14 bytes

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

Experimente online!

Carvão , 42 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Construa os primeiros nnúmeros primos pela divisão de teste de todos os números inteiros por todos os números primos encontrados anteriormente.

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

Faça um loop por todos os números inteiros até encontrarmos um que contenha todos os números primos como substrings.

Ｉη

Transmitir o resultado para string e imprimir implicitamente.

A velocidade do programa pode ser dobrada ao custo de um byte, substituindo o último ≦⊕ηpor ≦⁺²ηmas ainda é muito lento para calcular n>6.

Perl 6 , 63 59 bytes

-4 bytes graças a nwellnhof

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

Experimente online!

Soluções de força bruta que excedem o tempo limite de TIO para números acima de 5, mas tenho certeza de que funciona corretamente. Localiza o primeiro número positivo que contém os primeiros nnúmeros primos. Aqui está uma solução que não atinge o tempo limiten=6 .

Explicação:

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

Experimente online!

f é a função

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

Experimente online!

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; 

A entrada é inserida após a cards;instrução, da seguinte forma:

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

Produz um conjunto de dados p, com o resultado v, com uma linha de saída para cada valor de entrada. Tecnicamente, deve funcionar para todos os casos de teste fornecidos (o número máximo máximo com precisão total no SAS é 9.007.199.254.740.992), mas desisti depois de deixá-lo pensar por 5 minutos em n = 8.

Explicação:

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

Experimente online!

Explicação / Ungolfed

Como já Data.Listimportamos, podemos usá-lo: em vez do bom e velho take n[p|p<-[2..],all((>0).mod p)[2..p-1]], podemos usar outra maneira de gerar todos os números primos de que precisamos. Ou seja, geramos uma quantidade suficiente de compostos e os usamos juntamente com (\\):

[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

Japonês, 20 18 bytes

Longe do meu melhor trabalho, fiquei feliz em fazê-lo funcionar depois do dia que tive. Tenho certeza de que acabarei batendo nele mais tarde na boozer!

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

Experimente - leva 13 segundos para executar uma entrada de 7, lança um vacilante depois disso (a versão atualizada é louca 5para mim, mas esse pode ser apenas o meu telefone).