จำนวน113นั้นเป็นจำนวนเฉพาะครั้งแรกที่มีความยาว3เป็นจำนวนมากผลรวมดิจิทัล5 = 1 + 1 + 3เป็นจำนวนเฉพาะและผลิตภัณฑ์ดิจิทัล3 = 1 * 1 * 3เป็นจำนวนมาก

ไพร์มที่มีคุณสมบัติ 3 อย่างนี้จะเรียกว่าดีเลิศ ช่วงเวลา11117และ1111151เป็นตัวอย่างอื่น ๆ

เป้าหมาย

เขียนโปรแกรมที่สามารถค้นหาหมายเลขที่สำคัญที่สุดที่ยิ่งใหญ่ที่สุดที่เป็นไปได้ในเวลาน้อยกว่าหนึ่งชั่วโมงในคอมพิวเตอร์ส่วนบุคคลที่ทันสมัย ​​(เช่นสเป็คที่ต้องการที่นี่ )

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

เกณฑ์การให้คะแนน

การส่งที่พบว่าชนะสูงสุดที่ยิ่งใหญ่ที่สุด หากปรากฎว่ามีช่วงเวลาที่ยอดเยี่ยมที่สุดจำนวนมากดังนั้นการส่งครั้งแรกที่สร้างผู้ชนะสูงสุดที่สูงที่สุด

(ถ้าคุณสามารถพิสูจน์ทางคณิตศาสตร์ได้ว่ามีหรือไม่มีจำนวนมากที่สุดเท่าที่จะทำได้ฉันจะให้ 200 ตัวแทนเงินรางวัลเพราะ :))

รายละเอียด

• คุณสามารถใช้แหล่งข้อมูลใด ๆ เพื่อสร้างช่วงเวลาของคุณ (เช่นอินเทอร์เน็ต)
• คุณอาจใช้วิธีการทดสอบความน่าจะเป็นสำคัญ
• ทุกอย่างอยู่ในฐาน 10
• ศูนย์และหนึ่งจะไม่ถือว่าเป็นนายก
• ช่วงเวลาที่0มีผลิตภัณฑ์ดิจิทัล0อย่างชัดเจนดังนั้นพวกเขาจึงไม่สามารถสูงสุด

• เพื่อให้หน้าดูรกรุงรังน้อยลงให้เพิ่มจำนวนสูงสุด (100+ หลัก) ในแบบฟอร์ม:

  {[number of 1's before the prime digit]}[prime digit]{[number of 1's after the prime digit]}
  

  ดังนั้นอาจจะแสดงเป็น1111151{5}5{1}

Perl, 15,101 หลัก, {83} 7 {15017}, 8 นาที พบสูงสุด: 72227 หลัก

ใช้โมดูลของฉันคณิตศาสตร์ :: นายกรัฐมนตรี :: Utilและท้าย GMP กลับ มีการทดสอบหลายรายการรวมถึงis_prob_prime ()พร้อมการทดสอบ ES BPSW (เข้มงวดกว่า ispseudoprime ของ Pari เล็กน้อย), is_prime ()ซึ่งจะเพิ่มการสุ่ม MR-base หนึ่งครั้งและis_provable_prime ()ซึ่งจะรัน BLS75 T5 หรือ ECPP ที่ขนาดและประเภทเหล่านี้การทำข้อพิสูจน์จะใช้เวลานาน ฉันได้ทดสอบ MR อีกครั้งในส่วนย่อยของ verifier verifier เวลาบน Core2 E7500 ซึ่งไม่ใช่คอมพิวเตอร์ที่เร็วที่สุดของฉัน (ใช้เวลา 2.5 นาทีสำหรับ i7-4770K ของฉัน)

ดังที่ Tim S. ชี้ให้เห็นเราสามารถค้นหาค่าที่มากขึ้นเรื่อย ๆ จนถึงจุดที่การทดสอบครั้งเดียวใช้เวลาหนึ่งชั่วโมง ที่ ~ 15,000 ตัวเลขใน E7500 นี้ใช้เวลาประมาณ 26 วินาทีสำหรับการทดสอบ MR และ 2 นาทีสำหรับการเต็ม is_prime (แผนกทดลองบวก base-2 MR บวก ES Lucas บวก MR สุ่มหนึ่งฐาน) i7-4770K ของฉันเร็วกว่า 3x ฉันลองสองสามขนาดส่วนใหญ่จะเห็นว่ามันทำอย่างไรกับผลลัพธ์ของคนอื่น ฉันลอง 8k, 20k และ 16k, ฆ่ากันหลังจากนั้นประมาณ 5 นาที จากนั้นฉันลองใช้ความก้าวหน้า 15k สำหรับแต่ละ ~ 10m และโชคดีในวันที่ 4

