Une autre séquence, un autre défi. *

Définition

Un nombre premier pest dans cette séquence, appelons-le A, ssi pour chaque chiffre ddans pl'expansion décimale de, vous remplacez dpar des dcopies de det l'entier résultant est toujours premier; les zéros ne sont pas autorisés.

Par exemple, 11est trivialement dans cette séquence (c'est le premier nombre, soit dit en passant). Le suivant dans la séquence est 31, car 3331est également premier; puis 53parce que 55555333c'est aussi premier, et ainsi de suite.

Défi

Étant donné une entrée n, retournez A(n), c'est-à-dire le ne élément de cette séquence.

Exemples

Voici les 20 premiers termes pour vous aider à démarrer. C'est A057628 sur OEIS.

11, 31, 53, 131, 149, 223, 283, 311, 313, 331, 397, 463, 641, 691, 937, 941, 1439, 1511, 1741, 1871

Cela signifie A(0) = 11, A(1) = 31etc., lorsque vous utilisez l'indexation zéro.

Règles

• Vous pouvez choisir une indexation à zéro ou à base unique; veuillez préciser dans votre réponse laquelle.
• Au lieu de renvoyer uniquement le ne élément, vous pouvez choisir de renvoyer les premiers ntermes.
• Vous pouvez supposer que l'entrée / sortie ne sera pas supérieure au format entier natif de votre langue; cependant, le nombre premier répété peut être plus grand que le format natif de votre langue, il faudra donc en tenir compte.
• Par exemple, 1871le dernier nombre d'exemples a un nombre premier correspondant de 18888888877777771, qui est un peu plus grand que l'INT32 standard.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• La sortie peut être vers la console, renvoyée par une fonction, affichée dans une fenêtre d'alerte, etc.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

* Pour être honnête, j'avais trouvé les premiers termes de la séquence en jouant avec quelques chiffres, puis je suis allé à OEIS pour obtenir le reste de la séquence.

Husk , 15 octets

!fo§&öεpd´ṘΠdİp

Essayez-le en ligne!

!                 Index into
             İp     the list of primes
 f                    for which:
            d            the digits of p
  o§&                      satisfy both:
     öεpd´Ṙ                  repeated "themselves" times, they form a prime.
           Π                 they are all nonzero.

Erik l'Outgolfer a enregistré un octet. Utiliser ṗau lieu de εpsauverait un autre octet, mais cela rend le programme si lent qu'il multiplie notre pair pour n = 2.

05AB1E , 14 13 octets

-1 octet grâce à Emigna !

µNSÐPŠ×JpNpPĀ½

Essayez-le en ligne!

Explication

µNSÐPŠ×JpNpPĀ½
µ              # Do until the input is reached...
 N              # Push the iteration counter
  S             # Split it to its digits
   Ð            # And push two copies of it to the stack
    P           # Get the digital product of the counter
     Š          # And place it two places down the stack
      ×J        # Repeat each digit by itself and join it back to a number
        p       # Check for primality on that result
         Np     # And on the original counter as well
           PĀ   # Create the product and truthify the result
                # Implicit: If it is true increment the input number

Gelée , 18 14 octets

ÆPaDxDḌÆPaDẠµ#

Essayez-le en ligne!

M. Xcoder: -1 octet (tout logique)

Erik the Outgolfer: -2 octets (une ligne au lieu de deux)

HyperNeutrino: -1 octet (retourne les n premiers éléments de la séquence)

Explication

ÆPaDxDḌÆPaDẠµ#     First Link
ÆP                Is prime?
  a               logical and
   D              convert number to list of digits
    xD            repeat each digit as many times as it's value
      Ḍ           convert to an integer
       ÆP         is prime?
         a        logical and
          D       list of digits
           Ạ      logical all
            µ     the following link as a monad
             #    Do this until n matches are found and return them all

Edit: initialement soumis une réponse qui comprenait des nombres avec 0 dans sa représentation décimale qui n'est spécifiquement pas autorisée.

Wolfram Language (Mathematica) , 100 octets

Nest[#+1//.i_/;!PrimeQ@FromDigits[##&@@#~Table~#&/@(l=IntegerDigits@i)]||Min@l<1:>NextPrime@i&,1,#]&

Essayez-le en ligne!

Jonathan Frech a économisé 3 octets

et -7 octets de JungHwan Min

-15 octets de Martin Ender

merci aussi à Jenny Mathy

Alice , 72 70 66 62 56 octets

Merci à Leo d'avoir économisé 5 octets.

/.\&wh...tz~F0/*$\W.tzt$W?K/ o
\i/&.,a:.$K;d&\FR/K.!w.a%

Essayez-le en ligne!

Utilise une entrée basée sur 1.

Explication

L'astuce de golf neatest ici (même si elle enregistre seulement quelques octets) est que j'utilise un test de primalité qui donne 0pour la composition n pour la nnon-composite n . De cette façon, nous n'avons pas à utiliser le résultat directement dans un conditionnel, mais nous pouvons le passer directement à la partie suivante qui vérifie que l'entrée ne contient pas de zéros.

/i\       Read all input in Ordinal mode (the usual way to read decimal input).
&w        Push the current IP position onto the return address stack (RAS)
          n times. This effectively begins our main loop. We will return
          here after each number we've checked, but whenever we come across
          a repeated digit prime (RDP), we will pop one copy of the address
          from the RAS, so that the loops ends once we've found n RDPs.

h.        Increment our main loop iterator X (initially an implicit zero on
          the empty stack) and duplicate it.
.         Make another copy.
.tz       Drop all factors less than X. This gives X for prime X and 1 for
          non-prime X.
~F        Check whether X divides this value. Of course, X divides X so this
          gives X for non-composite X. But X doesn't divide 1 (unless X is 1),
          so we get 0 for composite X. Call this Y.
0         Push a 0.
\         Switch to Ordinal mode.
F         Implicitly convert both to string and check whether Y contains 0.
$/K       If it does, return to the w. Either way, switch back to Cardinal mode.
          Note that the only numbers that get to this point are 1 and prime
          numbers which don't contain 0. It's fine that we let 1 through here,
          because we'll use a proper primality test for the digit-expanded
          version later on.
.!        Store a copy of X on the tape. Let's call the copy that remains on
          the stack Z, which we're now decomposing into digits while expanding
          them.
w         Push the current IP position to the RAS. This marks the beginning
          of an inner loop over the digits of Z.

  .a%       Duplicate Z and retrieve its last digit D by taking Z % 10.
  \./       Duplicate D (in Ordinal mode but that doesn't matter).
  &.        Duplicate D, D times. So we end up with D+1 copies of D.
  ,         Pop the top D and pull up the Dth stack element, which is Z.
  a:        Discard the last digit by taking Z / 10.
  .$K       If Z is zero now, skip the K and end the inner loop, otherwise
            repeat the inner loop.
;         Discard the 0 (what used to be Z).
          We now have D copies of each digit D on the stack, but the digits
          were processed in reverse order, so the last digit is at the bottom.
d&        Repeat the next command once for each stack element.
\*        Concatenate in Ordinal mode. This joins all the digits on the
          stack into a single string.
R         Reverse that string. This is the digit-expanded version of X.
/         Switch back to Cardinal mode.
W         Pop the inner loop's return address from the RAS. We could have done
          this right after the most recent K, but putting it here helps lining
          up the two Ordinal sections in the program layout.
.tzt      Is the digit-expanded number a prime?
$W        If so, we've found an RDP. Pop one copy of the main loop address 
          from the RAS.
g         Recover the current value of X from the top left grid cell.
K         Jump back to the w if any copies of the return address are left 
          on the RAS. Otherwise, we leave the main loop.
/o        Implicitly convert the result to a string and print it in
          Ordinal mode.
          The IP will then bounce off the top right corner and start
          travelling through the program in reverse. Whatever it does
          on the way back is utter nonsense, but it will eventually get
          back to the division (:). The top of the stack will be zero
          at that point and therefore the division terminates the program.

Python 2 , 130 octets

• Merci à ArBo pour cette solution plus courte de quatre octets.

f=lambda n,c=9:n and f(n-(('0'in`c`)<p(c)*p(int("".join(d*int(d)for d in`c`)))),c+1)or~-c
p=lambda n:all(n%m for m in xrange(2,n))

Essayez-le en ligne!

Python 2 , 195 179 167 140 138 136 135 134 octets

• 27 octets enregistrés grâce aux ovs ; utiliser xrangeau lieu de range, ainsi contourner a MemoryErroret compacter la fonction principale; l'amélioration du comptage d'indices entiers.
• Enregistré deux octets; en utilisant un canal binaire ou des opérations |pour économiser des octets or.
• Enregistré deux octets; inverser la fonction principale et faire une autre manipulation logique.
• Enregistré un octet; utiliser ~-au lieu de 0**pour inverser l'existence d'un zéro dans j, &suivi d'un vrai booléen, isole la propriété booléenne de cette valeur.
• Enregistré un octet grâce à Lynn ; jouer au golf ~-A&B&C(équivalent à (not A) and B and C) en A, B, Cétant booléen A<B==C.

def f(n,j=9,p=lambda n:all(n%j for j in xrange(2,n))):
 while n:j+=1;n-=("0"in`j`)<p(j)==p(int("".join(d*int(d)for d in`j`)))
 print j

Essayez-le en ligne! (1 index)

Explication

Définit une fonction principale fqui prend un index entier n, et une valeur définie par défaut j, la séquence en cours canditate (intitulée 9pour améliorer les performances tout en conservant la taille du programme) et une fonction de vérification principale.
Tant qu'il nest différent de zéro, l' nentrée de séquence -th n'est pas encore trouvée. Il jest donc incrémenté et ndécrémenté d'une unité si jun nombre satisfait les propriétés requises.
Lorsque la boucle se termine, jc'est la n-ième entrée de séquence et donc imprimée.

Pyth , 21 octets

.f&.AKjZT&P_ss*VK`ZP_

Essayez-le ici!

Assez long car Pyth n'a pas d' expansion décimale intégrée.

• Prenez les N premiers entiers positifs ( .f), qui:
  • Ayez tous les chiffres véridiques ( .AKjZT), et ( &) ...
  • La multiplication vectorisée de leur représentation sous forme de chaîne avec leurs chiffres ( *VK`Z), réunis et convertis en un entier ( ss) sont prime ( P_) et ( &) ...
  • Ce sont des nombres premiers eux-mêmes ( P_).

Perl 6 , 51 octets

{(grep {!/0/&is-prime $_&S:g/./{$/x$/}/},2..*)[$_]}

Essayez-le en ligne!

• grep {...}, 2..* filtre la séquence infinie de nombres naturels à partir de 2 en utilisant la fonction de prédicat entre les accolades. (...)[$_]indexe dans cette liste filtrée en utilisant l'argument de la fonction $_.
• !/0/ filtre les nombres qui contiennent un chiffre zéro.
• S:g/./{$/ x $/}/ reproduit chaque chiffre dans l'expansion décimale du numéro de test.
• is-prime $_ & S:g/./{$/ x $/}/appelle la is-primefonction intégrée avec une jonction et $_, le numéro de test et le numéro résultant de la réplication de ses chiffres. La fonction retournera true si les deux membres de la jonction and sont premiers.

J, 81 octets

f=.[:1&p:(*@(*/)*x:@#~)&.(10&#.inv)
[:{.(4&p:@{.@]([,]+f@[){:@])^:([>{:@])^:_&2 0

C'est une de ces situations pour lesquelles je n'ai pas encore trouvé de bonne solution J.

Néanmoins, je poste ceci dans l'espoir d'apprendre quelque chose de nouveau.

fnous indique si un nombre donné est un "nombre premier répété". Il se décompose comme suit:

[:1&p:                               is the following a prime?
      (*@                            the signum of...
         (*/)                        the product of the digits
             *                       times...
              x:@                    force extended precision of...
                 #~)                 self-duplicated digits
                    &.               "Under": perform this, then perform its inverse at the end
                      (10&#.inv)     convert to a list of digits

Et enfin le principal Do ... Bien que le verbe, avec son passe-partout embêtant et apparemment inévitable, qui découle du fait que nous devons utiliser une liste pour stocker nos progrès, ce qui nécessite à la fois des registres "actuels" et "trouvés jusqu'à présent" , puisque notre argument de gauche est déjà pris pour stocker la condition d'arrêt, c'est-à-dire n. Cela signifie que nous devons utiliser de nombreux octets précieux pour la tâche simple de spécifier args ( [et ]) et de décompresser notre liste de 2 éléments ( {.et {:):

[:{.                                                take the first element of the final result, of the following Do... While:
    (4&p:@                                          the next prime after...
          {.@                                       the first element of...
             ]                                      the right arg 
                       {:@])                        the last (2nd) elm of the arg...
              ([,]+f@[)                             those two now become the left and right args to this verb...
               [,                                   left arg appended to...
                 ]+                                 right arg plus...
                   f@[                              f of the left arg...
                             ^:(      )^:_          keep doing all that while...
                                [>                  the left is bigger than...
                                  {:@]              the last elm of the right arg
                                          &2 0      seed the process with 2 0, ie,
                                                    the first prime, and 0 rdps found so far.

Essayez-le en ligne!