Pada tahun 1946, Erdos dan Copeland membuktikan bahwa angka tertentu adalah angka normal , yaitu digit dalam ekspansi desimalnya terdistribusi secara merata.

Pengguna akan memasukkan urutan digit dan Anda akan menemukan perdana terkecil yang berisi string itu di basis 10.

Contoh:

input   -> output
"10"    -> 101
"03"    -> 103
"222"   -> 2221
"98765" -> 987659

Kode terpendek dalam byte menang. Saya tahu bahwa beberapa bahasa (Mathematica, sage, pari-gp ...) hadir dengan fungsi bawaan yang terkait dengan bilangan prima. -50 byte jika program Anda tidak bergantung pada fungsi seperti itu. Jangan mencoba untuk menyontek hal ini, jika bahasa Anda sudah memiliki keuntungan besar, jangan mengklaim bonus.

Edit

Menurut beberapa komentar di bawah, prime terkecil yang mengandung "03" adalah 3. Apakah ini benar-benar membuat perbedaan? Satu-satunya hal yang dapat saya pikirkan adalah mungkin angka lebih mudah ditangani daripada string.

Dalam kasus seperti "03", output yang disukai adalah 103. Namun, saya tidak menganggapnya sebagai bagian mendasar dari program Anda, jadi Anda bebas untuk mengabaikan nol awal jika itu memberi Anda jumlah byte yang lebih rendah.

Golfcipt, 33 32 byte = -18 skor

2{:x,2>{x\%!},!!x`3$?)!|}{)}/;;x

Penjelasan:

• 2{...}{)}/- Dimulai dengan 2, sementara ada sesuatu yang benar, naikkan bagian atas tumpukan

• ;;x- buang nilai antara yang dikumpulkan oleh {}{}/dan input, lalu masukkan nilai terakhir yang diuji di sana

• :x,2>- simpan nilainya sebagai x, lalu buat daftar dari 2hinggax-1

• {x\%!},!!- pertahankan yang xhabis dibagi, lalu paksakan ke boolean (tidak kosong)
• x`3?)!- mencari input dalam bentuk teks x( -1jika tidak ditemukan), increment, negate.
• | - atau

Program Haskell, 97 karakter = 47 skor

main=getLine>>= \i->print$head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

Fungsi Haskell, 75 karakter = 25 skor

p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

jenis pyaitu (Integral a, Show a) => [Char] -> a. Jika Anda menyediakan tipe integral Anda sendiri, Anda dapat mencari dengan infix di representasi Anda sendiri dari nilai-nilai itu. Standar Integermenggunakan notasi desimal yang diharapkan untuk bilangan bulat.

Tidak terlalu cepat. Kuadratik dalam nilai (bukan ukuran) dari output.

versi tanpa ungolfed:

import Data.List
leastPrime infix = head $ filter prime' [2..]
  where prime' x  = all (\n-> x`mod`n /= 0) [2..x-1]
                 && i `isInfixOf` show x
main = print . leastPrime =<< getLine

contoh:

Prelude> let p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]
Prelude> p "0"
101
Prelude> p "00"
1009
Prelude> p "000" -- long pause
10007

Java - 175 karakter.

class s{public static void main(String[]a){int i,n=2,p;for(;;){p=1;for(i=3;i<n;i++)if(n%i==0)p=0;if((n==2||p>0)&&(""+n).indexOf(a[0])>=0) {System.out.println(n);break;}n++;}}}

Mathematica 58

(n=1;While[StringCases[ToString[p=Prime@n],#]=={},n++];p)&

Waktu Relatif pada Mac saya (2,6 GHz i7 dengan memori 8 GB).

Temukan prime terkecil yang mengandung "01".

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["01"]]

{0,000217, 101}

Temukan prime terkecil yang mengandung "012345".

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["012345"]]

{5.021915, 10123457}

Temukan prime terkecil yang mengandung "0123456".

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["0123456"]]

{87.056245, 201234563}

Sage , 72

Berjalan di prompt interaktif

a=raw_input()
i=0
p=2
while a not in str(p):i+=1;p=Primes().unrank(i)
p

Primes().unrank(i)memberikan ibilangan prima th, dengan bilangan prima 0 adalah 2.

R, 56chars -50 = 6

k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k

Ambil input sebagai stdin. Penambahan k hingga k adalah bilangan prima (diuji dengan menjumlahkan instance yang k mod 2 menjadi k nol, maka FALSE sejak 0 berubah menjadi logical FALSE) dan berisi string yang diberikan sebagai input (diuji dengan grep sederhana, di sini grepl karena kita menginginkan hasil yang logis).

Pemakaian:

> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "03"
2: 
Read 1 item
[1] 103
> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "003"
2: 
Read 1 item
[1] 2003

shell oneliner (coreutils): 45chars

Tidak mendefinisikan fungsi di sini ... hanya oneliner yang mengambil satu argumen $ndan memindai rentang integer (sebenarnya sedikit lebih banyak untuk membuat kode lebih pendek). Versi 55 karakter:

