Questa domanda sarà una svolta nel trovare il nnumero primo.

Sfida

È necessario scrivere un programma che accetta un input ne produrre il nprimo numero primo la cui rappresentazione decimale contiene la rappresentazione decimale di ncome sottotitola.

Confuso? Ecco alcuni esempi.

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

Questo è code-golf , quindi vince il conteggio di byte più basso.

Se qualcosa è confuso, si prega di lasciare un commento.

05AB1E , 8 byte

Codice:

µN¹åNp*½

Spiegazione:

µ          # 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.

Utilizza la codifica CP-1252 . Provalo online! .

Pyth - 11 byte

e.f&P_Z}`Q`

Test Suite .

Python 2, 67 65 62 byte

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)

Provalo su Provalo Ideone .

Come funziona

Usiamo un corollario del teorema di Wilson :

In ogni momento, la variabile p è uguale al quadrato del fattoriale di m - 1 .

Se k <n , k/nprodurrà 0 e f è chiamato ricorsivamente. m viene incrementato, p viene aggiornato e k viene incrementato se e solo se m è un numero primo che contiene n .

Quest'ultimo si ottiene aggiungendo il risultato di p%m*(`n`in`m`)a k . Secondo il corollario del teorema di Wilson se m è primo, p%mrestituisce 1 e, in caso contrario, restituisce 0 .

Una volta k raggiunge n , abbiamo trovato q , il n ^° primo che contiene n .

Siamo nella prossima chiamata durante il controllo, quindi m = q + 1 . k/nrestituirà 1 e gli operatori bit a bit -~incrementeranno quel numero una volta per ogni chiamata di funzione. Poiché sono necessarie q - 1 chiamate a f per incrementare m da 2 a q + 1 , la chiamata più esterna a f restituirà 1 + q - 1 = q , come previsto.

Bash, 27 byte

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

primes viene da bsdgames.

Accetta input come argomento della riga di comando e output su STDOUT.

Gelatina , 13 byte

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

Provalo online!

Mathematica, 75 byte

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

Potrebbe essere ancora golfabile.

Java, 194 180 173 171 112 byte

Codice:

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

Rubino, 62 61 byte

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

Richiede il -rprimeflag (+8 byte).

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

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

Provalo online!

MATL , 18 byte

`@YqVGVXf?3M]NG<]&

Provalo online!

Spiegazione

Questo genera numeri primi nell'ordine usando un do...whileciclo. Per ogni numero primo, viene verificata la condizione (e il primo viene consumato). Se soddisfatto, quel numero primo viene nuovamente inserito nello stack. Il numero di elementi nello stack viene utilizzato come conteggio di quanti numeri primi qualificanti abbiamo trovato. Quando ce ne sono abbastanza, viene visualizzato l'ultimo.

`         % 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 byte

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

Provalo qui!

Bash + GNU coreutils, 66 byte

Contrariamente alla soluzione di @ Doorknob, questa necessita solo di cose installate su ogni GNU / Linux:

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

Perl 6 , 41 byte

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

Spiegazione:

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

Test:

#! /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 byte (programma 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);}}

Provalo online.

Spiegazione:

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 byte (funzione 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;}

Provalo online.

Come sopra, ma con ninput intero e senza roba di classe dettagliata.

Clojure, 118 byte

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

Ottiene solo l'ennesimo elemento della sequenza infinita di numeri pigri che sono primi e hanno n nella loro rappresentazione in stringa.

Puoi provarlo qui: https://ideone.com/ioBJjt

In realtà, 16 byte

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

Provalo online!

Spiegazione:

;$╗`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 byte

Ooof. La mancanza di qualsiasi tipo di calcolo / controllo primario incorporato fa davvero male qui.

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

Accetta input $n, entra in un for()loop infinito . Ad ogni iterazione, utilizziamo un forciclo racchiuso nel controllo di regex regex di PowerShell (da h / t a Martin) per trasformarlo in un generatore principale incrementando $iogni volta attraverso il ciclo. (Ad esempio, eseguendo solo for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}verrà generato2, 3, 5, 7... separatamente da nuove righe).

Quindi un semplice -likecontrollo per vedere se $nè da qualche parte $ie incrementare il nostro contatore $o. Se abbiamo raggiunto dove $ne $osono uguali, output $ie exit. Altrimenti continuiamo attraverso il forper trovare il prossimo primo e il processo si ripete.

APL (NARS), 39 caratteri, 78 byte

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

1π è il prossimo numero primo ...; test:

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

ma che già a 20 esce lo spazio di stack ... Invece questo sotto sembra ok anche se ha una lunghezza un po 'più lunga (61 caratteri)

∇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 

Aggiungi ++ , 36 byte

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

Provalo online!

Abbastanza inefficiente. Passa da un numero intero all'altro$i$ tale che $i \le 25x^2$ e filtra i composti e i numeri primi che non contengono $n$. Infine, prendiamo il$n$il valore degli interi rimanenti.

Japt -h , 15 13 11 byte

_j ©ZsèU}jU

Provalo