Năm 1946 Erdos và Copeland đã chứng minh rằng một số nhất định là một số bình thường , tức là các chữ số trong phần mở rộng thập phân của nó được phân bố đồng đều.

Người dùng sẽ nhập một chuỗi các chữ số và bạn sẽ tìm thấy số nguyên tố nhỏ nhất chứa chuỗi đó trong cơ sở 10.

Thí dụ:

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

Mã ngắn nhất trong byte thắng. Tôi biết rằng một số ngôn ngữ (mathicala, sage, pari-gp ...) đi kèm với các chức năng tích hợp liên quan đến các số nguyên tố. -50 byte nếu chương trình của bạn không dựa vào các chức năng đó. Đừng cố lừa dối điều này, nếu ngôn ngữ của bạn đã có lợi thế rất lớn thì đừng đòi tiền thưởng.

Biên tập

Theo một vài bình luận bên dưới, số nguyên tố nhỏ nhất chứa "03" là 3. Điều này có thực sự tạo ra sự khác biệt không? Điều duy nhất tôi có thể nghĩ là có lẽ số dễ xử lý hơn chuỗi.

Trong các trường hợp như "03", đầu ra ưa thích sẽ là 103. Tuy nhiên, tôi không coi đó là phần cơ bản của chương trình của mình, vì vậy bạn có thể bỏ qua bất kỳ số 0 đứng đầu nào nếu nó cấp cho bạn số byte thấp hơn.

Sân gôn, 33 32 byte = -18 điểm

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

Giải trình:

• 2{...}{)}/- bắt đầu bằng 2, trong khi điều gì đó là đúng, tăng đỉnh của ngăn xếp

• ;;x- loại bỏ các giá trị trung gian được thu thập bởi {}{}/và đầu vào, sau đó đặt giá trị cuối cùng được kiểm tra vào đó

• :x,2>- lưu trữ các giá trị như x, sau đó tạo ra một danh sách từ 2đểx-1

