Il compito attuale è, dato un numero n, trovare il primo più piccolo che inizia con ALMENO n del numero 2all'inizio del numero. Questa è una sequenza che ho trovato su OEIS ( A068103 ).

I primi 17 numeri nella sequenza sono indicati di seguito, se vuoi di più dovrò effettivamente implementare la sequenza, cosa che non mi dispiace fare.

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

Ho solo pensato che sarebbe stata una bella combinazione di manipolazione delle stringhe, rilevazione primaria e sequenze. Si tratta di code-golf , il conteggio di byte più basso verrà dichiarato il vincitore probabilmente alla fine del mese.

Brachylog , 12 11 byte

:2rj:Acb#p=

Provalo online!

Questo si traduce in Brachylog in modo sorprendentemente diretto. Questa è una funzione, non un programma completo (anche se dare l'interprete Zcome argomento della riga di comando fa sì che aggiunga il wrapper appropriato per rendere la funzione in un programma; questo è quello che ho fatto per far funzionare il collegamento TIO). È anche abbastanza sfortunato che jsembra essere indicizzato -1 e necessita di una correzione per consentirlo.

Puoi argomentare ragionevolmente che =non è necessario, ma penso che, dato il modo in cui il problema è formulato, lo sia; senza, la funzione sta descrivendo l'insieme di tutti i numeri primi che iniziano con il numero dato di 2s, e senza alcune dichiarazioni esplicite che il programma dovrebbe fare qualcosa con questa descrizione (in questo caso, generando il primo valore), probabilmente non lo fa rispettare le specifiche.

Spiegazione

: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 viene utilizzata come funzione che restituisce un numero intero, nulla richiede mai valori oltre il primo, quindi il primo è tutto ciò di cui dobbiamo preoccuparci.

Una sottigliezza (sottolineata nei commenti): :Acbe b:Acsono matematicamente equivalenti (come una rimuove dall'inizio e l'altra si aggiunge alla fine, con la regione in mezzo che non si sovrappone mai); In precedenza avevo b:Ac, il che è più naturale, ma si interrompe sull'input 0 (che suppongo sia perché si crifiuta di concatenare una lista vuota a qualsiasi cosa; molti builtin di Brachylog tendono a rompere su liste vuote per qualche motivo). :Acbassicura che cnon debba mai vedere un elenco vuoto, il che significa che ora può funzionare anche il caso dell'ingresso 0.

Java (OpenJDK 8) , 164 110 byte

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

Grazie a @FryAmTheEggman per un mucchio di byte!

Provalo online!

Pyth, 12 byte

f&!x`T*Q\2P_

In pseudocodice:

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

Avvia il ciclo lambdada T=1, incrementando di 1 fino a quando la condizione è soddisfatta. La stringa di 2s deve essere una sottostringa dall'inizio della stringa, ovvero il metodo di indice deve restituire 0. Se la sottostringa non viene trovata, ritorna -1che è convenientemente anche vero, quindi non esiste un caso eccezionale.

Puoi provarlo online qui , ma il server consente solo fino a un input di 4.

Perl, 50 byte

49 byte di codice + -pflag.

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

Fornire l'input senza newline finale. Per esempio:

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

Questa operazione richiede un po 'di tempo per eseguire un numero maggiore di 4 poiché verifica ogni numero (ci sono 2 test: il primo /^2{$_}/verifica se ce ne sono abbastanza 2 all'inizio, e il secondo (1x$\)!~/^1?$|^(11+)\1+$/verifica la primalità (con prestazioni molto scarse)).

Haskell, 73 byte

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

Esempio di utilizzo: f 3-> 2221.

Forza bruta. [1..n]>>"2"crea un elenco di n 2s che viene confrontato con i primi ncaratteri nella rappresentazione in stringa del primo corrente.

Mathematica, 103 byte

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

Funzione senza nome che accetta un argomento intero non negativo #e restituisce un numero intero. Mette alla prova letteralmente tutti gli interi positivi a turno fino a quando non ne trova uno che inizia con #2 secondi ed è primo. Orribilmente lento per input superiori a 5.

risultato precedente: Mathematica, 155 byte

Mathematica sarebbe meglio per giocare a golf se non fosse così fortemente tipizzato; dobbiamo passare esplicitamente avanti e indietro tra i tipi interi / list / 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&

Questo algoritmo funziona su elenchi di cifre , stranamente, a partire da {2,...,2,1}. Fintanto che quelle non sono le cifre di un numero primo, ne aggiunge una all'ultima cifra, usando la regola {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}... e quindi implementa manualmente portando il numero uno alla cifra successiva fintanto che uno qualsiasi dei le cifre equivalgono a 10, usando la regola {a__,b_,10,c___}->{a,b+1,0,c}... e poi, se siamo andati così lontano che l'ultima 2s principale si è trasformata in a 3, ricomincia da capo con un'altra cifra alla fine, usando la regola {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. Alla /. 23->2fine risolve solo il caso speciale in cui si trova l'input 1: la maggior parte dei numeri primi non può finire 2, ma 2può. (Alcuni errori vengono sputati sugli input 0e 1, ma la funzione trova la strada per la risposta giusta.)

Questo algoritmo è piuttosto veloce: per esempio, sul mio laptop ci vogliono meno di 3 secondi per calcolare che il primo numero primo a partire da 1.000 2s è 22...220521.

Pyth, 17 byte

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

Non riesco a risolvere n = 4online, ma in teoria è corretto.

Spiegazione

               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 byte

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

Provalo

Allargato:

{
  ( $/ = 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 byte

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

Molto inefficiente. Provalo online!

Pyke, 14 byte

.fj`Q\2*.^j_P&

Provalo qui!

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

12 byte dopo la correzione di bug e una nuova funzionalità

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

Provalo qui!

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

Sage, 69 68 byte

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

Utilizza un generatore per trovare il primo (quindi il più piccolo) di infiniti termini.

Japt, 20 byte

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

Provalo online! Termina entro due secondi sulla mia macchina per tutti gli input fino a 14, e successivamente perde naturalmente precisione (JavaScript ha una precisione intera fino a 2 ⁵³ ).

Mille grazie a @obarakon per aver lavorato su questo :-)

Spiegazione

                       // 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

Nell'ultima versione di Japt, questo può essere di 12 byte:

_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

Provalo online! Termina entro mezzo secondo sulla mia macchina per tutti gli ingressi fino a 14.

PHP, 76 byte

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

accetta input dall'argomento della riga di comando. Corri con -r.

abbattersi

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 byte

Funziona fino a 2 ^ 63-1 (9223372036854775807) , impiega molto tempo per terminare per N> 8.

golfed

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

Test

>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

Python 3, 406 byte

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

codice di prova

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

uscita di prova

 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

Ho deciso di andare per la velocità su un intervallo abbastanza ampio, piuttosto che la dimensione in byte. :) Uso un test deterministico sulla primalità di Miller-Rabin che è garantito fino a 3317044064679887385961981 con questo set di testimoni. I numeri primi più grandi superano sempre con successo il test, ma possono passare anche alcuni composti, sebbene la probabilità sia estremamente bassa. Tuttavia, ho anche testato i numeri di output per i> 22 utilizzando Pyecm e un programma di fattorizzazione con curva ellittica, e sembrano essere primi.

Python 3, 132 byte

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

Ogni speranza di prestazioni è stata sacrificata per un conteggio di byte più piccolo.

Java, 163 byte

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

codice di prova

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

produzione:

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 millisecondi

Spiegazione: passa in rassegna i numeri interi e li aggiunge come stringhe alla stringa radice, che è la stringa "2", e verifica se è primo o no.