ในปีพ. ศ. 2489 แอร์ดิชและโคปแลนด์ได้พิสูจน์ว่าจำนวนหนึ่งเป็นจำนวนปกตินั่นคือตัวเลขในการขยายทศนิยมจะกระจายอย่างสม่ำเสมอ

ผู้ใช้จะป้อนลำดับของตัวเลขและคุณจะพบจำนวนที่เล็กที่สุดที่มีสตริงนั้นในฐาน 10

ตัวอย่าง:

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

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ ฉันรู้ว่าบางภาษา (mathematica, sage, pari-gp ... ) มาพร้อมกับฟังก์ชั่นในตัวที่เกี่ยวข้องกับช่วงเวลา -50 ไบต์หากโปรแกรมของคุณไม่ใช้ฟังก์ชันดังกล่าว โปรดอย่าพยายามโกงในเรื่องนี้หากภาษาของคุณมีข้อได้เปรียบอย่างมากอยู่แล้วอย่าอ้างสิทธิ์รับโบนัส

แก้ไข

จากความคิดเห็นบางประการด้านล่างนายกที่เล็กที่สุดที่มี "03" คือ 3 สิ่งนี้สร้างความแตกต่างได้จริงหรือ สิ่งเดียวที่ฉันคิดได้ก็คือตัวเลขอาจจัดการได้ง่ายกว่าสตริง

ในกรณีเช่น "03" ผลลัพธ์ที่ต้องการจะเป็น 103 อย่างไรก็ตามฉันไม่คิดว่ามันจะเป็นส่วนพื้นฐานของโปรแกรมของคุณดังนั้นคุณสามารถเพิกเฉยต่อศูนย์นำหน้าหากคุณให้จำนวนไบต์ที่ต่ำกว่า

Golfscipt, 33 32 ไบต์ = -18 คะแนน

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

คำอธิบาย:

• 2{...}{)}/- เริ่มต้นด้วย2บางสิ่งที่เป็นจริงให้เพิ่มด้านบนสุดของสแต็ก

• ;;x- ทิ้งค่ากลางที่รวบรวมโดย{}{}/และอินพุตจากนั้นใส่ค่าสุดท้ายที่ทดสอบที่นั่น

• :x,2>- เก็บค่าเป็นxจากนั้นสร้างรายการจาก2ถึงx-1

