Bu soru, nasal sayıyı bulmak için bir büküm olacaktır .

Meydan okuma

Tek bir girişi alacak bir programı yazmak gerekir nve çıkış nondalık gösterim ondalık temsili içeren inci asal sayı nbir subtring olarak.

Şaşkın? İşte bazı örnekler.

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

Bu kod golf , yani en düşük bayt sayısı kazanır.

Bir şey kafa karıştırıcıysa, lütfen yorum bırakın.

05AB1E , 8 bayt

Kod:

µN¹åNp*½

Açıklama:

µ          # 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 kodlamasını kullanır . Çevrimiçi deneyin! .

Pyth - 11 bayt

e.f&P_Z}`Q`

Test Takımı .

Python 2, 67 65 62 bayt

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)

İdeone üzerinde test et .

Nasıl çalışır

Wilson teoreminin bir sonucunu kullanıyoruz :

Her zaman, p değişkeni m - 1 faktörünün karesine eşittir .

Eğer k <n , k/nverecektir 0 ve f yinelemeli olarak adlandırılır. m artırılır, p güncellenir ve k artırılır ve yalnızca m , n'yi içeren bir üsse .

İkincisi sonucunu eklenerek sağlanır p%m*(`n`in`m`)için k . Wilson'ın teoremin doğal sonucu olarak, eğer m , asal p%mdöner 1 , ve değilse, o döner 0 .

Bir kez k ulaşır n , bulduğumuz q , n ^inci içeren asal n .

Kontrol sırasında bir sonraki aramadayız, bu yüzden m = q + 1 . 1k/n döndürür ve bitli operatörler , her işlev çağrısı için bu sayıyı bir kez artırır. Tek gereken yana q 1 - çağrı f artış için m den 2 için q + 1 , en dıştaki çağrı f döndürür 1 + q - 1 = q , istendiği gibi.-~

Bash, 27 bayt

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

primes bsdgames'ten geliyor.

Bir komut satırı argümanı olarak girdi alır ve STDOUT'da çıkar.

Jöle , 13 bayt

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

Çevrimiçi deneyin!

Mathematica, 75 bayt

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

Hala golf oynayabilir.

Java, 194 180 173 171 112 Bayt

Kod:

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 bayt

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

-rprimeBayrağı gerektirir (+8 bayt).

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

f(n,k=0,m=1)=k<n&&f(n,k+isprime(m)contains("$m","$n"),m+1)+1

Çevrimiçi deneyin!

MATL , 18 bayt

`@YqVGVXf?3M]NG<]&

Çevrimiçi deneyin!

açıklama

Bu, bir do...whiledöngü kullanarak sıralar oluşturur . Her asal için durum test edilir (ve asal tüketilir). Memnun bırakılırsa, bu astar yığına tekrar itilir. Yığındaki öğelerin sayısı, kaç tane uygun primer bulduğumun sayısı olarak kullanılır. Bunlardan yeterli olduğunda, sonuncusu görüntülenir.

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

Q.fD_P.I`Q`R{(e

Burada dene!

Bash + GNU coreutils, 66 Bayt

@ Doorknob'un çözümünün aksine, bu sadece her GNU / Linux'ta kurulu olan şeylere ihtiyaç duyar:

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

Perl 6 , 41 bayt

->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

Açıklama:

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

Ölçek:

#! /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 bayt (tam program)

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

Çevrimiçi deneyin.

Açıklama:

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 bayt (lambda işlevi)

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

Çevrimiçi deneyin.

Yukarıdakiyle aynı, ancak ntamsayı girişli ve ayrıntılı sınıf öğeleri olmadan.

Clojure, 118 bayt

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

Sadece asal olan ve nsicim gösterimlerinde sahip olan tembel sonsuz sayı dizisinin nth elemanını alır .

Burada deneyebilirsiniz: https://ideone.com/ioBJjt

Aslında, 16 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Ooof. Herhangi bir çeşit yerleşik asal hesaplama / kontrol eksikliği burada gerçekten acıtıyor.

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

Girdi alır $n, sonsuz bir for()döngüye girer . Her yinelemede, PowerShell regex prime checker'ı (h / t Martin'e) foretrafına sarılmış bir döngü kullanarak her seferinde döngüyü artırarak bir primer üretecine dönüştürürüz . (Örneğin, sadece çalışan çıkış yeni satırlarla ayrılmış olarak çıkacaktır ).$ifor(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}2, 3, 5, 7...

Sonra bir yerde -likeolup olmadığını görmek için basit bir kontrol yapın ve sayacımızı artırın . Nereye ve eşit olana ulaştıysak , çıktı ve . Aksi halde , bir sonraki üssü bulmak için ilerlemeye devam ederiz ve süreç tekrar eder.$n$i$o$n$o$iexitfor

APL (NARS), 39 karakter, 78 bayt

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

1π sonraki asal sayıdır ...; Ölçek:

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

ama bu 20'de zaten yığın alanından dışarı çıkıyor ... Bunun yerine, biraz daha uzun olsa bile, bu durum tamam görünüyor (61 karakter)

∇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 bayt ekle

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

Çevrimiçi deneyin!

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

Japt -h , 15 13 11 bayt

_j ©ZsèU}jU

Dene