Этот вопрос станет поворотом при поиске 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 , и побитовые операторы -~будут увеличивать это число один раз для каждого вызова функции. Так как для увеличения m от 2 до q + 1 требуется q - 1 вызовов f , самый внешний вызов f вернет 1 + q - 1 = q , как и предполагалось.

Баш, 27 байт

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

primes происходит от bsdgames.

Принимает ввод в качестве аргумента командной строки и выводит на STDOUT.

Желе , 13 байт

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

Попробуйте онлайн!

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

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

Рубин, 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 байт

Ooof. Отсутствие каких-либо встроенных простых вычислений / проверок действительно вредит здесь.

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

Принимает ввод $n, входит в бесконечный for()цикл. На каждой итерации мы используем forцикл, обернутый вокруг основной проверки регулярных выражений PowerShell (h / t для Мартина), чтобы превратить его в простой генератор путем увеличения$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$th значение оставшихся целых чисел.

Japt -h , 15 13 11 байт

_j ©ZsèU}jU

Попытайся