A tarefa em questão é, dado um número n, encontrar o menor primo que começa com PELO MENOS n do número 2no início do número. Esta é uma sequência que encontrei no OEIS ( A068103 ).

Os primeiros 17 números da sequência são dados abaixo; se você quiser mais, terei de implementar a sequência, o que não me importo de fazer.

0  = 2
1  = 2
2  = 223
3  = 2221
4  = 22229
5  = 2222203
6  = 22222223                # Notice how 6 and 7 are the same! 
7  = 22222223                # It must be **AT LEAST** 6, but no more than necessary.
8  = 222222227
9  = 22222222223             # Notice how 9 and 10 are the same!
10 = 22222222223             # It must be **AT LEAST** 9, but no more than necessary.
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221

Só pensei que isso seria uma combinação legal de manipulação de cordas, detecção de primos e seqüências. Isso é código-golfe , a menor contagem de bytes será declarada a vencedora provavelmente no final do mês.

Braquilog , 12 11 bytes

:2rj:Acb#p=

Experimente online!

Isso se traduz em Brachylog surpreendentemente diretamente. Essa é uma função, não um programa completo (embora fornecer o intérprete Zcomo argumento da linha de comando faça com que ele adicione o wrapper apropriado para transformar a função em um programa; foi isso que eu fiz para que o link TIO funcionasse). Também é bastante lamentável que jpareça estar indexado a -1 e precise de uma correção para permitir isso.

Você pode argumentar razoavelmente que isso =não é necessário, mas acho que, dada a maneira como o problema está redigido, é; sem, a função está descrevendo o conjunto de todos os números primos que começam com o número especificado de 2s, e sem alguma declaração explícita de que o programa deve fazer algo com essa descrição (nesse caso, gerando o primeiro valor), provavelmente não cumprir com as especificações.

Explicação

:2rjbAcb#p=
:2rj         2 repeated a number of times equal to the input plus one
    :Ac      with something appended to it
       b     minus the first element
        #p   is prime;
          =  figure out what the resulting values are and return them

Quando usado como uma função que retorna um número inteiro, nada solicita valores além do primeiro, portanto, o primeiro é tudo o que nos preocupa.

Uma sutileza (apontada nos comentários): :Acbe b:Acsão matematicamente equivalentes (à medida que uma é removida do início e a outra é adicionada ao final, com a região entre nunca se sobrepondo); Eu tinha anteriormente b:Ac, o que é mais natural, mas ele quebra na entrada 0 (o que eu acho que é porque cse recusa a concatenar uma lista vazia para qualquer coisa; muitos builds do Brachylog tendem a quebrar em listas vazias por algum motivo). :Acbgarante que cnunca precise ver uma lista vazia, o que significa que o caso da entrada 0 também pode funcionar agora.

Java (OpenJDK 8) , 164 110 bytes

a->{int i=0;for(;!(i+"").matches("2{"+a+"}.*")|new String(new char[i]).matches(".?|(..+)\\1+");i++);return i;}

Obrigado a @FryAmTheEggman por um monte de bytes!

Experimente online!

Pitão, 12 bytes

f&!x`T*Q\2P_

No pseudocódigo:

f                key_of_first_truthy_value( lambda T:
  !                  not (
   x`T*Q\2               repr(T).index(input()*'2')
                     )
 &                   and
          P_T        is_prime(T)
                 )

Faz um loop na lambdapartida T=1, aumentando em 1 até que a condição seja satisfeita. A sequência de 2s deve ser uma substring desde o início da sequência, ou seja, o método index precisa retornar 0. Se a substring não for encontrada, ela retornará, o -1que também é realmente conveniente, portanto, não existe um caso excepcional.

Você pode experimentá-lo online aqui , mas o servidor permite apenas uma entrada de 4.

Perl, 50 bytes

49 bytes de código + -psinalizador.

