Esta questão será uma torção para encontrar o nnúmero primo th.

Desafio

Você deve escrever um programa que terá uma entrada ne produzirá o nnúmero primo cuja representação decimal contém a representação decimal de numa subtração.

Confuso? Aqui estão alguns exemplos.

n=1
Primes: 2, 3, 5, 7, 11
                    ^1 first prime that contains a 1
Output: 11

n=2
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
        ^1                          ^2 second prime that contains a 2
Output: 23

n=3
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
           ^1           ^2          ^3 third prime that contains a 3
Output: 23

n=10
Primes: 2, 3, 5, 7, 11, ..., 97, 101, 103, 107, 109, ..., 997, 1009, 1013, 1019, 1021, 1031, 1033
                                 ^1   ^2   ^3   ^4             ^5    ^6    ^7    ^8    ^9    ^10 tenth prime that contains a 10
Output: 1033

Isso é código-golfe , então a menor contagem de bytes vence.

Se algo estiver confuso, deixe um comentário.

05AB1E , 8 bytes

Código:

µN¹åNp*½

Explicação:

µ          # Run this until the counting variable has reached the input value.
 N¹å       # Check if the input number is in the range variable.
    Np     # Check if the range variable is prime.
      *    # Multiply those two numbers (which is basically an AND operator).
       ½   # If true, increment the counting variable.
           # After the loop, the stack is empty and implicitly prints N.

Usa a codificação CP-1252 . Experimente online! .

Pitão - 11 bytes

e.f&P_Z}`Q`

Conjunto de Teste .

Python 2, 67 65 62 bytes

f=lambda n,k=0,m=2,p=1:k/n or-~f(n,k+p%m*(`n`in`m`),m+1,p*m*m)

Teste em Ideone .

Como funciona

Usamos um corolário do teorema de Wilson :

Em todo momento, a variável p é igual ao quadrado do fatorial de m - 1 .

Se k <n , k/nirá produzir 0 e f é chamado de forma recursiva. m é incrementado, p é atualizado ek é incrementado se e somente se m for um primo que contém n .

O último é alcançado adicionando o resultado de p%m*(`n`in`m`)a k . Pelo corolário do teorema de Wilson, se m é primo, p%mretorna 1 e, se não, retorna 0 .

Uma vez que k alcances n , encontramos q , o n ^º nobre que contém n .

Estamos na próxima ligação durante a verificação, então m = q + 1 . k/nretornará 1 e os operadores bit a bit -~aumentarão esse número uma vez para cada chamada de função. Como são necessárias q - 1 chamadas para f para incrementar m de 2 para q + 1 , a chamada mais externa para f retornará 1 + q - 1 = q , conforme pretendido.

Bash, 27 bytes

primes 0|grep $1|sed $1q\;d

primes vem de bsdgames.

Recebe a entrada como argumento da linha de comando e gera STDOUT.

Gelatina , 13 bytes

×ÆP,³Dœṣ/Ṗµ#Ṫ

Experimente online!

Mathematica, 75 bytes

