Un'altra sequenza, un'altra sfida. *

Definizione

Un primo pè in questa sequenza, chiamiamola A, se e solo se per ogni cifra din psviluppo decimale 's, si sostituisce dcon dcopie de l'intero risultante è ancora prime; gli zeri non sono ammessi.

Ad esempio, 11è banalmente in questa sequenza (è il primo numero, per inciso). Il prossimo nella sequenza è 31, perché 3331è anche primo; allora 53perché 55555333è anche primo, e così via.

Sfida

Dato un input n, return A(n), ovvero l' nelemento th in questa sequenza.

Esempi

Ecco i primi 20 termini per iniziare. Questo è A057628 su OEIS.

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

Ciò significa A(0) = 11, A(1) = 31ecc., Quando si utilizza l'indicizzazione zero.

Regole

• È possibile scegliere l'indicizzazione con zero o uno basato; si prega di specificare nella risposta quale.
• Invece di restituire solo l' nelemento th, puoi invece scegliere di restituire i primi ntermini.
• Puoi presumere che l'input / output non sarà più grande del formato intero nativo della tua lingua; tuttavia, il numero primo a cifre ripetute potrebbe essere più grande del formato nativo della tua lingua, quindi sarà necessario tenerne conto.
• Ad esempio, 1871l'ultimo numero degli esempi ha un numero primo corrispondente 18888888877777771, che è un po 'più grande dello standard INT32.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• L'output può essere sulla console, restituito da una funzione, visualizzato in un popup di avviso, ecc.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

* Per essere onesti, avevo escogitato i primi termini della sequenza solo giocando con alcuni numeri, e poi sono andato a OEIS per ottenere il resto della sequenza.

Buccia , 15 byte

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

Provalo online!

!                 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 the Outgolfer ha salvato un byte. Usando ṗinvece di εpsi salverebbe un altro byte, ma questo rende il programma così lento che fa il nostro anche per n = 2.

05AB1E , 14 13 byte

-1 byte grazie a Emigna !

µNSÐPŠ×JpNpPĀ½

Provalo online!

Spiegazione

µ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

Gelatina , 18 14 byte

ÆPaDxDḌÆPaDẠµ#

Provalo online!

Sig. Xcoder: -1 byte (tutto logico)

Erik the Outgolfer: -2 byte (una riga anziché due)

HyperNeutrino: -1 byte (restituisce i primi n elementi della sequenza)

Spiegazione

Æ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

Modifica: originariamente ha inviato una risposta che includeva numeri con 0 nella sua rappresentazione decimale che non è specificatamente consentita.

Wolfram Language (Mathematica) , 100 byte

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

Provalo online!

Jonathan Frech ha salvato 3 byte

e -7 byte da JungHwan Min

-15 byte da Martin Ender

anche grazie a Jenny Mathy

Alice , 72 70 66 62 56 byte

Grazie a Leo per aver salvato 5 byte.

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

Provalo online!

Utilizza un input basato su 1.

Spiegazione

Il trucco golf più grazioso qui (anche se si salva solo un paio di byte) è che io sto usando un test di primalità che dà 0per composito n per i nper i non-composito n . In questo modo, non dobbiamo usare il risultato direttamente in un condizionale, ma possiamo passarlo direttamente alla parte successiva che controlla che l'input non contenga zero.

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

• Grazie ad ArBo per questa soluzione più corta di quattro byte.

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

Provalo online!

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

• Salvato 27 byte grazie agli ovs ; utilizzandoxrange invece di range, aggirando così a MemoryErrore compattando la funzione primaria; migliorare il conteggio dell'indice intero.
• Salvato due byte; usando il tubo binario o le operazioni| per salvare byte or.
• Salvato due byte; invertendo la funzione primaria e facendo qualche ulteriore manipolazione logica.
• Salvato un byte; usando ~-invece di 0**invertire l'esistenza di uno zero in j, come& seguito da un vero booleano isola la proprietà booleana di questo valore.
• Salvataggio di un byte grazie a Lynn ; giocare a golf ~-A&B&C(equivalente a (not A) and B and C) con l' A, B, Cessere booleano a 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

Provalo online! (1-indicizzati)

Spiegazione

Definisce una funzione principale fche accetta un indice intero ne un valore impostato di default j, la sequenza corrente candita (destinata 9a migliorare le prestazioni mantenendo le dimensioni del programma) e una funzione di controllo principale.
Finché nè diverso da zero, la nvoce della sequenza non è ancora stata trovata. Pertanto jviene incrementato e ndecrementato di un iff jè un numero che soddisfa le proprietà richieste.
Quando il loop termina, jviene nimmessa la sequenza -th e quindi stampata.

Pyth , 21 byte

.f&.AKjZT&P_ss*VK`ZP_

Provalo qui!

Piuttosto lungo in quanto Pyth non ha un'espansione decimale integrata.

• Prendi i primi N numeri interi positivi ( .f), che:
  • Avere tutte le cifre verità ( .AKjZT) e ( &) ...
  • La moltiplicazione vettoriale della rappresentazione della stringa con le cifre ( *VK`Z), unite insieme e convertite in un numero intero ( ss) sono prime ( P_) e ( &) ...
  • Questi sono numeri primi stessi ( P_).

Perl 6 , 51 byte

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

Provalo online!

• grep {...}, 2..* filtra la sequenza infinita di numeri naturali a partire da 2 usando la funzione predicato tra parentesi graffe. (...)[$_]indicizza in questo elenco filtrato usando l'argomento della funzione $_.
• !/0/ filtra i numeri che contengono una cifra zero.
• S:g/./{$/ x $/}/ replica ogni cifra nell'espansione decimale del numero di test.
• is-prime $_ & S:g/./{$/ x $/}/chiama la is-primefunzione integrata con una giunzione e di $_, il numero di test e il numero risultante dalla replica delle sue cifre. La funzione tornerà vera se entrambi i membri della giunzione e sono primi.

J, 81 byte

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

Questa è una di quelle situazioni per le quali non ho ancora trovato una buona soluzione J.

Ciononostante, inserisco questo nella speranza di imparare qualcosa di nuovo.

fci dice se un dato numero è un "numero primo ripetuto". Si suddivide come segue:

[: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

E infine il principale Do ... While verbo, con la sua fastidiosa, apparentemente inevitabile caldaia, che deriva dal fatto che abbiamo bisogno di usare un elenco per memorizzare i nostri progressi, che richiede sia i registri "attuali primi" che "trovati finora" , poiché il nostro argomento di sinistra è già utilizzato per memorizzare la condizione di arresto, ovvero n. Ciò significa che dobbiamo usare molti byte preziosi per il semplice compito di specificare args ( [e ]) e decomprimere il nostro elenco di 2 elementi ( {.e {:):

[:{.                                                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.

Provalo online!