++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{

Forneça a entrada sem nova linha final. Por exemplo:

echo -n 4 | perl -pE '++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{'

Demora um pouco para executar números maiores que 4, pois ele testa todos os números (há 2 testes: o primeiro /^2{$_}/verifica se há 2 suficientes no início e o segundo (1x$\)!~/^1?$|^(11+)\1+$/testa primalidade (com desempenhos muito ruins)).

Haskell, 73 bytes

f n=[x|x<-[2..],all((>0).mod x)[3..x-1],take n(show x)==([1..n]>>"2")]!!0

Exemplo de uso: f 3-> 2221.

Força bruta. [1..n]>>"2"cria uma lista de n 2s que é comparada com os primeiros ncaracteres na representação de sequência do primo atual.

Mathematica, 103 bytes

ReplaceRepeated[0,i_/;!IntegerDigits@i~MatchQ~{2~Repeated~{#},___}||!PrimeQ@i:>i+1,MaxIterations->∞]&

Função sem nome, usando um argumento inteiro não negativo #e retornando um número inteiro. Ele literalmente testa todos os números inteiros positivos, por sua vez, até encontrar um que comece com #2s e seja primo. Horrivelmente lento para entradas acima de 5.

resultado anterior: Mathematica, 155 bytes

O Mathematica seria melhor para jogar golfe se não fosse tão fortemente digitado; precisamos alternar explicitamente entre os tipos inteiro / lista / string.

(d=FromDigits)[2&~Array~#~Join~{1}//.{j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}//.{a__,b_,10,c___}->{a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b})]/. 23->2&

Estranhamente, esse algoritmo opera em listas de dígitos , começando com {2,...,2,1}. Contanto que esses não sejam os dígitos de um número primo, ele adiciona um ao último dígito, usando a regra {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}... e, em seguida, implementa manualmente o carregamento do um para o próximo dígito, desde que qualquer um dos dígitos iguais a 10, usando a regra {a__,b_,10,c___}->{a,b+1,0,c}... e, se formos tão longe que o último dos 2s principais se transformou em a 3, começa novamente com outro dígito no final, usando a regra {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. O /. 23->2no final apenas corrige o caso especial em que a entrada está 1: a maioria dos primos não pode terminar 2, mas 2pode. (Alguns erros são cuspidos nas entradas 0e 1, mas a função encontra o caminho para a resposta certa.)

Esse algoritmo é bastante rápido: por exemplo, no meu laptop, são necessários menos de 3 segundos para calcular que o primeiro primeiro a começar com 1.000 2s é 22...220521.

Pitão, 17 bytes

f&q\2{<`T|Q1}TPTh

Não consigo resolver n = 4online, mas é correto em teoria.

Explicação

               Th    Starting from (input)+1, 
f                    find the first T so that
      <              the first
          Q          (input) characters
         | 1         or 1 character, if (input) == 0
       `T            of T's string representation
     {               with duplicates removed
  q\2                equal "2", 
 &                   and
            }T       T is found in
              PT     the list of T's prime factors.

Perl 6 , 53 bytes

{($/=2 x$^n-1)~first {+($/~$_) .is-prime&&/^2/},0..*}

Tente

Expandido:

{
  ( $/ = 2 x $^n-1 )       # add n-1 '2's to the front (cache in ｢$/｣)
  ~
  first {
    +( $/ ~ $_ ) .is-prime # find the first that when combined with ｢$/｣ is prime
    &&
    /^2/                   # that starts with a 2 (the rest are in ｢$/｣)
  },
  0..*
}

Gelatina , 14 bytes

D=2×\S:³aÆPµ1#

Muito ineficiente. Experimente online!

Pyke, 14 bytes

.fj`Q\2*.^j_P&

Experimente aqui!

.fj            - first number (asj)
   `    .^     -   str(i).startswith(V)
    Q\2*       -    input*"2"
             & -  ^ & V
          j_P  -   is_prime(j)

12 bytes após correção de bug e um novo recurso

~p#`Q\2*.^)h

Experimente aqui!

~p           - all the primes
  #       )h - get the first where...
   `    .^   - str(i).startswith(V)
    Q\2*     -  input*"2"

Sábio, 69 68 bytes

lambda n:(x for x in Primes()if '2'*len(`x`)=>'2'*n==`x`[:n]).next()

Usa um gerador para encontrar o primeiro (portanto o menor) de infinitos termos.

Japonês, 20 bytes

L²o@'2pU +Xs s1)nÃæj

Teste online! Ele termina em dois segundos na minha máquina para todas as entradas de até 14 e, depois disso, perde naturalmente a precisão (o JavaScript só tem precisão de número inteiro até 2 ⁵³ ).

Muito obrigado a @obarakon por trabalhar nisso :-)

Explicação

                       // Implicit: U = input integer, L = 100
L²o                    // Generate the range [0...100²).
   @             Ã     // Map each item X through the following function:
    '2pU               //   Take a string of U "2"s.
         +Xs s1)n      //   Append all but the first digit of X, and cast to a number.
                       // If U = 3, we now have the list [222, 222, ..., 2220, 2221, ..., 222999].
                  æ    // Take the first item that returns a truthy value when:
                   j   //   it is checked for primality.
                       // This returns the first prime in the forementioned list.
                       // Implicit: output result of last expression

Na versão mais recente do Japt, isso pode ter 12 bytes:

_n j}b!+'2pU   // Implicit: U = input integer
_   }b         // Return the first non-negative bijective base-10 integer that returns
               // a truthy value when run through this function, but first,
      !+       //   prepend to each integer
        '2pU   //   a string of U '2's.
               // Now back to the filter function:
 n j           //   Cast to a number and check for primality.
               // Implicit: output result of last expression

Teste online! Ele termina em meio segundo na minha máquina para todas as entradas de até 14.

PHP, 76 bytes

for($h=str_pad(2,$i=$argv[1],2);$i>1;)for($i=$p=$h.++$n;$p%--$i;);echo$p?:2;

recebe entrada do argumento da linha de comando. Corra com -r.

demolir

for($h=str_pad(2,$i=$argv[1],2) # init $h to required head
    ;$i>1;                      # start loop if $p>2; continue while $p is not prime
)
    for($i=$p=$h.++$n               # 1. $p = next number starting with $h
                                    #    (first iteration: $p is even and >2 => no prime)
    ;$p%--$i;);                     # 2. loop until $i<$p and $p%$i==0 ($i=1 for primes)
echo$p?:2;                      # print result; `2` if $p is unset (= loop not started)

Bash (+ coreutils), 53 bytes

Trabalhos com até 2 ^ 63-1 (9223372036854775807) , leva um tempo considerável para terminar com N> 8.

Golfe

seq $[2**63-1]|factor|grep -Pom1 "^2{$1}.*(?=: \S*$)"

Teste

>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

Python 3, 406 bytes

w=2,3,5,7,11,13,17,19,23,29,31,37,41
def p(n):
 for q in w:
  if n%q<1:return n==q
  if q*q>n:return 1
 m=n-1;s,d=-1,m
 while d%2==0:s,d=s+1,d//2
 for a in w:
  x=pow(a,d,n)
  if x in(1,m):continue
  for _ in range(s):
   x=x*x%n
   if x==1:return 0
   if x==m:break
  else:return 0
 return 1
def f(i):
 if i<2:return 2
 k=1
 while k:
  k*=10;l=int('2'*i)*k
  for n in range(l+1,l+k,2):
   if p(n):return n

código de teste

for i in range(31):
    print('{:2} = {}'.format(i, f(i)))

saída de teste

 0 = 2
 1 = 2
 2 = 223
 3 = 2221
 4 = 22229
 5 = 2222203
 6 = 22222223
 7 = 22222223
 8 = 222222227
 9 = 22222222223
10 = 22222222223
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221
17 = 222222222222222221
18 = 22222222222222222253
19 = 222222222222222222277
20 = 2222222222222222222239
21 = 22222222222222222222201
22 = 222222222222222222222283
23 = 2222222222222222222222237
24 = 22222222222222222222222219
25 = 222222222222222222222222239
26 = 2222222222222222222222222209
27 = 2222222222222222222222222227
28 = 222222222222222222222222222269
29 = 2222222222222222222222222222201
30 = 222222222222222222222222222222053

Decidi usar a velocidade em uma faixa bastante grande, em vez do tamanho de bytes. :) Uso um teste determinista de primalidade de Miller-Rabin, que é garantido até 3317044064679887385961981 com este conjunto de testemunhas. Prizes maiores sempre passarão com êxito no teste, mas alguns compostos também podem passar, embora a probabilidade seja extremamente baixa. No entanto, também testei os números de saída para i> 22 usando pyecm, um programa de fatoração de curva elíptica, e eles parecem ser primos.

Python 3, 132 bytes

def f(x):
 k=10;p=2*(k**x//9)
 while x>1:
  for n in range(p*k,p*k+k):
   if all(n%q for q in range(2,n)):return n
  k*=10
 return 2

Qualquer esperança de desempenho foi sacrificada por uma contagem menor de bytes.

Java, 163 bytes

BigInteger f(int a){for(int x=1;x>0;x+=2){BigInteger b=new BigInteger(new String(new char[a]).replace("\0","2")+x);if(b.isProbablePrime(99))return b;}return null;}

código de teste

    public static void main(String[] args) {
    for(int i = 2; i < 65; i++)
        System.out.println(i + " " + new Test20170105().f(i));
    }

saída:

2 223
3 2221
4 22229
5 2222219
6 22222223
7 22222223
8 222222227
9 22222222223
10 22222222223
11 2222222222243
12 22222222222229
13 22222222222229
14 222222222222227
15 222222222222222143
16 222222222222222221
17 222222222222222221
18 22222222222222222253
19 222222222222222222277
20 2222222222222222222239
21 22222222222222222222261
22 222222222222222222222283
23 2222222222222222222222237
24 22222222222222222222222219
25 222222222222222222222222239
26 2222222222222222222222222213
27 2222222222222222222222222227
28 222222222222222222222222222269
29 22222222222222222222222222222133
30 222222222222222222222222222222113
31 222222222222222222222222222222257
32 2222222222222222222222222222222243
33 22222222222222222222222222222222261
34 222222222222222222222222222222222223
35 222222222222222222222222222222222223
36 22222222222222222222222222222222222273
37 222222222222222222222222222222222222241
38 2222222222222222222222222222222222222287
39 22222222222222222222222222222222222222271
40 2222222222222222222222222222222222222222357
41 22222222222222222222222222222222222222222339
42 222222222222222222222222222222222222222222109
43 222222222222222222222222222222222222222222281
44 2222222222222222222222222222222222222222222297
45 22222222222222222222222222222222222222222222273
46 222222222222222222222222222222222222222222222253
47 2222222222222222222222222222222222222222222222219
48 22222222222222222222222222222222222222222222222219
49 2222222222222222222222222222222222222222222222222113
50 2222222222222222222222222222222222222222222222222279
51 22222222222222222222222222222222222222222222222222289
52 2222222222222222222222222222222222222222222222222222449
53 22222222222222222222222222222222222222222222222222222169
54 222222222222222222222222222222222222222222222222222222251
55 222222222222222222222222222222222222222222222222222222251
56 2222222222222222222222222222222222222222222222222222222213
57 222222222222222222222222222222222222222222222222222222222449
58 2222222222222222222222222222222222222222222222222222222222137
59 22222222222222222222222222222222222222222222222222222222222373
60 222222222222222222222222222222222222222222222222222222222222563
61 2222222222222222222222222222222222222222222222222222222222222129
62 2222222222222222222222222222222222222222222222222222222222222227
63 2222222222222222222222222222222222222222222222222222222222222227
64 2222222222222222222222222222222222222222222222222222222222222222203

582,5858 milissegundos

Explicação: faz um loop sobre números inteiros e os adiciona como strings à string raiz, que é a string "2's" fornecida, e verifica se é prime ou não.