这个问题将是找到n第素数的一个转折。

挑战

您必须编写一个程序，该程序将接受一个input 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是包含n的素数时，m递增，p更新，k递增。

后者是通过将结果取得p%m*(`n`in`m`)到ķ。根据威尔逊定理的推论，如果m为素数，则p%m返回1，否则返回0。

一旦k达到n，我们发现q，即包含n的^第n ^个素数。

我们在检查过程中处于下一个通话中，因此m = q + 1。k/n将返回1，按位运算符-~将为每个函数调用将该数字递增一次。由于需要f的q-1个调用才能使m从2递增到q + 1，因此，对f的最远调用将按预期返回1 + q-1 = q。

Bash，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=#]&

可能仍然可以打高尔夫球。

Java中，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);
    }
}

Ruby，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 

Pyke，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个字节（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;}

在线尝试。

与上面相同，但具有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质数检查器（对Martin为h / t）$i环绕的循环，通过在循环中每次递增将其转换为素数生成器。（例如，运行just 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

试试吧