Câu hỏi này sẽ là một bước ngoặt trong việc tìm nsố nguyên tố thứ.

Thử thách

Bạn phải viết một chương trình sẽ lấy một đầu vào nvà xuất ra nsố nguyên tố thứ có biểu diễn thập phân chứa biểu diễn thập phân ndưới dạng một phép trừ.

Bối rối? Dưới đây là một số ví dụ.

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

Đây là mã golf , vì vậy số byte thấp nhất sẽ thắng.

Nếu có gì đó khó hiểu, xin vui lòng để lại nhận xét.

05AB1E , 8 byte

Mã số:

µN¹åNp*½

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Pyth - 11 byte

e.f&P_Z}`Q`

Phòng thử nghiệm .

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)

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Chúng tôi sử dụng một hệ quả của định lý Wilson :

Tại mọi thời điểm, biến p đều bằng bình phương của giai thừa của m - 1 .

Nếu k <n , k/nsẽ mang lại 0 và f được gọi là đệ quy. m được tăng lên, p được cập nhật và k được tăng lên khi và chỉ khi m là một số nguyên tố có chứa n .

Loại thứ hai được thực hiện bằng cách thêm các kết quả của p%m*(`n`in`m`)để k . Theo hệ quả của định lý Wilson nếu m là số nguyên tố, p%mtrả về 1 và nếu không, nó trả về 0 .

Khi k đạt n , chúng tôi thấy q , các n ^th thủ có chứa n .

Chúng tôi đang trong cuộc gọi tiếp theo trong quá trình kiểm tra, vì vậy m = q + 1 . k/nsẽ trả về 1 và các toán tử bitwise -~sẽ tăng số đó một lần cho mỗi lần gọi hàm. Vì phải mất q - 1 cuộc gọi đến f để tăng m từ 2 lên q + 1 , cuộc gọi ngoài cùng đến f sẽ trả về 1 + q - 1 = q , như dự định.

Bash, 27 byte

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

primes đến từ bsdgames.

Lấy đầu vào làm đối số dòng lệnh và xuất ra trên STDOUT.

Thạch , 13 byte

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

Hãy thử trực tuyến!

Toán học, 75 byte

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

Vẫn có thể chơi được.

Java, 194 180 173 171 112 byte

Mã số:

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

Ung dung:

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 byte

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

Yêu cầu -rprimecờ (+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

Hãy thử trực tuyến!

MATL , 18 byte

`@YqVGVXf?3M]NG<]&

Hãy thử trực tuyến!

Giải trình

Điều này tạo ra các số nguyên tố theo thứ tự bằng cách sử dụng một do...whilevòng lặp. Đối với mỗi nguyên tố, điều kiện được kiểm tra (và nguyên tố được tiêu thụ). Nếu hài lòng, số nguyên tố đó được đẩy lên ngăn xếp một lần nữa. Số lượng phần tử trong ngăn xếp được sử dụng như là số lượng các số nguyên tố đủ điều kiện chúng tôi đã tìm thấy. Khi có đủ chúng, cái cuối cùng được hiển thị.

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

Hãy thử nó ở đây!

Bash + GNU coreutils, 66 byte

Trái ngược với giải pháp của @ Doorknob, giải pháp này chỉ cần những thứ được cài đặt trên mọi 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]}

Giải trình:

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

Kiểm tra:

#! /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 (chương trình đầy đủ)

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

Hãy thử trực tuyến.

Giải trình:

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 (hàm 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;}

Hãy thử trực tuyến.

Tương tự như trên, nhưng với nđầu vào là số nguyên và không có nội dung lớp dài.

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

Chỉ cần lấy phần tử thứ n của chuỗi số vô hạn lười biếng là số nguyên tố và có ntrong biểu diễn chuỗi của chúng.

Bạn có thể dùng thử tại đây: https://ideone.com/ioBJjt

Trên thực tế, 16 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Ôi. Việc thiếu bất kỳ loại tính toán / kiểm tra chính tích hợp nào thực sự gây tổn thương ở đây.

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

Đưa đầu vào $n, đi vào một for()vòng lặp vô hạn . Mỗi lần lặp, chúng tôi sử dụng một forvòng lặp bao quanh trình kiểm tra chính regex PowerShell (h / t cho Martin) để biến nó thành một trình tạo số nguyên tố bằng cách tăng $imỗi lần qua vòng lặp. (Ví dụ, chỉ chạy for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}sẽ được 2, 3, 5, 7...phân tách bằng dòng mới).

Sau đó, -likekiểm tra đơn giản để xem $ncó ở đâu đó không $i, và tăng bộ đếm của chúng tôi $o. Nếu chúng ta đạt đến nơi $nvà $obằng nhau, đầu ra $ivà exit. Nếu không, chúng tôi tiếp tục thông qua forđể tìm số nguyên tố tiếp theo và quá trình lặp lại.

APL (NARS), 39 ký tự, 78 byte

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

1π là số nguyên tố tiếp theo ...; kiểm tra:

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

nhưng điều đó đã ở mức 20 đi ra ngoài không gian ngăn xếp ... Thay vào đó, điều này có vẻ ổn ngay cả khi có chiều dài hơn một chút (61 ký tự)

∇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 

Thêm ++ , 36 byte

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

Hãy thử trực tuyến!

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

Japt -h , 15 13 11 byte

_j ©ZsèU}jU

Thử nó