Outra sequência, outro desafio. *

Definição

Um primo pestá nesta sequência, vamos chamá-lo A, se para cada dígito dna pexpansão decimal de você substituir dpor dcópias de de o inteiro resultante ainda for primo; zeros não são permitidos.

Por exemplo, 11está trivialmente nesta sequência (é o primeiro número, aliás). O próximo na sequência é 31, porque 3331também é primo; então 53porque 55555333também é primo, e assim por diante.

Desafio

Dada uma entrada n, retorne A(n), ou seja, o nth item nesta sequência.

Exemplos

Aqui estão os 20 primeiros termos para você começar. Este é A057628 no OEIS.

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

Isso significa A(0) = 11, A(1) = 31etc., ao usar a indexação zero.

Regras

• Você pode escolher a indexação com base em zero ou uma; especifique na sua resposta qual.
• Em vez de retornar apenas o nelemento th, você pode optar por retornar os primeiros ntermos.
• Você pode assumir que a entrada / saída não será maior que o formato inteiro nativo do seu idioma; no entanto, o número primo de dígitos repetidos pode ser maior que o formato nativo do seu idioma, portanto, isso deve ser levado em consideração.
• Por exemplo, 1871o último número dos exemplos, possui um prime correspondente 18888888877777771, que é um pouco maior que o INT32 padrão.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• A saída pode ser no console, retornada de uma função, exibida em um pop-up de alerta, etc.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

* Para ser sincero, eu tinha apresentado os primeiros termos da sequência apenas brincando com alguns números e depois fui para a OEIS para obter o resto da sequência.

Casca , 15 bytes

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

Experimente 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, o Outgolfer, salvou um byte. Usandoṗ vez de εpsalvaria outro byte, mas isso torna o programa tão lento que o tempo é igual a n = 2.

05AB1E , 14 13 bytes

-1 byte graças a Emigna !

µNSÐPŠ×JpNpPĀ½

Experimente online!

Explicação

µ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éia , 18 14 bytes

ÆPaDxDḌÆPaDẠµ#

Experimente online!

Sr. Xcoder: -1 Byte (tudo lógico)

Erik the Outgolfer: -2 Bytes (uma linha em vez de duas)

HyperNeutrino: -1 Byte (retorna os primeiros n elementos da sequência)

Explicação

Æ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

Editar: originalmente enviou uma resposta que incluía números com 0 na sua representação decimal, o que não é especificamente permitido.

Wolfram Language (Mathematica) , 100 bytes

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

Experimente online!

Jonathan Frech salvou 3 bytes

e -7 bytes de JungHwan Min

-15 bytes de Martin Ender

também graças a Jenny Mathy

Alice , 72 70 66 62 56 bytes

Agradecemos a Leo por salvar 5 bytes.

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

Experimente online!

Usa entrada baseada em 1.

Explicação

O truque mais puro golfe aqui (mesmo que só poupa um par de bytes) é que eu estou usando um teste de primalidade que dá 0para composite n para npara não-composite n . Dessa forma, não precisamos usar o resultado diretamente de forma condicional, mas podemos transmiti-lo diretamente para a próxima parte que verifica se a entrada não contém zeros.

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

• Graças a ArBo por esta solução de quatro bytes mais curta.

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

Experimente online!

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

• Economizou 27 bytes graças a ovs ; usando em xrangevez de range, contornando a MemoryErrore compactando a função principal; melhorando a contagem de índice inteiro.
• Salvou dois bytes; usando pipe ou operações binárias |para salvar bytes or.
• Salvou dois bytes; invertendo a função principal e fazendo alguma manipulação lógica adicional.
• Salva um byte; usando em ~-vez de 0**inverter a existência de um zero emj , &seguido por um booleano verdadeiro, isola a propriedade booleana desse valor.
• Salvou um byte graças a Lynn ; golfe ~-A&B&C(equivalente a (not A) and B and C) com A, B, Cser booleanos para 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

Experimente online!(Indexado 1)

Explicação

Define uma função principal fque recebe um índice inteiro n, e um valor definido por padrão j, a sequência atual canditate (destinada 9a melhorar o desempenho enquanto mantém o tamanho do programa) e uma função de verificação primária.
Contanto que nseja diferente de zero, a nentrada da quinta sequência ainda não foi encontrada. Assim, jé incrementado e ndecrementado por um iff jé um número que satisfaz as propriedades necessárias.
Quando o loop termina, jé a nentrada da -ésima sequência e, portanto, é impressa.

Pitão , 21 bytes

.f&.AKjZT&P_ss*VK`ZP_

Experimente aqui!

Bastante demorado, já que Pyth não tem uma expansão decimal incorporada.

• Pegue o primeiro N números inteiros positivos ( .f), que:
  • Tenha todos os dígitos verdadeiros (.AKjZT ) e ( &) ...
  • A multiplicação vetorizada de sua representação de string com seus dígitos ( *VK`Z), unidos e convertidos em um número inteiro ( ss) são primos ( P_) e (& ) ...
  • Esses são os próprios primos ( P_).

Perl 6 , 51 bytes

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

Experimente online!

• grep {...}, 2..*filtra a sequência infinita de números naturais a partir de 2 usando a função de predicado entre as chaves. (...)[$_]indexa nessa lista filtrada usando o argumento da função$_ .
• !/0/ filtra números que contêm um dígito zero.
• S:g/./{$/ x $/}/ replica cada dígito na expansão decimal do número de teste.
• is-prime $_ & S:g/./{$/ x $/}/chama a is-primefunção interna com uma junção e de $_, o número de teste e o número resultante da replicação de seus dígitos. A função retornará true se os dois membros da junção e forem primos.

J, 81 bytes

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

Essa é uma daquelas situações para as quais ainda não encontrei uma boa solução J.

No entanto, eu posto isso na esperança de aprender algo novo.

fnos diz se um determinado número é um "primo de dígito repetido". Ele divide da seguinte forma:

[: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 finalmente o principal ... Enquanto o verbo, com seu clichê irritante e aparentemente inevitável, surge do fato de que precisamos usar uma lista para armazenar nosso progresso, o que exige registros "atuais atuais" e "encontrados até agora" , já que nosso argumento esquerdo já foi usado para armazenar a condição de parada, ou seja n,. Isso significa que devemos usar muitos bytes preciosos para a tarefa simples de especificar args ( [e ]) e descompactar nossa lista de 2 elementos ( {.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.

Experimente online!