• {x\%!},!!- เก็บค่าที่xหารด้วยแล้วบีบบังคับเป็นบูลีน (ไม่ว่าง)
• x`3?)!- ค้นหาอินพุตในรูปแบบข้อความของx( -1หากไม่พบ), เพิ่ม, คัดค้าน
• | - หรือ

โปรแกรม Haskell, 97 ตัวอักษร = 47 คะแนน

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

ฟังก์ชัน Haskell, 75 ตัวอักษร = 25 คะแนน

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

ประเภทของการมีp (Integral a, Show a) => [Char] -> aหากคุณระบุประเภทอินทิกรัลของคุณเองคุณสามารถค้นหาโดยใส่ในการแสดงค่าเหล่านั้นของคุณเอง มาตรฐานIntegerใช้รูปแบบเลขฐานสิบที่คาดหวังสำหรับจำนวนเต็ม

ไม่เร็วมาก กำลังสองในค่า (ไม่ใช่ขนาด) ของเอาต์พุต

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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

ตัวอย่าง:

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 ตัวอักษร

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

การตั้งเวลาแบบสัมพัทธ์บน Mac ของฉัน (2.6 GHz i7 ที่มีหน่วยความจำ 8 GB)

ค้นหานายกที่เล็กที่สุดที่มี "01"

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

{0.000217, 101}

ค้นหานายกที่เล็กที่สุดที่มี "012345"

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

{5.021915, 10123457}

ค้นหานายกที่เล็กที่สุดที่มี "0123456"

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

{87.056245, 201234563}

Sage , 72

ทำงานในพรอมต์แบบโต้ตอบ

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

Primes().unrank(i)ให้iหมายเลขเฉพาะที่ th โดยที่ 0 สำคัญอยู่ที่ 2

R, 56chars -50 = 6

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

ใช้อินพุตเป็น stdin เพิ่มค่า k จนกระทั่ง k เป็นค่าเฉพาะ (ทดสอบโดยการรวมอินสแตนซ์ที่ k mod 2 ถึง k เป็นเลขศูนย์ดังนั้น FALSE ตั้งแต่ 0 กลายเป็นตรรกะเป็น FALSE) และมีสตริงที่ให้เป็นอินพุต (ทดสอบด้วย grep อย่างง่ายนี่คือ grepl เนื่องจากเราต้องการผลเป็นตรรกะ)

การใช้งาน:

> 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

ไม่ได้กำหนดฟังก์ชั่นที่นี่ ... เพียงแค่ oneliner ที่ใช้เวลาหนึ่งอาร์กิวเมนต์ใน$nและสแกนช่วงจำนวนเต็ม (จริง ๆ แล้วอีกเล็กน้อยเพื่อให้รหัสสั้นลง) เวอร์ชั่นตัวละคร 55:

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

มันไม่ได้ช้าเกินไป สำหรับn=0123456มันกลับใน201234563 81.715sนั่นเป็นเรื่องที่รวดเร็วอย่างน่าประทับใจสำหรับไพพ์ไลน์แบบยาวที่มีตัวประมวลผลสตริงสองตัว

การลบอักขระสองตัว (ลดลงเหลือ 53) และหนึ่งไพพ์เราสามารถทำให้มันทำงานได้เร็วขึ้น:

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

และในที่สุดตัวsedช่วยสร้างก็มีความยาวไม่เกิน45 ตัวอักษรแม้ว่าผลงานพิมพ์น่าเกลียด:

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

n = 000 -> 10007: 1,0007 (ผู้ใช้ 0.017 วินาที)

n = 012345 -> 10123457: 10123457 (ผู้ใช้ 7.11 วินาที)

n = 0123456 -> 201234563: 201234563 (ผู้ใช้ 66.8 วินาที)

J - 38 ถ่าน -50 = -12 แต้ม

โดยปกติใน J คุณจะต้องใช้บิวด์อินที่ได้รับการปรับให้เหมาะสมที่สุดเพื่อช่วงเวลาดังนั้นฉันจะไม่ขอโทษสำหรับความเชื่องช้าในการดำเนินการ

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

อธิบาย:

• >:@]^:(...)^:_&2- เริ่มต้นด้วย 2 เพิ่มขึ้นจน(...)กลับเท็จ
• (+.i.)@]- นำ GCD ของตัวนับไปด้วยจำนวนเต็มที่น้อยกว่าทุกตัว (เราใช้การประชุม GCD (X, 0) = X. )
• ]=*/@- นำผลคูณของตัวเลขเหล่านี้มาทดสอบความเท่าเทียมกันที่เคาน์เตอร์ หากตัวนับเป็นจำนวนเฉพาะรายการทั้งหมด 1 วินาทียกเว้น GCD ที่มี 0 มิฉะนั้นจะมีอย่างน้อยหนึ่ง GCD ที่มากกว่า 1 ดังนั้นผลิตภัณฑ์จะมากกว่าตัวนับ
• >./@(E.":)- ทดสอบว่าการแทนสตริงของตัวนับ ( ":) มีสตริง ( E.) ที่จุดใด >./เป็นฟังก์ชั่นสูงสุดและเราใช้มันเพราะE.คืนค่าเวกเตอร์บูลีนด้วย 1 ทุกครั้งที่สตริงย่อยเริ่มต้นในสตริงหลัก
• *:- ตรรกะ NAND ผลลัพธ์ร่วมกัน สิ่งนี้จะเป็นเท็จหากอินพุตทั้งสองเป็นจริงเช่นถ้าตัวนับทั้งคู่เป็นไพร์มและมีซับสตริง

การใช้งาน:

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

สำหรับรุ่นหลังนี่เป็นรุ่นที่ใช้ไพร์มบิวอิน (ยาว 30 ถ่าน แต่ไม่มีโบนัส):

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

1 p:] ทดสอบตัวนับสำหรับไพรเมอร์แทนการหลอก GCD

Brachylog (v2), 3 ไบต์ในการเข้ารหัสของ Brachylog

ṗ≜s

ลองออนไลน์!

การส่งฟังก์ชั่นรับอินพุตจากอาร์กิวเมนต์ขวามือให้เอาต์พุตโดยการกลายพันธุ์อาร์กิวเมนต์ซ้ายมือ (นี่คือสิ่งที่ตรงกันข้ามกับการประชุม Brachylog ปกติดูโพสต์ meta นี้สำหรับการสนทนาเพิ่มเติมการแลกเปลี่ยนข้อโต้แย้งในคำสั่งปกติจะมีราคาสามไบต์) ลิงค์ TIO มี wrapper ซึ่งเรียกฟังก์ชันที่มีหลักการเรียกที่เหมาะสมและพิมพ์ ผลลัพธ์.

คำอธิบาย

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

น่าเศร้าที่ Brachylog เหมาะสมกับปัญหานี้มากว่าตามกฎของปัญหาฉันไม่สามารถลองรับโบนัสได้

หนึ่งในเหตุผลที่ฉันชอบ Brachylog มากคือการเขียนโปรแกรมเป็นการสื่อสารระหว่างมนุษย์และคอมพิวเตอร์และภาษาที่ "สมบูรณ์แบบ" จะช่วยให้คุณสามารถแปลสเปคปัญหาเป็นภาษาอังกฤษได้โดยตรง ความคิดที่ผ่านปัญหาได้ถูกระบุและการเขียนโปรแกรมจะเหมือนกัน Brachylog สามารถทำสิ่งนี้ได้อย่างน่าประหลาดใจบ่อยครั้ง คำถามที่นี่คือ "ค้นหานายกที่เล็กที่สุดที่มีสตริงย่อยที่กำหนด" และฉันสามารถสตริงรวมกันแนวคิดของ "เล็กที่สุดนายกประกอบด้วยซับสตริง" ในลำดับที่ถูกต้องและมีโปรแกรมทำงาน เช่นนี้ Brachylog พูดถึงลักษณะของการสื่อสารมากกว่าภาษาที่คุณต้องระบุอัลกอริทึมสำหรับการแก้ปัญหาอย่างชัดเจน บางครั้งเมื่อพูดคุยกับมนุษย์คนอื่น เราพยายามอธิบายปัญหาด้วยการอธิบายขั้นตอนที่คุณต้องดำเนินการเพื่อแก้ไขปัญหา แต่หายาก แล้วทำไมภาษาของเราถึงแตกต่างกัน?

JavaScript 83 ไบต์ = 33 คะแนน

แข็งแรงเล่นกอล์ฟ:

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 (เล็กน้อย):

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 ไบต์ = 43 คะแนน

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

ในรูปแบบที่แยกด้วยชื่อตัวแปรที่สมเหตุสมผล:

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

สนิม 0.9 136 ไบต์ = 86 คะแนน

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

ชัดเจนมากแม้จะมีขนาดกะทัดรัด มีการใช้พื้นที่มากเกินไปในการค้นหาสตริง :(

ที่นี่รุ่นที่ไม่มีช่องว่าง (136 ถ่าน)

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

_j *ZsøU}a

ลองมัน

เรียบร้อย 37 ไบต์

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

ลองออนไลน์!

Perl 6 , 36 - 50 = -14 คะแนน

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

ลองออนไลน์!

การพิจารณา$_%%one ^$_มีขนาดเล็กกว่าขนาด2 ไบต์เท่านั้น.is-primeฉันคิดว่ามันคุ้มค่ากับโบนัส หมดเวลาสำหรับกรณีทดสอบครั้งสุดท้าย

คำอธิบาย:

{                                  }  # 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 bytes - 50 = 30 29 คะแนน

-1 ไบต์ขอบคุณการใช้งานโฆษณาอย่างเดียวของ @ ASCII %sแทนstr

กรณีทดสอบ "98765" ยังไม่ได้รับการยืนยันเนื่องจากใช้เวลานานเท่าใดในการทดสอบยืนยันสำหรับกรณีทดสอบ "98765" หลังจากผ่านไปสองชั่วโมง แต่ด้วยวิธีการที่คล้ายกันที่ใช้การประเมินการลัดวงจรเพื่อหลีกเลี่ยงการทดสอบแบบดั้งเดิม เร็วกว่ามาก อีกวิธีหนึ่งอาจเร็วถึง 2x เท่านี้หากเรารู้ว่า "2" ไม่ใช่อินพุต (เราสามารถหลีกเลี่ยงการตรวจสอบตัวเลขแม้แต่ค่าดั้งเดิม) โดยการตั้งค่าi=3เริ่มต้นและi+=2ในลูปโดยไม่มีค่าใช้จ่ายเพิ่มเติม

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

ลองออนไลน์!

คำอธิบายของwhileเงื่อนไข ((x in"%s"%i)*all(i%j for j in range(2,i))-1 ):

(x in"%s"%i): True/ 1ถ้าตัวนับปัจจุบันประกอบด้วยลำดับตัวเลขที่ต้องการ False/0มิฉะนั้น

all(i%j for j in range(2,i)): True/ 1ถ้าตัวนับปัจจุบันมีส่วนที่เหลือเสมอเมื่อหารด้วยจำนวนเต็มใด ๆ จาก 2 (รวม) ถึงตัวเอง (พิเศษ) นั่นคือสำคัญ; False/0มิฉะนั้น

*คูณสองเงื่อนไขร่วมกันและทำหน้าที่เป็นandผู้ประกอบการ - ผลิตภัณฑ์ที่เป็นTrue/ 1และถ้าหากเงื่อนไขทั้งสองTrue/1 /

การ-1กระทำในฐานะnotโอเปอเรเตอร์: False/ 0- 1 ผลลัพธ์-1ซึ่งถือว่าเป็นจริงในขณะที่True/ 1- 1 ผลลัพธ์0จะถือว่าเป็นเท็จ ดังนั้นการวนซ้ำจะดำเนินต่อไปในขณะที่ตัวเลขอาจไม่มีลำดับหมายเลขที่ต้องการหรือไม่ได้เป็นจำนวนเฉพาะ

แทนที่*ด้วยandและเพิ่มวงเล็บรอบ ๆ ทุกสิ่งยกเว้น-1โซลูชันที่เร็วกว่าและเทียบเท่า (นั่นคืออีกต่อไปเล็กน้อย)

76 ไบต์ - 50 = 26 คะแนนการแก้ปัญหาในหลาม 2 กำหนดโดย @ ASCII เท่านั้น (ใช้``แทนstr(),

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

ลองออนไลน์!

JavaScript, 65 - 50 = 15 คะแนน

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

ลองออนไลน์!