seq 5e9|grep $n|factor|awk '{if(NF==2)print $2}'|head -n1

Bahkan tidak terlalu lambat. Untuk n=0123456itu kembali 201234563di 81.715s. Itu sangat cepat untuk pipa panjang dengan dua prosesor string.

Menghapus dua karakter (hingga 53) dan satu pipa, kita bisa membuatnya berjalan lebih cepat:

seq 5e9|grep $n|factor|awk '{if(NF==2){print $2;exit}}'

Dan akhirnya, beberapa sedsihir membuatnya hingga 45 karakter , meskipun hasil cetakannya jelek:

seq 5e9|grep $n|factor|sed -n '/: \w*$/{p;q}'

n = 000 -> 10007: 10007 (pengguna 0,017s)

n = 012345 -> 10123457: 10123457 (pengguna 7.11s)

n = 0123456 -> 201234563: 201234563 (pengguna 66.8s)

J - 38 char -50 = -12 poin

Biasanya di J, Anda akan menggunakan builtin yang sangat optimal yang didedikasikan untuk bilangan prima, jadi saya tidak akan meminta maaf atas keterlambatan dalam eksekusi.

>:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2

Dijelaskan:

• >:@]^:(...)^:_&2- Mulai dengan 2, increment hingga (...)return false.
• (+.i.)@]- Ambil GCD penghitung dengan setiap bilangan bulat lebih kecil dari itu. (Kami menggunakan konvensi GCD (X, 0) = X.)
• ]=*/@- Ambil produk dari semua angka ini, dan uji kesetaraan ke konter. Jika penghitungnya prima, daftar adalah semua 1s, kecuali untuk GCD dengan 0; selain itu akan ada setidaknya satu GCD yang lebih besar dari 1, sehingga produk akan lebih besar dari penghitung.
• >./@(E.":)- Uji apakah representasi string dari penghitung ( ":) berisi string ( E.) di titik mana pun. >./adalah fungsi max, dan kami menggunakannya karena E.mengembalikan vektor boolean dengan 1 di mana substring dimulai pada string utama.
• *:- NAND logis hasil bersama. Ini akan menjadi salah hanya jika kedua input benar, yaitu jika penghitung keduanya prima dan berisi substring.

Pemakaian:

   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '03'
103
   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '713'
2713

Untuk anak cucu, inilah versi menggunakan prime builtin (panjang 30 char, tapi tidak ada bonus):