Nest[NestWhile[b=NextPrime,b@#,!StringContainsQ@@ToString/@{#,a}&]&,1,a=#]&

Ainda pode ser jogável.

Java, 194 180 173 171 112 Bytes

Código:

a->{int i=1,j,n,r=0;for(j=n=new Integer(a);(r+=++i>=j&(""+j).contains(""+n)?1:0)!=n;j+=j%i==0?i=1:0);return j;}

Ungolfed:

class P{
    static int i=1,j,n,r;
    public static void main(String[]s) {
        for(
                j=n=new Integer(s[0]); //executes once before first iteration
                (r+=++i>=j&(""+j).contains(""+n)?1:0)!=n; //executes on first and every iteration
                j+=j%i==0?i=1:0 //executes after first and every iteration
           ) {
            ;
        }
        System.out.print(j);
    }
}

Rubi, 62 61 bytes

->i{Prime.lazy.map(&:to_s).grep(/#{i}/).first(i)[-1]}

Requer o -rprimesinalizador (+8 bytes).

->i{            # lambda with one argument
Prime           # iterator over all primes
.lazy           # make the iterator lazy (can't evaluate infinite primes)
.map(&:x.to_s)  # convert the primes to strings
.grep(/#{i}/)   # find primes that regex match on the input (contain it)
.first(i)       # take the first (input) primes that satisfy this
[-1]            # take the last of those
}

Julia, 61 60 bytes

f(n,k=0,m=1)=k<n&&f(n,k+isprime(m)contains("$m","$n"),m+1)+1

Experimente online!

MATL , 18 bytes

`@YqVGVXf?3M]NG<]&

Experimente online!

Explicação

Isso gera números primos em ordem usando um do...whileloop. Para cada injeção, a condição é testada (e a injeção é consumida). Se satisfeito, esse prime é empurrado para a pilha novamente. O número de elementos na pilha é usado como contagem de números primos qualificados que encontramos. Quando houver um número suficiente deles, o último será exibido.

`         % Do...while
  @       %   Push iteration index, k. Starts at 1
  YqV     %   k-th prime. Convert to string
  GV      %   Push input, n. Convert to string
  Xf      %   Find string within another
  ?       %   If non-empty
    3M    %     Push k-th prime again (increase stack size by 1)
  ]       %   End if
  NG<     %   Is stack size less than input number? If so proceeed with
          %   a new iteration; else exit do...while loop
]         % End do...while
&         % Implicitly display only top number in the stack 

Pyke, 15 bytes

Q.fD_P.I`Q`R{(e

Experimente aqui!

Bash + GNU coreutils, 66 bytes

Ao contrário da solução do @ Doorknob, esta precisa apenas de coisas que estão instaladas em todos os GNU / Linux:

for((n=2;;n++)){
[ `factor $n|wc -w` -eq 2 ]&&grep $1<<<$n&&exit
}

Perl 6 , 41 bytes

->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

Explicação:

-> $n { # has one parameter
  grep(
    {
      .is-prime # check that it is prime
      &&        # and
      / $n /    # that it contains the argument in the "string"
    },
    2 .. *      # for all numbers starting with 2
  )[ $n - 1 ]   # only take the $n-th one
                # ( accounting for 0 based array access )
}

Teste:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &prefix:<ℙ𝕟> = ->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

my @test = (
  1  => 11,
  2  => 23,
  3  => 23,
  10 => 1033,
);

plan +@test;

for @test {
  is ℙ𝕟.key, .value, .gist
}

1..4
ok 1 - 1 => 11
ok 2 - 2 => 23
ok 3 - 3 => 23
ok 4 - 10 => 1033

Java 8, 192 183 181 171 bytes (programa completo)

interface M{static void main(String[]a){long n=new Long(a[0]),c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(a[0])?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);System.out.print(r);}}

Experimente online.

Explicação:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    long n=new Long(a[0]),      //   Input argument as number
         c=0,                   //   Counter, starting at 0
         r=1,                   //   Result-number, starting at 1
         m,i;                   //   Temp number
    for(;c<n;                   //   Loop as long as `c` does not equals `n`
        c+=                     //     After every iteration: increase `c` by:
           m>1                  //      If the current `r` is a prime,
           &(r+"").contains(a[0])?
                                //      and this prime contains the input `n`
            1                   //       Increase `c` by 1
           :                    //      Else:
            0)                  //       Leave `c` the same
      for(m=++r,                //    Increase `r` by 1 first with `++r`, and set `m` to it
          i=2;i<m;              //    Inner loop `i` in the range [2, `m`)
        m=m%i++<1?              //     If `m` is divisible by `i`
           0                    //      Change `m` to 0 (so it's not a prime)
          :                     //     Else:
           m);                  //      Leave `m` unchanged
    System.out.print(r);}}      //    Print `r` as result

Java 8, 105 bytes (função lambda)

n->{int c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(n+"")?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);return r;}

Experimente online.

O mesmo que acima, mas com nentrada como inteiro e sem o material de classe detalhado.

Clojure, 118 bytes

(defn s[n](nth(filter(fn[x](if(.contains(str x)(str n))(not-any? #(=(mod x %)0)(range 2 x))))(drop 2(range)))(dec n)))

Apenas obtém o enésimo elemento da preguiçosa sequência infinita de números que são primos e têm n em sua representação de cadeias.

Você pode experimentá-lo aqui: https://ideone.com/ioBJjt

Na verdade, 16 bytes

;$╗`P$╜@íu`╓dP.X

Experimente online!

Explicação:

;$╗`P$╜@íu`╓dP.X
;$╗               make a copy of n, push str(n) to reg0
   `      `╓      push the first n values where f(k) is truthy, starting with k=0:
    P$              kth prime, stringified
      ╜@íu          1-based index of n, 0 if not found
            d     remove last element of list and push it to the stack (dequeue)
             P    nth prime
              .   print
               X  discard rest of list

PowerShell v2 +, 108 99 bytes

Ooof. A falta de qualquer tipo de cálculo / verificação principal embutido realmente dói aqui.

param($n)for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){if("$i"-like"*$n*"){if(++$o-eq$n){$i;exit}}}}

Recebe entrada $n, entra em um for()loop infinito . A cada iteração, usamos um forloop em volta do verificador principal do regex do PowerShell (h / t para Martin) para transformá-lo em um gerador principal, incrementando $icada vez que o loop é feito. (Por exemplo, executando apenasfor(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}} produzirá2, 3, 5, 7... separado por novas linhas).

Em seguida, faça uma -likeverificação simples para ver se $nestá em algum lugar $ie aumente nosso contador $o. Se alcançamos onde $ne $osomos iguais, produzimos $ie exit. Caso contrário, continuamos até o forpróximo primo e o processo se repete.

APL (NARS), 39 caracteres, 78 bytes

{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}

1π é o próximo número primo ...; teste:

  f←{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}
  f¨1 2 3 10
11 23 23 1033 

mas que já aos 20 anos sai do espaço da pilha ... Em vez disso, isso abaixo parece ok, mesmo que tenha um pouco mais de duração (61 caracteres)

∇r←f w;i;k;s
r←2⋄s←⍕w⋄i←1
→0×⍳(w≤i)∧k←∨/s⍷⍕r⋄r←1πr⋄i+←k⋄→2
∇

  f¨1 2 3 10 20 100
11 23 23 1033 4201 100999 

Adicionar ++ , 36 bytes

L,5*2^RßÞPABDBJVB]dG€Ωezߣ*BZB]A1_$:

Experimente online!

Bastante ineficiente. Repete cada número inteiro$i$ de tal modo que $i \le 25x^2$ e filtra compostos e primos que não contêm $n$. Finalmente, tomamos o$n$th valor dos números inteiros restantes.

Japonês -h , 15 13 11 bytes

_j ©ZsèU}jU

Tente