Un numero primo troncabile a destra è un numero primo in cui ogni prefisso è un numero primo (nella base 10). Un numero primo troncabile a sinistra è esattamente l'opposto, dove ogni postfisso è un numero primo (i numeri primi che iniziano con 0 non sono ammessi). Entrambe queste sequenze sono finite (ci sono solo 83 tronchi a destra, mentre ci sono 4260 tronchi a sinistra).

È necessario scrivere un programma che accetta un singolo numero come input, e produce il n ° privilegiata-truncatable. Tuttavia, quando il programma viene letta a ritroso disposti , dovrebbe produrre il n ° a sinistra-truncatable prime.

Per organizzare un programma al contrario, suddividiamo il programma in parole, quindi invertiamo l'ordine delle parole. Una parola può essere composta da un numero qualsiasi di caratteri.

Ad esempio, se il programma era il seguente:

hello world
1234567890

Sarebbero tutti consentiti come possibili arretrati:

Dividi su ogni personaggio:

0987654321
dlrow olleh

Suddivisione su spazi bianchi:

1234567890
world hello

Suddivisione arbitraria (tubi aggiunti per maggiore chiarezza):

hel|lo w|orld
1|23456|7|8|90

908723456orld
1lo whel

Quando organizzi il tuo programma al contrario, tutti gli spazi bianchi devono essere considerati e invertiti, proprio come qualsiasi altro personaggio.

Ingressi test in avanti:

1:  2
2:  3
21: 379
60: 239933
83: 73939133

Ingressi test all'indietro:

1:    2
2:    3
39:   647
187:  29173
4260: 357686312646216567629137

I programmi dovrebbero essere in grado di funzionare in un ragionevole lasso di tempo (meno di un minuto)

Questo è un codice-golf , quindi vince il programma con il minor numero di byte!

Gelatina , 26 23 byte

Inoltrare

Ѷp9¶7ÆR2ĿV€$ÆPÐf$ÐĿFị@

Provalo online!

Parole

Ñ ¶ p 9 ¶ 7ÆR2ĿV€$ÆPÐf$ÐĿFị@

a rovescio

7ÆR2ĿV€$ÆPÐf$ÐĿFị@¶9p¶Ñ

Provalo online!

Parole

7ÆR2ĿV€$ÆPÐf$ÐĿFị@ ¶ 9 p ¶ Ñ

Come funziona

Tutti i programmi Jelly sono costituiti da collegamenti (funzioni di assunzione di Jelly), che sono separati da avanzamenti di riga o pilcrows ( ¶). L'ultimo è il collegamento principale ; viene chiamato automaticamente quando viene eseguito il programma.

Il programma forward funziona come segue.

Ñ                   Helper link. Unused.


p9                  Helper link. Take the Cartesian product with [1, ..., 9].


7ÆR2ĿV€$ÆPÐf$ÐĿFị@  Main link. Argument: n

7ÆR                 Yield all primes up to 7.
             ÐĿ     
            $ÐĿ     Combine the two quicklinks to the left into a monadic chain,
                    and call it repeatedly until the results are no longer unique.
                    Return the array of all intermediate results.
       $              Combine the two links to the left into a monadic chain.
   2Ŀ               Call the helper link on line 2.
     Ṿ€                 Eval each array in the product. This casts to string
                        before evaluating, thus concatenating both numbers.
        ÆPÐf        Filter by primality; keep only primes.
               F    Flatten the resulting array.
                ị@  Retrieve the element at index n.

Il programma all'indietro fa quasi esattamente lo stesso; ci sono solo due differenze.

• Il link principale è ora Ñ, che chiama semplicemente il link sottostante (avvolgendolo), ovvero il link principale del programma forward.

• 9pinvece di p9restituire il prodotto cartesiano invertito.

Python 2, 143 139 byte

I=1
a={2}
def f(s):
 for d in'123456789':u=d[I:]+s+d*I;z=int(u);z+=z<3;z%91>0<2==pow(2,z,z)>a.add(z)<f(u)
f('')
lambda n:sorted(a)[~-n]
I=0

È composto da cinque parti:

1. I=1
2. Una nuova riga
3. a={2}…[~-n]
4. Una nuova riga
5. I=0

Quindi l'inversione sta semplicemente cambiando il valore di I.

Spiegazione

La funzione fesegue una ricerca ricorsiva per numeri primi troncabili a sinistra (LTP) o numeri primi troncabili a destra (RTP), a seconda del valore del globale I. Questi valori vengono aggiunti al set a. Quindi, lambda n:sorted(a)[~-n]restituisce il n-th one.

Definiamo una foglia come un LTP, un RTP, una cifra diversa da zero + un LTP o un RTP + una cifra diversa da zero. Questi sono tutti i valori che fpotrebbero mai voler verificare la primalità.

Ho progettato un test pseudoprime Fermat che funziona con tutte le foglie:

(63973 è un numero di Carmichael .)

Se questo test ritorna vero, allora zdovrebbe essere aggiunto al set ae dovremmo ricorrere str(z). Il bit responsabile del codice è:

z+=z<3;z%91>0<2==pow(2,z,z)>a.add(z)<f(u)

Innanzitutto, desideriamo affrontare il caso z == 2. Lo facciamo semplicemente schivandolo qui e hard-coding 2quando inizialmente definiamo a! (EDIT: E non succede nulla di dannoso se prendiamo anche noi z == 1.) Quindi possiamo supporre che z ≥ 3ora.

Ho tradotto alcuni "e" s in un confronto concatenato da cortocircuito: i primi tre confronti devono avere successo prima a.add(z)e f(u)vengono mai valutati. Ecco tutti i loro ruoli:

1. z%91>0codifica la nostra prima condizione. (63973 è divisibile per 91, che non è una foglia stessa, quindi è così che la riconosciamo.)
2. 0<2è sempre vero, ma il concatenamento è più corto di and.
3. 2==pow(2,z,z) codifica la nostra seconda condizione.
4. pow(2,z,z)>a.add(z)attiva l'aggiunta ed è sempre vero, poiché i set.addrendimenti Nonee gli interi sono sempre maggiori di None.
5. a.add(z)<f(u)innesca la ricorsione. Il suo valore di verità non è importante.

Ringraziamenti

• Dennis ha salvato quattro byte ( u=[d+s,s+d][I]→ u=d[I:]+s+d*I; z==2→ z<3e il trucco mod 91 ). Grazie!