การทดสอบ PRP ของ OpenPFGW นั้นเร็วกว่าเมื่อตัวเลข 4000 หรือมากกว่านั้นและเร็วกว่ามากในช่วง 50k + การทดสอบนั้นมีผลบวกผิด ๆ จำนวนหนึ่งซึ่งทำให้เป็นการทดสอบล่วงหน้าที่ยอดเยี่ยม แต่ก็ยังต้องการตรวจสอบผลลัพธ์ด้วยอย่างอื่น

สิ่งนี้สามารถต่อขนานกับเธรด perl หรือการใช้ MCE คล้ายกับตัวอย่างตัวค้นหานายก Fibonacci ขนานในโมดูล

เวลาและผลลัพธ์บน i7-4770K ที่ไม่ทำงานโดยใช้แกนเดียว:

• อินพุต 3000, 16 วินาที, 3019 หลัก, {318} 5 {2700}
• อินพุต 4000, 47 วินาที, 4001 หลัก, {393} 7 {3607}
• อินพุต 4100, 5 วินาที, 4127 หลัก, {29} 7 {4097}
• อินพุต 6217 5 วินาที 6217 หลัก {23} 5 {6193}
• อินพุต 6500, 5 นาที, 6547 หลัก, {598} 5 {5948}
• อินพุต 7000, 15 นาที, 7013 หลัก, {2411} 7 {4601}
• อินพุต 9000, 11 นาที, 9001 หลัก, {952} 7 {8048}
• อินพุต 12000, 10 นาที, 12007 หลัก, {652} 5 {11354}
• อินพุต 15100, 2.5 นาที, 1,5101 หลัก, {83} 7 {15017}
• อินพุต 24600, 47 นาที, 24671 หลัก, {621} 7 {24049}
• อินพุต 32060, 18 นาที, 32063 หลัก, {83} 7 {31979}
• อินพุต 57000, 39 นาที, 57037 หลัก, {112} 5 {56924}
• อินพุต 72225, 42 นาที, 72227 หลัก, {16} 3 {72210}

สำหรับผลลัพธ์หลัก 32k ฉันเริ่มต้น 6 สคริปต์ที่ทำงานในเวลาเดียวกันโดยแต่ละรายการมีข้อโต้แย้งต่อเนื่องเริ่มต้นที่ 32000 หลังจาก 26.5 นาทีหนึ่งจบด้วยผลลัพธ์ 32063 หลักที่แสดง สำหรับ 57k ฉันปล่อยให้สคริปต์ต่อเนื่องรัน 6 ครั้งละหนึ่งชั่วโมงเพื่อเพิ่มอินพุต 500 จนกระทั่งผลลัพธ์ 57k กลับมาใน 57 นาที ผลลัพธ์หลัก 72k ถูกค้นพบโดยทำช่วงต่อเนื่องตั้งแต่ 70k ขึ้นไปดังนั้นจึงไม่พบภายในหนึ่งชั่วโมง (แต่เมื่อคุณทราบว่าจะเริ่มต้นที่ใด)

สคริปต์:

#!/usr/bin/env perl
use warnings;
use strict;
use Math::Prime::Util qw/:all/;
use Math::Prime::Util::GMP;  # Just to ensure it is used.

my $l = shift || 1000;  $l--;