• {x\%!},!!- giữ những số xchia hết cho, sau đó ép thành boolean (không trống)
• x`3?)!- tra cứu đầu vào ở dạng văn bản của x( -1nếu không tìm thấy), tăng, phủ định.
• | - hoặc là

Chương trình Haskell, 97 ký tự = 47 điểm

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

Hàm Haskell, 75 ký tự = 25 điểm

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

loại plà (Integral a, Show a) => [Char] -> a. Nếu bạn cung cấp loại tích phân của riêng bạn, bạn có thể tra cứu bằng cách kết hợp với các giá trị đó. Tiêu chuẩn Integersử dụng ký hiệu thập phân dự kiến ​​cho số nguyên.

Không nhanh lắm. Phương trình bậc hai trong giá trị (không phải kích thước) của đầu ra.

phiên bản không có bản quyền:

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

thí dụ:

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 ký tự.

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

Toán học 58

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

Thời gian tương đối trên máy Mac của tôi (2,6 GHz i7 với bộ nhớ 8 GB).

Tìm số nguyên tố nhỏ nhất chứa "01".

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

{0,000217, 101}

Tìm số nguyên tố nhỏ nhất chứa "012345".

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

{5,021915, 10123456}

Tìm số nguyên tố nhỏ nhất chứa "0123456".

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

{87.056245, 201234563}

Hiền nhân , 72

Chạy trong dấu nhắc tương tác

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

Primes().unrank(i)đưa ra isố nguyên tố thứ, với số nguyên tố thứ 0 là 2.

R, 56chars -50 = 6

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

Lấy đầu vào là stdin. Gia tăng k cho đến khi k là số nguyên tố (được kiểm tra bằng cách tính tổng các trường hợp mà k mod 2 đến k là số 0, do đó FALSE từ 0 biến thành logic là FALSE) và chứa chuỗi được cung cấp dưới dạng đầu vào (được kiểm tra bằng một grep đơn giản, ở đây grepl vì chúng tôi muốn một logic như kết quả).

Sử dụng:

> 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

vỏ oneliner (coreutils): 45chars

Không xác định hàm ở đây ... chỉ là một oneliner có một đối số $nvà quét phạm vi số nguyên (thực tế thêm một chút để làm cho mã ngắn hơn). Phiên bản 55 ký tự:

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

Nó thậm chí không quá chậm. Đối với n=0123456nó trở lại 201234563trong 81.715s. Đó là nhanh chóng ấn tượng cho một đường ống dài với hai bộ xử lý chuỗi.

Xóa hai ký tự (xuống còn 53) và một ống, chúng ta có thể khiến nó chạy nhanh hơn:

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

Và cuối cùng, một số sedthuật sĩ đưa nó xuống còn 45 ký tự , mặc dù bản in rất xấu:

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

n = 000 -> 10007: 10007 (người dùng 0,017s)

n = 012345 -> 10123457: 10123457 (người dùng 7,11)

n = 0123456 -> 201234563: 201234563 (người dùng 66.8s)

J - 38 char -50 = -12 điểm

Thông thường trong J, bạn sẽ sử dụng các nội dung được tối ưu hóa dành riêng cho các số nguyên tố, vì vậy tôi sẽ không xin lỗi vì bất kỳ sự chậm chạp nào trong thực thi.

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

Giải thích:

• >:@]^:(...)^:_&2- Bắt đầu bằng 2, tăng cho đến khi (...)trả về false.
• (+.i.)@]- Lấy GCD của bộ đếm với mọi số nguyên nhỏ hơn nó. (Chúng tôi sử dụng quy ước GCD (X, 0) = X.)
• ]=*/@- Lấy sản phẩm của tất cả các số này, và kiểm tra sự bằng nhau cho bộ đếm. Nếu bộ đếm là số nguyên tố, danh sách là tất cả 1 giây, ngoại trừ GCD có 0; nếu không, sẽ có ít nhất một GCD lớn hơn 1, vì vậy sản phẩm sẽ lớn hơn bộ đếm.
• >./@(E.":)- Kiểm tra xem biểu diễn chuỗi của bộ đếm ( ":) có chứa chuỗi ( E.) tại bất kỳ điểm nào không. >./là hàm max và chúng tôi sử dụng nó bởi vì E.trả về một vectơ boolean với 1 bất cứ nơi nào chuỗi con bắt đầu trong chuỗi chính.
• *:- NAND logic kết quả với nhau. Điều này sẽ chỉ sai nếu cả hai đầu vào đều đúng, tức là nếu cả bộ đếm đều là số nguyên tố và chứa chuỗi con.

Sử dụng:

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

Đối với hậu thế, đây là phiên bản sử dụng nội dung chính (dài 30 ký tự, nhưng không có tiền thưởng):

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

1 p:] kiểm tra bộ đếm cho tính nguyên thủy, thay vì thủ thuật GCD.

Brachylog (v2), 3 byte trong mã hóa của Brachylog

ṗ≜s

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

Gửi hàm, lấy đầu vào từ đối số bên phải, đưa ra đầu ra bằng cách thay đổi đối số bên trái. (Điều này trái ngược với quy ước Brachylog thông thường; xem bài đăng meta này để thảo luận thêm. Hoán đổi các đối số theo thứ tự thông thường hơn sẽ tốn ba byte.) Liên kết TIO có trình bao bọc gọi hàm với quy ước gọi và in thích hợp kết quả.

Giải trình

ṗ≜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}

Đáng buồn thay, Brachylog rất phù hợp cho vấn đề này đến nỗi theo các quy tắc trong vấn đề, tôi thậm chí không thể cố gắng để nhận tiền thưởng (điều trớ trêu có nghĩa là nó không có khả năng chiến thắng).

Một trong những lý do tôi thích Brachylog rất nhiều là lập trình là sự giao tiếp giữa con người và máy tính, và do đó, một ngôn ngữ "hoàn hảo" sẽ cho phép bạn dịch trực tiếp đặc tả vấn đề sang tiếng Anh; các ý tưởng thông qua đó vấn đề đã được nêu, và thông qua đó chương trình được viết, sẽ giống nhau. Brachylog có thể đạt được lý tưởng này một cách đáng ngạc nhiên thường xuyên; câu hỏi ở đây là "tìm số nguyên tố nhỏ nhất chứa một chuỗi con nhất định" và tôi có thể kết hợp các khái niệm "nhỏ nhất, nguyên tố, chứa chuỗi con" theo đúng thứ tự và có một chương trình làm việc. Như vậy, Brachylog nói nhiều về bản chất của giao tiếp hơn là một ngôn ngữ mà bạn phải xác định rõ ràng một thuật toán để giải quyết vấn đề; đôi khi khi nói chuyện với người khác, chúng tôi cố gắng giải thích vấn đề bằng cách giải thích các bước bạn thực hiện để giải quyết vấn đề đó, nhưng điều đó rất hiếm. Vậy tại sao ngôn ngữ của chúng ta phải khác biệt?

JavaScript 83 byte = 33 điểm

Chơi gôn

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)

Ungolfed (một chút):

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 điểm

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

Ở dạng trích xuất với tên biến hợp lý:

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

Rust 0,9 136 byte = 86 điểm

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

Rất rõ ràng mặc dù cho sự nhỏ gọn. Quá nhiều không gian dành cho chuỗi tìm kiếm. :

Ở đây phiên bản không có khoảng trắng (136 char)

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

Thử nó

Gọn gàng , 37 byte

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

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

Perl 6 , 36 - 50 = -14 điểm

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

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

Xem xét $_%%one ^$_là chỉ có 2 byte nhỏ hơn lớn hơn .is-prime, tôi nghĩ rằng nó xứng đáng với tiền thưởng. Lần này ra cho trường hợp thử nghiệm cuối cùng.

Giải trình:

{                                  }  # 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 29 điểm

-1 byte nhờ sử dụng sáng tạo chỉ %sthay vì @ ASCIIstr

Trường hợp thử nghiệm "98765" chưa được xác nhận do thời gian thử nghiệm đã được xác nhận trong bao lâu " Xác nhận cho trường hợp thử nghiệm" 98765 "sau một vài giờ, nhưng với một cách tiếp cận tương tự sử dụng đánh giá ngắn mạch để tránh một số thử nghiệm nguyên thủy, nó hoạt động nhanh hơn nhiều. Ngoài ra, điều này có thể nhanh gấp 2 lần nếu chúng ta biết rằng "2" không phải là đầu vào (chúng ta có thể tránh kiểm tra các số chẵn cho tính nguyên thủy) bằng cách đặt i=3ban đầu và i+=2trong vòng lặp, không mất thêm chi phí byte.

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

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

Giải thích về whileđiều kiện ( (x in"%s"%i)*all(i%j for j in range(2,i))-1):

(x in"%s"%i): True/ 1nếu bộ đếm hiện tại chứa dãy số mong muốn trong đó; False/ 0nếu không.

all(i%j for j in range(2,i)): True/ 1nếu bộ đếm hiện tại luôn có phần dư khi chia cho bất kỳ số nguyên nào từ 2 (đã bao gồm) cho chính nó (loại trừ), tức là số nguyên tố; False/ 0nếu không.

Nhân *hai điều kiện với nhau và hoạt động như một andtoán tử - sản phẩm là True/ 1nếu và chỉ khi cả hai điều kiện là True/ 1.

Các -1hoạt động như một nottoán tử: False/ 0- 1 kết quả -1, được coi là đúng, trong khi True/ 1- 1 kết quả 0, được coi là sai. Do đó, vòng lặp tiếp tục trong khi số không chứa chuỗi số mong muốn hoặc không phải là số nguyên tố.

Thay thế *bằng andvà thêm dấu ngoặc đơn xung quanh mọi thứ trừ -1giải pháp tương đương nhanh hơn nhiều (dài hơn một chút).

Một giải pháp 76 byte - 50 = 26 điểm trong Python 2 được cung cấp bởi chỉ @ ASCII (sử dụng ``thay vì str(),

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

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

JavaScript, 65 - 50 = 15 điểm

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

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