>:@]^:(>./@(E.":)*:1 p:])^:_&2

1 p:] menguji penghitung untuk keunggulan, bukan trik GCD.

Brachylog (v2), 3 byte dalam penyandian Brachylog

ṗ≜s

Cobalah online!

Pengajuan fungsi, mengambil input dari argumen sebelah kanan, memberikan output dengan memutasi argumen sebelah kiri. (Ini kebalikan dari konvensi Brachylog normal; lihat meta post ini untuk diskusi lebih lanjut. Menukar argumen ke dalam urutan yang lebih biasa akan menelan biaya tiga byte.) TIO link memiliki pembungkus yang memanggil fungsi dengan konvensi dan cetakan yang sesuai panggilan. hasil.

Penjelasan

ṗ≜s
 ≜   Find the integer closest to zero
ṗ      which is prime {implicit: and output it via the left argument}
  s    and which is a substring of the {right argument}

Sayangnya, Brachylog sangat tepat untuk masalah ini sehingga menurut aturan dalam masalah, saya bahkan tidak bisa mencoba untuk mendapatkan bonus (yang ironisnya berarti itu tidak mampu menang).

Salah satu alasan saya sangat menyukai Brachylog adalah bahwa pemrograman adalah komunikasi antara manusia dan komputer, dan dengan demikian bahasa "sempurna" akan membiarkan Anda menerjemahkan spesifikasi masalah ke dalam bahasa Inggris secara langsung; ide-ide yang melaluinya masalah dinyatakan, dan melalui mana program ditulis, akan sama. Brachylog dapat mencapai ideal ini secara mengejutkan; pertanyaannya di sini adalah "menemukan prime terkecil yang mengandung substring yang diberikan", dan saya benar-benar dapat merangkai konsep "terkecil, prime, mengandung substring" dalam urutan yang benar dan memiliki program kerja. Dengan demikian, Brachylog mengatakan lebih banyak tentang sifat komunikasi daripada bahasa di mana Anda harus secara eksplisit menentukan algoritma untuk memecahkan masalah; terkadang ketika berbicara dengan manusia lain, kami mencoba menjelaskan masalah dengan menjelaskan langkah-langkah yang akan Anda ambil untuk menyelesaikannya, tetapi itu jarang terjadi. Jadi mengapa bahasa kita harus berbeda?

JavaScript 83 byte = 33 skor

Golf:

for(s=prompt(n=x=0);!n;x++)for(n=(''+x).match(s)?2:0;n&&n<x;n=x%n?n+1:0);alert(x-1)

Tidak disatukan (sedikit):

s=prompt() // get the input
n = 0
for(x=0;!n;x++) // stop when n is non-zero
    if ((''+x).match(s)) { // if x matches the pattern, check if x is prime
        for(n=2;n&&n<x;)
            n = (x%n == 0) ? 0 : n+1; // if x%n is zero, x is not prime so set n=0
        // if n is non-zero here, x is prime and matches the pattern
    }
alert(x-1)

Javascript (Node.JS) - 93 byte = 43 poin

l:for(i=x=process.argv[2];j=i;i++){while(--j>2)if(!(i%j*(""+i).match(x)))continue l
throw i}

Dalam bentuk yang diekstraksi dengan nama variabel yang masuk akal:

outerLoop:for (currentTry=inputNumber=process.argv[2]; primeIterator=currentTry; currentTry++ ) {
    while (--primeIterator > 2) 
        if(!(currentTry % primeIterator * (""+currentTry).match(inputNumber)))
            continue outerLoop;
    throw i
}

Karat 0,9 136 byte = 86 poin

fn main(){
   let mut n:u32=2;
   while n.to_str().find_str(std::os::args()[1])==None ||
         range(2,n).find(|&x|n%x==0)!=None {
      n=n+1;
   }
   print!("{}",n);
}

Sangat eksplisit meski untuk kekompakan. Terlalu banyak ruang yang dihabiskan untuk mencari string. :(

Di sini versi tanpa spasi (136 karakter)

fn main(){let mut n:u32=2;while n.to_str().find_str(std::os::args()[1])==None||range(2,n).find(|&x|n%x==0)!=None{n=n+1;}print!("{}",n);}

Japt, 10 byte

_j *ZsøU}a

Cobalah

Tidy , 37 byte

{s:s&{s,p:s in"".p}from primes|first}

Cobalah online!

Perl 6 , 36 - 50 = -14 poin

{$^a;first {/$a/&&$_%%one ^$_},2..*}

Cobalah online!

Mengingat $_%%one ^$_hanya 2 byte lebih kecil dari .is-prime, saya pikir itu layak untuk bonus. Ini habis untuk test case terakhir.

Penjelasan:

{                                  }  # Anonymous code block
 $^a;                                 # Assign input to $a
     first                    ,2..*   # Find the first number
           {                 }        # Which
            /$a/                        # Contains the input
                &&                      # And
                  $_%%one ^$_           # Is prime

Python 3 , 80 79 byte - 50 = 30 skor 29

-1 byte berkat penggunaan kreatif @ ASCII-only %s alih-alihstr

Test case "98765" belum dikonfirmasi karena berapa lama waktu yang dibutuhkan untuk menguji Confirmed for test case "98765" setelah beberapa jam, tetapi dengan pendekatan yang serupa yang menggunakan evaluasi hubung singkat untuk menghindari beberapa pengujian purba bekerja. lebih cepat. Atau, ini bisa ~ 2x lebih cepat jika kita tahu bahwa "2" bukan input (kita dapat menghindari memeriksa angka genap untuk primality) dengan menetapkan i=3awalnya dan i+=2dalam loop, tanpa biaya byte tambahan.

def f(x):
 i=2
 while(x in"%s"%i)*all(i%j for j in range(2,i))-1:i+=1
 return i

Cobalah online!

Penjelasan whilekondisi ( (x in"%s"%i)*all(i%j for j in range(2,i))-1):

(x in"%s"%i): True/ 1jika penghitung saat ini berisi urutan angka yang diinginkan di dalamnya;False/ 0sebaliknya.

all(i%j for j in range(2,i)): True/ 1jika penghitung saat ini selalu memiliki sisa ketika dibagi oleh sembarang bilangan bulat dari 2 (inklusif) ke dirinya sendiri (eksklusif), yaitu perdana; False/0 sebaliknya.

The *mengalikan dua kondisi bersama-sama, dan bertindak sebagai andoperator yang - produk tersebut True/ 1jika dan hanya jika kedua kondisi True/ 1.

The -1bertindak sebagai notOperator: False/ 0- 1 hasil dalam -1, yang dianggap benar, sedangkan True/1 - 1 hasil dalam 0, yang dianggap palsu. Dengan demikian, loop berlanjut sementara nomor tidak mengandung urutan angka yang diinginkan atau tidak prima.

Ganti *dengan anddan tambahkan tanda kurung di sekitar segala sesuatu selain-1 untuk solusi yang jauh lebih cepat, setara (yang sedikit lebih lama).

Sebuah 76 byte - 50 = 26 skor solusi dengan Python 2 diberikan oleh @ ASCII-satunya (menggunakan ``bukan str(),

def f(x):
 i=2
 while(x in`i`)*all(i%j for j in range(2,i))-1:i+=1
 return i

Cobalah online!

JavaScript, 65 - 50 = 15 poin

x=>(f=y=>(''+y).match(x)&&(p=n=>--n<2||y%n&&p(n))(y)?y:f(y+1))(x)

Cobalah online!