Un nombre premier tronçable à droite est un nombre premier où chaque préfixe est un nombre premier (en base 10). Un nombre premier tronçable à gauche est exactement le contraire, où chaque suffixe est un nombre premier (les nombres premiers commençant par 0 ne sont pas autorisés). Ces deux séquences sont finies (il n'y a que 83 tronçonnables à droite, alors qu'il y a 4260 tronçonnables à gauche).

Vous devez écrire un programme qui accepte un seul nombre en entrée et produit le n ème nombre premier tronçable à droite. Cependant, lorsque le programme est lu en arrière , il devrait produire le n ème nombre premier tronçable à gauche.

Pour organiser un programme en arrière, nous divisons le programme en mots, puis inversons l'ordre des mots. Un mot peut être composé de n'importe quel nombre de caractères.

Par exemple, si ce qui suit était votre programme:

hello world
1234567890

Les dispositions suivantes seraient toutes autorisées en tant qu'arrangements possibles:

Fractionnement sur chaque personnage:

0987654321
dlrow olleh

Fractionnement sur un espace blanc:

1234567890
world hello

Fractionnement arbitraire (tuyaux ajoutés pour plus de clarté):

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

908723456orld
1lo whel

Lorsque vous organisez votre programme à l'envers, tous les espaces doivent être pris en compte et inversés, comme tout autre personnage.

Entrées de test direct:

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

Entrées de test en arrière:

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

Les programmes doivent pouvoir s'exécuter dans un délai raisonnable (moins d'une minute)

C'est un code-golf , donc le programme avec le moins d'octets gagne!

Gelée , 26 23 octets

Vers l'avant

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

Essayez-le en ligne!

Mots

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

En arrière

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

Essayez-le en ligne!

Mots

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

Comment ça fonctionne

Tous les programmes Jelly sont constitués de liens (les fonctions de prise en charge de Jelly), qui sont séparés par des sauts de ligne ou des pilcrows ( ¶). Le dernier d'entre eux est le lien principal ; il est appelé automatiquement lors de l'exécution du programme.

Le programme avancé fonctionne comme suit.

Ñ                   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.

Le programme en arrière fait presque exactement la même chose; il n'y a que deux différences.

• Le lien principal est maintenant Ñ, qui appelle simplement le lien en dessous (enroulement), c'est-à-dire le lien principal du programme suivant.

• 9pau lieu de p9renvoyer le produit cartésien inversé.

Python 2, 143 139 octets

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

Se compose de cinq parties:

1. I=1
2. Une nouvelle ligne
3. a={2}…[~-n]
4. Une nouvelle ligne
5. I=0

L'inversion revient donc simplement à inverser la valeur de I.

Explication

La fonction feffectue une recherche récursive des nombres premiers tronçables à gauche (LTP) ou des nombres premiers tronçables à droite (RTP), en fonction de la valeur du global I. Ces valeurs sont ajoutées à l'ensemble a. Ensuite, lambda n:sorted(a)[~-n]renvoie le n-ième.

Définissons une feuille comme un LTP, un RTP, un chiffre non nul + un LTP, ou un RTP + un chiffre non nul. Ce sont toutes les valeurs qui fpourraient vouloir vérifier la primauté.

J'ai conçu un test pseudoprime Fermat qui fonctionne pour toutes les feuilles:

(63973 est un nombre Carmichael .)

Si ce test retourne vrai, alors zdevrait être ajouté à l'ensemble aet nous devrions reprendre str(z). Le bit de code responsable est:

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

Tout d'abord, nous souhaitons traiter le cas z == 2. Nous le faisons simplement en l'esquivant ici et en codant en dur 2lors de la définition initiale a! (EDIT: Et rien de nuisible ne se produit si nous attrapons également z == 1.) Nous pouvons donc supposer cela z ≥ 3maintenant.

J'ai traduit certains «et» en une comparaison enchaînée de court-circuit: les trois premières comparaisons doivent réussir avant a.add(z)et f(u)sont toujours évaluées. Voici tous leurs rôles:

1. z%91>0code notre première condition. (63973 est divisible par 91, ce qui n'est pas une feuille elle-même, c'est ainsi que nous la reconnaissons.)
2. 0<2est toujours vrai, mais le chaînage est plus court que and.
3. 2==pow(2,z,z) code notre deuxième condition.
4. pow(2,z,z)>a.add(z)déclenche l'addition, et est toujours vrai, car set.addretourne None, et les entiers sont toujours supérieurs à None.
5. a.add(z)<f(u)déclenche la récursivité. Sa valeur de vérité est sans importance.

Remerciements

• Dennis a enregistré quatre octets ( u=[d+s,s+d][I]→ u=d[I:]+s+d*I;z==2 → z<3et l' astuce du mod 91 ). Merci!