คำถามนี้จะเป็นการบิดในการค้นหา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`

Test Suite

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เท่ากับตารางของปัจจัยของม. - 1

ถ้าk <n , k/nจะให้ผลผลิต0และฉเรียกว่าซ้ำ ม.จะเพิ่มขึ้น, Pมีการปรับปรุงและkจะเพิ่มขึ้นถ้าหากเมตรเป็นนายกที่มีn

หลังประสบความสำเร็จโดยการเพิ่มผลมาจากการp%m*(`n`in`m`)ที่จะk โดยพิสูจน์ทฤษฎีบทของวิลสันถ้าเมตรเป็นสำคัญp%mผลตอบแทนที่1และหากไม่ได้ก็จะส่งกลับ0

เมื่อkต้นน้ำnเราพบคิวที่n ^วันสำคัญที่มีn

เรากำลังอยู่ในการโทรไประหว่างการตรวจสอบเพื่อให้m = Q + 1 k/nจะส่งคืน1และผู้ประกอบการระดับบิต-~จะเพิ่มจำนวนนั้นหนึ่งครั้งสำหรับทุกการเรียกใช้ฟังก์ชัน เนื่องจากใช้การเรียกq - 1ถึงfเพื่อเพิ่ม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 Bytes

รหัส:

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

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 61ไบต์

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 ไบต์ (ฟังก์ชั่นแลมบ์ดา)

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อินพุตเป็นจำนวนเต็มและไม่มีข้อมูลคลาส verbose

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 regex (h / t ถึง Martin) เพื่อเปลี่ยนเป็นตัวสร้างหลักโดยการเพิ่ม$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$

Japtap -h , 15 13 11 ไบต์

_j ©ZsèU}jU

ลองมัน