이 질문은 n소수 를 찾는 데있어 비틀어 질 것 입니다.

도전

당신은 하나 개의 입력을하는 프로그램 작성해야 n및 출력 n진수 표현의 진수 표현이 포함되어 일 소수 nsubtring로합니다.

혼란 스러운가? 여기 몇 가지 예가 있어요.

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

이것은 code-golf 이므로 가장 낮은 바이트 수가 이깁니다.

혼란스러운 점이 있으면 의견을 남겨주세요.

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`

테스트 스위트 .

파이썬 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 인 경우 0k/n 을 산출 하고 f 를 재귀 적으로 호출합니다. m는 증분되고 (P)가 갱신되고, k는 증분 경우에만, m은 포함 된 소수 n이 .

후자의 결과를 가산함으로써 실현 p%m*(`n`in`m`)하는 케이 . m 이 소수 이면 윌슨 정리의 결과에 따라 1을p%m 리턴 하고 그렇지 않으면 0 을 리턴합니다 .

일단 케이 도달 N , 우리는 발견 Q 는 N ^번째 포함 프라임 N을 .

우리는 확인하는 동안 다음 호출에 있으므로 m = q + 1 입니다. k/n는 1 을 반환 하고 비트 연산자 -~는 모든 함수 호출에 대해 해당 숫자를 한 번 증가시킵니다. 이 걸리므 Q - 1 호출 F 증분 m 에서 2 행 Q + 1 에 최 호 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;}

언 골프 드 :

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

여기 사용해보십시오!

배쉬 + GNU 코어 유틸리티, 66 바이트

@Doorknob의 솔루션과 달리, 이것은 모든 GNU / Linux에 설치된 것만 필요합니다 :

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

펄 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

자바 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정수 입력 및 자세한 클래스 항목이 없습니다.

클로저, 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}}}}

input $n을 가져오고 무한 for()루프를 시작합니다. 반복 할 때마다 PowerShell 정규식 프라임 체커 (h / t to Martin)를 for감싸는 루프를 사용하여 루프 를 통해 매번 증분하여 프라임 생성기로 바꿉니다 . 예를 들어, 그냥 실행 하면 줄 바꿈으로 구분되어 출력 됩니다.$ifor(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}2, 3, 5, 7...

그런 다음 간단한 어딘가에 -like있는지 확인 하고 카운터를 늘리십시오 . 우리가 어디에 도달 한 경우 와 있는 동일한 출력을 하고 . 그렇지 않으면 다음 프라임을 찾기 위해 를 계속 진행 하고 프로세스가 반복됩니다.$n$i$o$n$o$iexitfor

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

시도 해봐