while (1) {
  $l = next_prime($l);
  my @D = grep { is_prime($l-1 + $_) } (3,5,7);
  next unless scalar @D > 0;
  for my $s (0 .. $l-1) {
    my $e = $l-$s-1;
    warn "   checking $l $s\n" unless $s % 100;
    for my $d (@D) {
      my $n = "1"x$s . $d . "1"x$e;
      die unless length($n) == $l;
      verify_supreme($n,$s,$d,$e) if is_prime($n);  # ES BPSW + 1 rand-base M-R
    }
  }
}
sub verify_supreme {  # Be pedantic and verify the result
  my($n,$s,$d,$e) = @_;
  die "Incorrect length" unless is_prime(length($n));
  die "Incorrect sum" unless is_prime(vecsum(split(//,$n)));
  my $prod = 1; $prod *= $_ for split(//,$n);
  die "Incorrect product" unless is_prime($prod);
  die "n is not a prime!" unless miller_rabin_random($n,1);  # One more M-R test
  die "{$s} $d {$e}\n";
}

Python 2.7 บน PyPy, {2404} 3 {1596} (~ 10 ^ 4000)

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

พบหนึ่งในนี้ประมาณ 50 นาทีหลังจากเริ่มต้นจาก 4000 ดังนั้นฉันจะประมาณว่านี่เป็นขีด จำกัด สูงสุดของวิธีการรหัสนี้

เปลี่ยนแปลง: ฉันสังเกตเห็นว่าบางความยาวดูเหมือนจะมีประโยชน์มากกว่าสำหรับการสร้างนายกประเภทนี้ดังนั้นฉันตัดสินใจที่จะตรวจสอบสถานที่สุ่ม 50 แห่งซึ่งไม่ใช่ 1 แทนที่จะเป็นสถานที่ที่เป็นไปได้ทั้งหมดก่อนที่จะย้าย บน. ฉันไม่แน่ใจว่าสิ่งนี้จะปรับปรุงประสิทธิภาพหรือว่า 50 ถูกต้อง แต่เราจะเห็น

รายการความเป็นไปได้ถูกสร้างขึ้นตามความจริงที่ว่าสำหรับความต้องการของผลิตภัณฑ์ที่จะต้องปฏิบัติตามจำนวนที่จะต้องเป็นคนทั้งหมดยกเว้นนายก นอกจากนี้ไพร์มไม่สามารถเป็น 2 ได้เนื่องจากความสัมพันธ์ผลรวมและความยาวและผลรวมดิจิทัลต้องไม่สามารถหารด้วยสามได้โดยให้ข้อกำหนด% 3

is_prime นำมาจากhttp://codepad.org/KtXsydxKเขียนโดย @primo

หมายเหตุ: ฟังก์ชั่น is_prime นี้เป็นจริงการทดสอบหลอกหลอก Baillie-PSW แต่ไม่มีตัวอย่างเคาน์เตอร์ที่รู้จักกันดังนั้นฉันจะไม่กังวลเกี่ยวกับความแตกต่าง

#http://codepad.org/KtXsydxK
from my_math import is_prime
import time,random
LLIMIT=2748
time.clock()
start_time=time.time()
checked=0
while time.time()-start_time<3600:
    small_primes = [a for a in range(LLIMIT,2*LLIMIT) if is_prime(a)]
    leng,dig=(0,0)
    for a in small_primes:
        if a+2 in small_primes:
            leng,dig=(a,3)
            break
        if a+4 in small_primes:
            leng,dig=(a,5)
            break
        if a+6 in small_primes:
            leng,dig=(a,7)
            break
    start=time.clock()
    print leng,dig,time.clock(),checked
    for loc in random.sample(range(leng),50):
        checked+=1
        if is_prime(int('1'*loc+str(dig)+'1'*(leng-loc-1))):
            print leng-1,loc,dig,time.clock(),time.clock()-start, \
                  int('1'*loc+str(dig)+'1'*(leng-loc-1))
            break
    LLIMIT=leng+1

PARI / GP, 4127 หลัก

(10 ⁴¹²⁷ -1) / 9 + 2 * 10 ⁵¹⁵

นี่เป็นการค้นหาที่ค่อนข้างตรงไปตรง: ตรวจสอบเฉพาะความยาวดิจิตที่สำคัญแล้วคำนวณจำนวนที่เป็นไปได้ที่จะใช้จากนั้นจึงวนซ้ำความเป็นไปได้ทั้งหมด ฉันใส่กรณีพิเศษเป็นพิเศษซึ่งมีตัวเลขเฉพาะที่เหมาะสมเป็น 0 หรือ 1

supreme(lim,startAt=3)={
    forprime(d=startAt,lim,
        my(N=10^d\9, P=select(p->isprime(d+p),[1,2,4,6]), D, n=1);
        if(#P==0, next);
        if(#P==1,
            for(i=0,d-1,
                if (ispseudoprime(D=N+n*P[1]), print(D));
                n*=10
            );
            next
        );
        D=vector(#P-1,i,P[i+1]-P[i]);
        for(i=0,d-1,
            forstep(k=N+n*P[1],N+n*P[#P],n*D,
                if (ispseudoprime(k), print(k))
            );
            n*=10
        )
    )
};
supreme(4200, 4100)

การคำนวณนี้ใช้เวลา 36 นาทีในหนึ่งแกนของเครื่องที่ค่อนข้างเก่า มันจะไม่มีปัญหาในการค้นหานายกมากกว่า 5,000 หลักในหนึ่งชั่วโมงฉันแน่ใจ แต่ฉันก็ใจร้อน

ทางออกที่ดีกว่าคือการใช้ภาษาที่เหมาะสมในการทำทุกอย่างยกเว้นลูปด้านในสุดจากนั้นสร้างไฟล์ abc สำหรับไพร์มฟอร์มซึ่งเหมาะสำหรับการคำนวณประเภทนั้น สิ่งนี้น่าจะสามารถผลักดันการคำนวณได้สูงสุด 10,000 หลัก

แก้ไข : ฉันใช้โซลูชันไฮบริดที่อธิบายไว้ข้างต้น แต่ในเครื่องเก่าของฉันฉันไม่สามารถหาคำแรกด้วย> = 10,000 หลักในเวลาน้อยกว่าหนึ่งชั่วโมง นอกจากว่าฉันจะวิ่งบนสิ่งที่เร็วกว่าฉันจะต้องเปลี่ยนไปสู่เป้าหมายที่สูงส่งน้อยลง

Mathematica 3181 หลัก

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

f[primeDigitLength_]:=
Module[{id=ConstantArray[1,primeDigitLength-1]},
permutations=Reverse@Sort@Flatten[Table[Insert[id,#,pos],{pos,primeDigitLength}]&/@{3,5,7},1];
Flatten[Select[permutations,PrimeQ[FromDigits[#]]\[And]PrimeQ[Plus@@#]&,1],1]]

ตัวอย่าง

นี่คือการทดสอบครั้งแรกของฉันค้นหาวิธีแก้ปัญหาด้วย 3181 หลัก พบกรณีแรกใน 26 วินาที

เรามาดูเหตุผลกันก่อน จากนั้นเราจะเข้าสู่โปรแกรม

เริ่มกันเลยอย่างที่ฉันทำ "นายกรัฐมนตรีคนที่ 450 คืออะไร" เราสามารถหาวิธีแก้ปัญหาด้วยตัวเลขจำนวนมาก (3181) ได้หรือไม่?

primeDigits = Prime[450]

3181

จำนวนจะพบได้โดยการเข้าร่วมตัวเลข

number = FromDigits[digits];

แต่แทนที่จะแสดงมันเราสามารถถามแทนตัวเลขและที่พวกเขาอยู่

DigitCount[number]

{3180, 0, 0, 0, 0, 0, 1, 0, 0, 0}

ซึ่งหมายความว่ามี 3180 อินสแตนซ์ของหลัก 1 และอินสแตนซ์เดียวของ 7 หลัก

ตัวเลข 7 อยู่ที่ตำแหน่งใด?

Position[digits, 7][[1, 1]]

142

ดังนั้นหลัก 7 คือ 142 หลัก ส่วนคนอื่น ๆ ทั้งหมดคือ 1

แน่นอนว่าผลคูณของตัวเลขต้องเป็นจำนวนเฉพาะคือ 7

digitProduct = Times @@ digits

7

และผลรวมของตัวเลขก็เป็นจำนวนมากเช่นกัน

digitSum = Plus @@ digits
PrimeQ[digitSum]

3187
จริง

และเรารู้ว่าจำนวนหลักคือจำนวนเฉพาะ จำไว้ว่าเราเลือกรุ่นที่ 450 ที่สำคัญคือ 3118

ดังนั้นเงื่อนไขทั้งหมดได้รับการตอบสนอง

Python 2.7, 6217 หลัก: {23} 5 {6193} 6 นาที 51 วินาที

ฉันทำงานกับเวอร์ชันของฉันเองและรู้สึกผิดหวังที่ @issacg ทำให้ฉันตบตีด้วยวิธีที่คล้ายกันมากถึงแม้ว่า is_ (very_probably) _prime () อย่างไรก็ตามฉันเห็นว่าฉันมีความแตกต่างที่สำคัญบางอย่างซึ่งทำให้ได้คำตอบที่ดีขึ้นในเวลาที่น้อยลง (เมื่อฉันใช้ is_prime ด้วย) เพื่อให้ชัดเจนเมื่อเริ่มต้นจาก 4000 ฉันได้คำตอบที่ดีกว่า 4001 หลัก ({393} 7 {3607}) ในเวลาเพียง 26 นาที 37 วินาทีโดยใช้Python interpreter มาตรฐาน (เช่นที่รุ่น 2.7) ไม่ใช่ PyPy รุ่น นอกจากนี้ฉันไม่ได้ 'ตรวจสอบ' การตรวจสอบตัวเลข ผู้สมัครทั้งหมดจะถูกตรวจสอบ

นี่คือการปรับปรุงหลัก:

1. ใช้ตัวสร้างหลัก ( https://stackoverflow.com/questions/567222/simple-prime-generator-in-python/568618#568618 ) เพื่อสร้างรายการช่วงเวลาเพื่อตรวจสอบและ (รุ่น "ช่วงเวลาขนาดเล็ก" ของเขา) และสำหรับการสร้างความยาวจำนวนที่มีสิทธิ์

2. เราต้องการใช้เวลาของเราเพื่อค้นหานายกที่ยิ่งใหญ่ที่สุดของความยาวที่กำหนดไม่ใช่ขนาดที่เล็กที่สุดดังนั้นฉันจึงสร้างตัวเลขที่ใหญ่ที่สุดเท่าที่จะเป็นไปได้ก่อนเพื่อตรวจสอบไม่ใช่ขนาดที่เล็กที่สุด จากนั้นเมื่อพบหนึ่งเราสามารถไปยังความยาวถัดไปได้ทันที

แก้ไข: ตอนนี้มีการประมวลผลหลายตัว

นี่คือการเปลี่ยนแปลงที่สำคัญกับรุ่นก่อนหน้า ก่อนหน้านี้ฉันสังเกตเห็นว่าเครื่อง 8-core ของฉันทำงานหนักฉันจึงตัดสินใจลองใช้มัลติโพรเซสซิงใน Python (ครั้งแรก) ผลลัพธ์เป็นสิ่งที่ดีมาก!

ในรุ่นนี้กระบวนการเด็ก 7 กระบวนการจะเกิดขึ้นซึ่งคว้า 'งาน' ออกจากคิวของความเป็นไปได้ที่อาจเกิดขึ้น (num_length + ตัวเลขที่มีสิทธิ์) พวกเขาปั่นผ่านการลองตำแหน่ง [7,5,3] ที่แตกต่างกันจนกว่าจะเจอ หากเป็นเช่นนั้นจะแจ้งกระบวนการหลักของความยาวที่ยาวที่สุดใหม่ที่พบ หากเด็กกำลังทำงานกับ num_length ที่สั้นกว่าพวกเขาจะประกันตัวและไปหาความยาวต่อไป

ฉันเริ่มการวิ่งครั้งนี้ด้วย 6,000 และมันยังคงทำงานอยู่ แต่จนถึงตอนนี้ฉันพอใจกับผลลัพธ์

โปรแกรมยังไม่หยุดอย่างถูกต้อง แต่ไม่ใช่เรื่องใหญ่สำหรับฉัน

ตอนนี้รหัส:

#!/usr/bin/env python
from __future__ import print_function

import sys
from multiprocessing import Pool, cpu_count, Value
from datetime import datetime, timedelta

# is_prime() et al from: http://codepad.org/KtXsydxK - omitted for brevity
# gen_primes() from: https://stackoverflow.com/questions/567222/simple-prime-generator-in-python/568618#568618 - ommitted for brevity
from external_sources import is_prime, gen_primes


def gen_tasks(start_length):
    """
    A generator that produces a stream of eligible number lengths and digits
    """
    for num_length in gen_primes():
        if num_length < start_length:
            continue

        ns = [ n for n in [7,5,3] if num_length + n - 1 in prime_list ]
        if ns:
            yield (num_length, ns)


def hunt(num_length, ns):
    """
    Given the num_length and list of eligible digits to try, build combinations
    to try, and try them.
    """

    if datetime.now() > end_time or num_length <= largest.value:
        return

    print('Tasked with: {0}, {1}'.format(num_length, ns))
    sys.stdout.flush()
    template = list('1' * num_length)
    for offset in range(num_length):
        for n in ns:
            if datetime.now() > end_time or num_length <= largest.value:
                return

            num_list = template[:]
            num_list[offset] = str(n)
            num = int(''.join(num_list))

            if is_prime(num):
                elapsed = datetime.now() - start_time
                largest.value = num_length
                print('\n{0} - "{1}"\a'.format(elapsed, num))


if __name__ == '__main__':
    start_time = datetime.now()
    end_time = start_time + timedelta(seconds=3600)

    print('Starting @ {0}, will stop @ {1}'.format(start_time, end_time))

    start_length = int(sys.argv[1])

    #
    # Just create a list of primes for checking. Up to 20006 will cover the first
    # 20,000 digits of solutions
    #
    prime_list = []
    for prime in gen_primes():
        prime_list.append(prime)
        if prime > 20006:
            break;
    print('prime_list is primed.')

    largest = Value('d', 0)

    task_generator = gen_tasks(start_length)

    cores = cpu_count()
    print('Number of cores: {0}'.format(cores))


    #
    # We reduce the number of cores by 1 because __main__ is another process
    #
    pool = Pool(processes=cores - 1)

    while datetime.now() < end_time:
        pool.apply_async(hunt, next(task_generator))

C, GMP - {7224} 5 {564} = 7789

รุ่งโรจน์ถึง @issacg และพวกคุณทุกคนสำหรับแรงบันดาลใจและลูกเล่น
และยังเป็นผู้ถามคำถามเก่ง ๆ @ Calvin's Hobbies สำหรับคำถามนี้

รวบรวม: gcc -I/usr/local/include -o p_out p.c -pthread -L/usr/local/lib -lgmp

หากคุณรู้สึกอยากบริจาคพลังการคำนวณหรืออยากรู้อยากเห็นเกี่ยวกับประสิทธิภาพการทำงานอย่าลังเลที่จะคัดลอกโค้ดและคอมไพล์ ;) คุณจะต้องติดตั้ง GMP

#include<stdio.h>
#include<stdlib.h>
#include<sys/time.h>
#include<gmp.h>
#include<pthread.h>

#define THREAD_COUNT 1
#define MAX_DIGITS   7800
#define MIN_DIGITS   1000

static void huntSupremePrime(int startIndex) {

    char digits[MAX_DIGITS + 1];

    for (int i = 0; i < MAX_DIGITS; digits[i++] = '1');

    digits[MAX_DIGITS] = '\0';
    mpz_t testPrime, digitSum, digitCount, increment;

    for (int j = 0; j < MAX_DIGITS - startIndex; digits[j++] = '0');

    int step = THREAD_COUNT * 2;

    for (int i = startIndex, l = MAX_DIGITS - startIndex; i > MIN_DIGITS - 1; 
        i -= step, l += step) {
        fprintf(stderr, "Testing for %d digits.\n", i);
        mpz_init_set_ui(digitCount, i);
        if (mpz_millerrabin(digitCount, 10)) {
            for (int j = 3; j < 8; j += 2) {
                mpz_init_set_ui(digitSum, i - 1 + j);
                if (mpz_millerrabin(digitSum, 10)) {
                    gmp_printf("%Zd \n", digitSum);
                    digits[MAX_DIGITS - 1] = j + 48;
                    mpz_init_set_str(testPrime, digits, 10);
                    mpz_init_set_ui(increment, (j - 1) * 99);
                    for (int k = 0; k < i/20; ++k) {
                        if (mpz_millerrabin(testPrime, 25)) {
                            i = 0;
                            j = 9;
                            k = l;
                            gmp_printf("%Zd\n", testPrime);
                            break;
                        }
                        mpz_add(testPrime, testPrime, increment);
                        mpz_mul_ui(increment, increment, 100);
                        fprintf(stderr, "TICK %d\n", k);
                    }

                }
            }
        }
        for (int j = 0; j < step; digits[l + j++] = '0');

    }
}

static void *huntSupremePrimeThread(void *p) {
    int* startIndex = (int*) p;
    huntSupremePrime(*startIndex);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {

    int  startIndexes[THREAD_COUNT];
    pthread_t threads[THREAD_COUNT];

    int startIndex = MAX_DIGITS;
    for (int i = 0; i < THREAD_COUNT; ++i) {
        for (;startIndex % 2 == 0; --startIndex);
        startIndexes[i] = startIndex;
        int rc = pthread_create(&threads[i], NULL, huntSupremePrimeThread, (void*)&startIndexes[i]); 
        if (rc) { 
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
        --startIndex;
    }

    for (int i = 0; i < THREAD_COUNT; ++i) {
        void * status;
        int rc = pthread_join(threads[i], &status);
        if (rc) {
            printf("ERROR: return code from pthread_join() is %d\n", rc);
            exit(-1);
        }
    }

    pthread_exit(NULL);
    return 0;
}

PFGW, 6067 หลัก, {5956} 7 {110}

รันPFGWด้วยไฟล์อินพุตต่อไปนี้และ-f100เพื่อกำหนดหมายเลขล่วงหน้า ในประมาณ 2-3 นาที CPU บนคอมพิวเตอร์ของฉัน (i5 Haswell) ก็พบว่า PRP (10 ^ (6073-6) -1) / 9 + 6 * 10 ^ 110 หรือ{5956} {7} ฉันเลือก 6,000 หลักเป็นจุดเริ่มต้นว่าเป็นหมายเลขที่ไม่มีอะไรเลยที่สูงกว่าการส่งก่อนหน้าเล็กน้อยทั้งหมด

ABC2 $a-$b & (10^($a-$b)-1)/9+$b*10^$c
a: primes from 6000 to 6200
b: in { 2 4 6 }
c: from 0 to 5990

จากการที่ฉันสามารถค้นหาสิ่งนี้ได้อย่างรวดเร็วฉันสามารถชนจำนวนหลักได้อย่างง่ายดายและยังสามารถหา PRP ได้ภายในหนึ่งชั่วโมง ด้วยวิธีการเขียนกฎฉันอาจจะหาขนาดที่ CPU ของฉันทำงานบนทั้ง 4 คอร์สามารถทดสอบ PRP หนึ่งครั้งในหนึ่งชั่วโมงใช้เวลานานในการค้นหา PRP และให้ "การค้นหา" ของฉันประกอบด้วยเพียงอย่างเดียว ของหนึ่ง PRP

ป.ล. ในความรู้สึกบางอย่างนี่ไม่ใช่วิธีการแก้ปัญหา "รหัส" เพราะฉันไม่ได้เขียนอะไรเลยนอกจากไฟล์อินพุต ... แต่แล้ววิธีแก้ปัญหา Mathematica แบบบรรทัดเดียวจำนวนมากสำหรับปัญหาทางคณิตศาสตร์สามารถอธิบายได้ในลักษณะเดียวกัน การใช้ห้องสมุดที่ใช้งานได้ยากสำหรับคุณ ในความเป็นจริงฉันคิดว่ามันยากที่จะวาดเส้นที่ดีระหว่างทั้งสอง ถ้าคุณชอบฉันสามารถเขียนสคริปต์ที่สร้างไฟล์อินพุต PFGW และโทร PFGW สคริปต์สามารถค้นหาแบบขนานเพื่อใช้ทั้ง 4 คอร์และเพิ่มความเร็วในการค้นหาได้ถึง 4 เท่า (บน CPU ของฉัน)

PPS ฉันคิดว่าLLRสามารถทำการทดสอบ PRP สำหรับตัวเลขเหล่านี้และฉันคาดว่ามันจะเร็วกว่า PFGWมาก โปรแกรมคัดแยกเฉพาะอาจดีกว่าที่จะแยกแยะตัวเลขเหล่านี้ได้ดีกว่า PFGW ในครั้งเดียว หากคุณรวมสิ่งเหล่านี้ฉันแน่ใจว่าคุณสามารถผลักดันขอบเขตที่สูงกว่าโซลูชันปัจจุบันได้มาก

Python 2.7, 17-19 หลัก

11111111171111111

พบ 5111111111111 (13 หลัก) ใน 3 วินาทีและ Prime 17 หลักสูงสุดนี้ใน 3 นาที ฉันจะเดาว่าเครื่องเป้าหมายสามารถทำงานได้และได้รับ 19 หลักสูงสุดในเวลาน้อยกว่าหนึ่งชั่วโมง วิธีการนี้ไม่ได้ปรับขนาดได้ดีเพราะมันจะเก็บช่วงเวลาได้มากถึงครึ่งของจำนวนเป้าหมายในหน่วยความจำ การค้นหา 17 หลักต้องการการจัดเก็บอาร์เรย์ของบูลีน 100M 19 หลักจะต้องมีอาร์เรย์องค์ประกอบ 1B และหน่วยความจำจะหมดลงก่อนที่จะถึง 23 หลัก รันไทม์อาจจะเป็นเช่นกัน

วิธีการทดสอบแบบดั้งเดิมที่ไม่เกี่ยวข้องกับค่าตัวหารจำนวนมหาศาลจะน่าสนใจยิ่งขึ้น

#!/usr/bin/env python
import math
import numpy as np
import sys

max_digits = int(sys.argv[1])
max_num = 10**max_digits

print "largest supreme prime of " + str(max_digits) + " or fewer digits"

def sum_product_digits(num):
    add = 0
    mul = 1
    while num:
         add, mul, num = add + num % 10, mul * (num % 10), num / 10
    return add, mul

def primesfrom2to(n):
    # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n/3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)/3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))/3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

def checkprime(n):
    for divisor in primes:
        if (divisor>math.sqrt(n)):
            break
        if n%divisor==0:
            return False
    return True

# make an array of all primes we need to check as divisors of our max_num
primes = primesfrom2to(math.sqrt(max_num))
# only consider digit counts that are prime
for num_digits in primes:
    if num_digits > max_digits:
        break
    for ones_on_right in range(0,num_digits):
        for mid_prime in ['3','5','7']:
            # assemble a number of the form /1*[357]1*/
            candidate = int('1'*(num_digits-ones_on_right-1)+mid_prime+'1'*ones_on_right)
            # check for primeness of digit sum first digit product first
            add, mul = sum_product_digits(candidate)
            if add in primes and mul in primes:
                # check for primality next
                if checkprime(candidate):
                    # supreme prime!
                    print candidate

Mathematica 4211 4259 หลัก

ด้วยจำนวน: {1042} 7 {3168} {388} 3 {3870}

ซึ่งสร้างขึ้นโดยรหัสต่อไปนี้:

TimeConstrained[
 Do[
  p = Prime[n];
  curlargest = Catch[
    If[PrimeQ[p + 6],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 7]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];

    If[PrimeQ[p + 4],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 5]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];
    If[PrimeQ[p + 2],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 3]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];
    Throw[curlargest];
    ]

  , {n, 565, 10000}]
 , 60*60]

การโยนทำให้หยุดการทดสอบตัวเลขอื่นด้วยตัวเลขเดียวกันกับที่พบในปัจจุบัน เนื่องจากมันเริ่มทำการทดสอบด้วยตัวเลขที่สำคัญที่สุดนั่นจะหมายความว่ามันจะส่งกลับตัวเลขที่ใหญ่ที่สุดเสมอเว้นแต่ว่าตัวเลขนั้นเป็นสมาชิกของ triplet สำคัญ

เพียงแค่เริ่มทดสอบต่ำกว่าค่าของหนึ่งในคำตอบก่อนหน้านี้ :)

เมื่อเสร็จสิ้นจำนวนจะถูกเก็บไว้ใน curlargest ตัวแปร

JavaScript, 3019 หลัก, {2,273} 5 {745}

สิ่งนี้ใช้การทดสอบ MillerRabin ที่รวมอยู่ใน BigInteger.js โดย Tom Wu

เริ่มต้นจาก0 => 2,046 ตัวเลข = {1799} {7} 263 ในหนึ่งชั่วโมง

เริ่มต้นจาก3000 => 3,019 ตัวเลข = {2273} {5} 745 ในหนึ่งชั่วโมงน้อย 3 วินาที

เมื่อเริ่มต้นจาก 0 โปรแกรมจะข้ามไปข้างหน้าและเริ่มค้นหาอีกครั้งที่ความยาว 1.5 เท่าของความยาวของ s-prime ครั้งสุดท้ายที่พบ จากนั้นเมื่อฉันเห็นว่ามันวิ่งเร็วแค่ไหนฉันก็เดาได้ว่ามันจะเริ่มจาก 3000 ในหนึ่งชั่วโมงซึ่งมันใช้เวลาเพียง 3 วินาทีเท่านั้น

คุณสามารถลองได้ที่นี่: http://goo.gl/t3TmTk
(ตั้งค่าเพื่อคำนวณ s-primes ทั้งหมดหรือข้ามไปข้างหน้า)

โปรแกรมทำงานโดยการสร้างสตริงของ "1" ทั้งหมด แต่จะมี "3", "5" หรือ "7" ทั้งหมด ฉันเพิ่มการตรวจสอบอย่างรวดเร็วในฟังก์ชัน IsStrPrime เพื่อปฏิเสธหมายเลขที่ลงท้ายด้วย "5"

if (IsIntPrime(length)) {

    var do3s = IsIntPrime(length + 2);
    var do5s = IsIntPrime(length + 4);
    var do7s = IsIntPrime(length + 6);

    if (do3s || do5s || do7s) {

        // loop through length of number
        var before, digit, after;

        for (var after = 0; after <= length - 1; after++) {

            before = length - after - 1;
            beforeStr = Ones(before);
            afterStr = Ones(after);

            if (do3s && IsStrPrime(beforeStr + (digit = "3") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (do5s && IsStrPrime(beforeStr + (digit = "5") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (do7s && IsStrPrime(beforeStr + (digit = "7") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (after % 10 == 0) document.title = "b=" + bestLength + ", testing=" + length + "-" + after;
        }
    }
}

สนุกมาก ทำให้ผมนึกถึงปริศนาผมไม่หลายปีที่ผ่านมาในการคำนวณสิ่งที่เรียกว่าหลักสำคัญลบออก นี่เป็นจำนวนเฉพาะที่หากคุณลบตัวเลขใด ๆ ออกไปหมายเลขที่เหลือจะยังคงเป็นจำนวนเฉพาะ ตัวอย่างเช่น 1,037 เป็นจำนวนลบหลักเนื่องจาก 1037, 037, 137, 107 และ 103 เป็นไพร์ม ฉันพบความยาวหนึ่งหลัก 84 และที่ยาวที่สุดที่ฉันรู้คือยาว 332 หลัก ฉันแน่ใจว่าเราสามารถค้นหาได้นานขึ้นด้วยเทคนิคที่ใช้สำหรับปริศนานี้ (แต่การเลือกหมายเลขทดลองใช้อาจเป็นเรื่องยากหน่อย -)

ความจริง 3019 หลัก {318} 5 {2700}

)time on

-- Return true if n is pseudo prime else return false
-- **Can Fail**
prime1(n:PI):Boolean==
     n=1=>false
     n<4=>true
     i:=5;sq:=sqrt(1.*n)
     repeat
       if i>sq or i>50000 then break
       if n rem i=0       then return false
       i:=i+2
     if i~=50001        then return true
     --output("i")
     if powmod(3,n,n)=3 then return true
     --output("e")
     false

-- input  'n': must be n>1 prime
-- output [0] if not find any number, else return 
-- [n,a,b,c,z] 'n' digits of solution, 
-- 'a' number of '1', 'b' central digit, 'b' number of final digit '1'
-- 'z' the number found
g(n:PI):List NNI==
    x:=b:=z:=1
    for i in 1..n-1 repeat
        z:=z*10+1
        b:=b*10
    repeat
       --output b
       k:=0    -- 3 5 7 <-> 2 4 6
       for i in [2,4,6] repeat
           ~prime?(n+i)=>0 --somma
           k:=k+1
           t:=z+b*i
           if prime1(t) then return [n,x-1,i+1,n-x,t]
       --if x=1 then output ["k=", k] 
       if k=0  then break
       x:=x+1
       b:=b quo 10
       if b<=0 then break
    [0]

-- start from number of digits n
-- and return g(i) with i prime i>=n 
find(n:PI):List NNI==
    i:=n
    if i rem 2=0 then i:=i+1 
    repeat
        if prime?(i) then --solo le lunghezze prime sono accettate
             output i 
             a:=g(i)
             if a~=[0] then return a
        i:=i+2

ผลลัพธ์จากค่าเริ่มต้น 3000 ใน 529 วินาที

(4) -> find(3000)
   3001
   3011
   3019

   (4)
   [3019, 318, 5, 2700, Omissis]
                                            Type: List NonNegativeInteger
       Time: 0.02 (IN) + 525.50 (EV) + 0.02 (OT) + 3.53 (GC) = 529.07 sec