Це питання буде поворотом у знаходженні nпершого простого числа.

Виклик

Ви повинні написати програму, яка буде приймати один вхід n, і вивести nперше просте число, десяткове подання якого містить десятковий подання nяк підзарядку.

Плутати? Ось кілька прикладів.

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

Це код-гольф , тому виграє найменший байт.

Якщо щось бентежить, залиште коментар.

05AB1E , 8 байт

Код:

µN¹åNp*½

Пояснення:

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

Використовує кодування CP-1252 . Спробуйте в Інтернеті! .

Pyth - 11 байт

e.f&P_Z}`Q`

Тестовий сюїт .

Python 2, 67 65 62 байт

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)

Перевірте це на Ideone .

Як це працює

Ми використовуємо наслідки теореми Вілсона :

У всі часи змінна p дорівнює квадрату факторіалу m - 1 .

Якщо k <n , k/nвийде 0 і f викликається рекурсивно. m збільшується, p оновлюється, а k збільшується, якщо і лише тоді, коли m є простим, що містить n .

Останнє досягається додаванням результату p%m*(`n`in`m`)до k . За наслідками теореми Вілсона, якщо m просте, p%mповертається 1 , а якщо ні, то повертається 0 .

Як тільки k досягає n , ми знайшли q , n- ^е простим, що містить n .

Ми знаходимось у наступному дзвінку під час перевірки, тому m = q + 1 . k/nповерне 1 , і побітні оператори -~збільшать це число один раз для кожного виклику функції. Оскільки потрібно д - 1 виклики до е до приросту м від 2 до д + 1 , то найперше виклик е буде повертати 1 + д - 1 = д , як і передбачалося.

Баш, 27 байт

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

primes походить від bsdgames.

Приймає введення як аргумент командного рядка та виводить на STDOUT.

Желе , 13 байт

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

Спробуйте в Інтернеті!

Математика, 75 байт

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

Можливо, все-таки буде зіграно.

Ява, 194 180 173 171 112 байт

Код:

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

Безголовки:

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

Рубі, 62 61 байт

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

Потрібен -rprimeпрапор (+8 байт).

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

Юлія, 61 60 байт

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

Спробуйте в Інтернеті!

MATL , 18 байт

`@YqVGVXf?3M]NG<]&

Спробуйте в Інтернеті!

Пояснення

Це створює праймери для того, щоб використовувати do...whileцикл. Для кожного найвищого розряду, умова перевіряється (і розряд споживається). Якщо це задоволено, цей прайм знову натискається на стек. Кількість елементів у стеці використовується для підрахунку кількості кваліфікованих прайменів, які ми знайшли. Коли їх достатньо, відображається останній.

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

Пайк, 15 байт

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

Спробуйте тут!

Bash + GNU coreutils, 66 байт

На відміну від рішення @ Doorknob, для цього потрібні лише речі, встановлені в кожному GNU / Linux:

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

Perl 6 , 41 байт

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

Пояснення:

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

Тест:

#! /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 байт (повна програма)

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

Спробуйте в Інтернеті.

Пояснення:

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 байт (лямбда-функція)

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

Спробуйте в Інтернеті.

Те саме, що вище, але з nцілим числом і без детального класу.

Clojure, 118 байт

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

Просто отримує n-й елемент лінивої нескінченної послідовності чисел, які є простими і мають nїх рядкове представлення.

Ви можете спробувати тут: https://ideone.com/ioBJjt

Власне, 16 байт

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

Спробуйте в Інтернеті!

Пояснення:

;$╗`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 байт

Ун. Відсутність будь-якого вбудованого основного розрахунку / перевірки тут справді шкодить.

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

Бере введення $n, входить у нескінченну for()петлю. Кожну ітерацію ми використовуємо forцикл, обгорнутий навколо шашки PowerShell regex prime (від г / т до Мартіна), щоб перетворити його в основний генератор, збільшуючи $iщоразу через цикл. (Наприклад, просто запущений for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}результат2, 3, 5, 7... розділені новими рядками).

Потім проста -likeперевірка, щоб перевірити, чи $nє десь $i, і збільшить наш лічильник $o. Якщо ми досягли місця $nта $oрівності, виведіть $iі exit. В іншому випадку ми продовжуємо forпошук, щоб знайти наступний прайм, і процес повторюється.

APL (NARS), 39 символів, 78 байт

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

1π - наступне просте число ...; тест:

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

але це вже в 20 виходить з простору стеку ... Натомість це нижче здається нормальним, навіть якщо він довше тривав (61 символ)

∇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 

Додайте ++ , 36 байт

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

Спробуйте в Інтернеті!

$i$$i \le 25x^2$$n$$n$

Japt -h , 15 13 11 байт

_j ©ZsèU}jU

Спробуй це