ค้นหานายกที่ใหญ่ที่สุดซึ่งยังคงเป็นไพรม์หลังจากการลบตัวเลข

มากกว่าที่/math/33094/deleting-any-digit-yields-a-prime-is-there-a-name-for-thisคำถามนี้ถูกถาม มีจำนวนเฉพาะที่เหลืออยู่หลังจากคุณลบตัวเลขใดตัวเลขหนึ่ง ยกตัวอย่างเช่น719เป็นสำคัญเช่นคุณได้รับ71, และ19 79ในขณะที่คำถามนี้ยังไม่ได้รับการแก้ไขฉันคิดว่ามันเป็นความท้าทายที่ดี

งาน. ให้นายกที่ใหญ่ที่สุดที่คุณสามารถพบได้ซึ่งยังคงเป็นนายกรัฐมนตรีอยู่หลังจากที่คุณลบหนึ่งหลัก คุณควรระบุรหัสที่พบ

คะแนน. คุณค่าของนายกที่คุณให้

คุณสามารถใช้ภาษาการเขียนโปรแกรมและไลบรารี่ใด ๆ ก็ได้ตามต้องการ

ในการเริ่มต้นสิ่งต่าง ๆ99444901133จะได้รับมากที่สุดในหน้าเชื่อมโยง

เวลาที่ จำกัด. ฉันจะยอมรับคำตอบที่ถูกต้องที่ใหญ่ที่สุดที่ให้ไว้หนึ่งสัปดาห์หลังจากคำตอบที่ถูกต้องครั้งแรกที่ใหญ่กว่าที่99444901133ได้รับในคำตอบ

จนถึงตอนนี้คะแนน

Python (พรีโม่)

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

J (randomra) (คำตอบนี้เริ่มจับเวลาหนึ่งสัปดาห์ในวันที่ 21 กุมภาพันธ์ 2013)

222223333333

274 หลัก

4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111

ใช้เวลาในการค้นหา CPU ประมาณ 20 ชั่วโมงและใช้เวลาประมาณ 2 นาทีในการทดสอบ ในทางตรงกันข้ามโซลูชั่น 84 หลักสามารถพบได้ในเวลาประมาณ 3 นาที

84 หลัก

444444444444444444444444444444444444444444444444441111111113333333333333333333333333

77777777999999999999999777777777 (32 หลัก)
66666666666666622222222222222333 (32 หลัก)
647777777777777777777777777 (27 หลัก)
44444441333333333333 (20 หลัก)
999996677777777777 (18 หลัก)
167777777777777 (15 หลัก)

ฉันขอแนะนำเครื่องมือนี้หากคุณต้องการยืนยันความเป็นอันดับแรก : D. Applet ECM ของ Alpern

นอกจากนี้ยังใช้วิธีการทำซ้ำซึ่งดูเหมือนจะเป็นวิธีที่มีแนวโน้มมากที่สุดที่จะหาค่ามาก สคริปต์ต่อไปนี้อัลกอริทึมข้ามตัวเลขหรือการตัดส่วนใหญ่ซึ่งจะส่งผลให้ทวีคูณเป็น2, 3, 5และตอนนี้11 c / o PeterTaylor (การมีส่วนร่วมของเขาเพิ่มประสิทธิภาพโดยประมาณ 50%)

from my_math import is_prime

sets = [
 (set('147'), set('0147369'), set('1379')),
 (set('369'), set('147'), set('1379')),
 (set('369'), set('0369'), set('17')),
 (set('258'), set('0258369'), set('39')),
 (set('369'), set('258'), set('39'))]

div2or5 = set('024568')

for n in range(3, 100):
 for sa, sb, sc in sets:
  for a in sa:
   for b in sb-set([a]):
    bm1 = int(b in div2or5)
    for c in sc-set([b]):
     if int(a+b+c)%11 == 0: continue
     for na in xrange(1, n-1, 1+(n&1)):
      eb = n - na
      for nb in xrange(1, eb-bm1, 1+(~eb&1)):
       nc = eb - nb
       if not is_prime(long(a*(na-1) + b*nb + c*nc)):
        continue
       if not is_prime(long(a*na + b*(nb-1) + c*nc)):
        continue
       if not is_prime(long(a*na + b*nb + c*(nc-1))):
        continue
       if not is_prime(long(a*na + b*nb + c*nc)):
        continue
       print a*na + b*nb + c*nc

my_math.pyสามารถพบได้ที่นี่: http://codepad.org/KtXsydxK
หรือคุณสามารถใช้gmpy.is_primeฟังก์ชั่น: โครงการ GMPY

การปรับปรุงความเร็วเล็กน้อยบางส่วนเป็นผลมาจากการทำโปรไฟล์ การตรวจสอบแบบดั้งเดิมสำหรับผู้สมัครที่ยาวที่สุดสี่คนถูกย้ายไปที่จุดสิ้นสุดxrangeแทนที่rangeและlongแทนที่การintปลดเปลื้องประเภท ดูเหมือนว่าจะมีค่าใช้จ่ายที่ไม่จำเป็นถ้าผลการประเมินการแสดงออกในintlong

กฎการแบ่งส่วน

ให้Nเป็นจำนวนเต็มหลังของรูปแบบa ... ab ... bc ... cโดยที่a , bและcเป็นตัวเลขหลักซ้ำ

โดย 2 และ 5
- เพื่อหลีกเลี่ยงการหารโดย2และ5 , คอาจจะไม่อยู่ในชุด[0, 2, 4, 5, 6, 8] นอกจากนี้หากbเป็นสมาชิกของชุดนี้ความยาวของcอาจไม่น้อยกว่า 2

3
- หากN = 1 (สมัย 3)แล้วยังไม่มีอาจจะไม่ได้มีการใด ๆ ของ[1, 4, 7]เป็นลบใด ๆ เหล่านี้จะส่งผลให้นิด ๆ หลายของ3 ในทำนองเดียวกันสำหรับN = 2 (สมัย 3)และ[2, 5, 8] การใช้งานนี้ใช้รูปแบบที่อ่อนแอลงเล็กน้อยหากNมีหนึ่งใน[1, 4, 7]มันอาจไม่มี[2, 5, 8]และในทางกลับกัน นอกจากนี้Nอาจไม่ประกอบด้วย[0, 3, 6, 9]เพียงอย่างเดียว นี่เป็นคำสั่งที่เทียบเท่ากันส่วนใหญ่ แต่จะอนุญาตให้ใช้ในบางกรณีเล็กน้อยเช่นa , bและcแต่ละคนซ้ำหลายครั้ง3ครั้ง

โดย 11
- ดังที่PeterTaylorบันทึกไว้ถ้าNเป็นรูปแบบaabbcc ... xxyyzzนั่นคือมันประกอบด้วยตัวเลขที่ซ้ำกันหลายครั้งเท่านั้นมันจะหารด้วย11 : a0b0c ... x0y0zเพียงเล็กน้อยเท่านั้น การสังเกตนี้กำจัดครึ่งหนึ่งของพื้นที่การค้นหา หากยังไม่มีเป็นของความยาวแปลกแล้วความยาวของ, ขและคทั้งหมดจะต้องแปลกเช่นกัน (75% การลดพื้นที่การค้นหา) และถ้ายังไม่มีเป็นของความยาวแม้แล้วเพียงหนึ่งใน, BหรือCอาจจะยิ่ง ความยาว (การลดพื้นที่การค้นหา 25%) - การคาดคะเน
ถ้าabcมีหลาย11ตัวอย่างเช่น407แล้วทั้งหมดซ้ำคี่ของ, BและCก็จะทวีคูณของ11 สิ่งนี้หลุดออกจากขอบเขตของการแบ่งแยกด้านบนตามกฎ11ข้อ; อันที่จริงมีเพียงการทำซ้ำที่แปลก ๆ เท่านั้นที่อยู่ในประเภทที่ได้รับอนุญาตอย่างชัดเจน ฉันไม่มีข้อพิสูจน์สำหรับเรื่องนี้ แต่การทดสอบอย่างเป็นระบบไม่สามารถหาตัวอย่างเคาน์เตอร์ได้ เปรียบเทียบ: 444077777 , 44444000777 , 44444440000077777777777ฯลฯทุกคนอาจรู้สึกอิสระที่จะพิสูจน์หรือพิสูจน์หักล้างการคาดเดานี้ aditsuได้แสดงให้เห็นว่าสิ่งนี้ถูกต้องตั้งแต่

แบบฟอร์มอื่น ๆ

ตัวเลขซ้ำ
จำนวน2 ชุดตัวเลขของแบบฟอร์มที่สุ่มกำลังตามหา... ab ... bดูเหมือนจะหายากกว่านี้มาก มีเพียง 7 โซลูชั่นที่น้อยกว่า10 ¹⁷⁰⁰ซึ่งใหญ่ที่สุดคือความยาว 12 หลัก

ตัวเลขซ้ำ
จำนวน4 ชุดตัวเลขของแบบฟอร์มนี้... ab ... bc ... cd ... d , ปรากฏว่ามีการกระจายหนาแน่นกว่าที่ฉันค้นหา มี 69 โซลูชั่นน้อยกว่า10 ¹⁰⁰เมื่อเทียบกับ 32 โดยใช้ตัวเลขซ้ำ 3 ชุด ผู้ที่อยู่ระหว่าง10 ¹¹และ10 ¹⁰⁰มีดังนี้:

190000007777
700000011119
955666663333
47444444441111
66666622222399
280000000033333
1111333333334999
1111333333377779
1199999999900111
3355555666999999
2222233333000099
55555922222222233333
444444440004449999999
3366666633333333377777
3333333333999888883333
4441111113333333333311111
2222222293333333333333999999
999999999339999999977777777777
22222226666666222222222299999999
333333333333333333339944444444444999999999
559999999999933333333333339999999999999999
3333333333333333333111111111111666666666611111
11111111333330000000000000111111111111111111111
777777777770000000000000000000033333339999999999999999999999999
3333333333333333333333333333333333333333333333336666666977777777777777
666666666666666666611111113333337777777777777777777777777777777777777777
3333333333333333333888889999999999999999999999999999999999999999999999999933333333

มีการโต้แย้งแบบฮิวริสติกแบบง่าย ๆ ว่าทำไมถึงเป็นเช่นนั้น สำหรับความยาวดิจิตอลแต่ละชุดจะมีชุดซ้ำหลายชุด (เช่นชุดซ้ำ 3 ชุดหรือชุดซ้ำ 4 ชุด ฯลฯ ) ซึ่งจำนวนโซลูชันที่คาดหวังจะสูงที่สุด การเปลี่ยนแปลงเกิดขึ้นเมื่อจำนวนโซลูชันที่เป็นไปได้เพิ่มเติมซึ่งคิดเป็นอัตราส่วนมีมากกว่าความน่าจะเป็นที่จำนวนเพิ่มเติมที่จะตรวจสอบนั้นเป็นจำนวนมาก เมื่อพิจารณาถึงลักษณะเลขชี้กำลังของความเป็นไปได้ในการตรวจสอบและลักษณะลอการิทึมของการแจกแจงจำนวนเฉพาะสิ่งนี้เกิดขึ้นอย่างรวดเร็ว

ตัวอย่างเช่นหากเราต้องการค้นหาโซลูชัน 300 หลักการตรวจสอบตัวเลขซ้ำ 4 ชุดน่าจะเป็นวิธีสร้างโซลูชันมากกว่า 3 ชุดและ 5 ชุดน่าจะยังคงมีแนวโน้มมากขึ้น อย่างไรก็ตามด้วยพลังการประมวลผลที่ฉันมีอยู่ในมือการค้นหาโซลูชันที่มีขนาดใหญ่กว่า 100 หลักที่มี 4 ชุดจะอยู่นอกเหนือความสามารถของฉันให้อยู่คนเดียว 5 หรือ 6

222223333333 (12 หลัก)

ที่นี่ฉันค้นหา aa..aabb..bb ฟอร์แมตสูงสุด 100 หลักเท่านั้น เฉพาะเพลงฮิตอื่น ๆ คือ 23 37 53 73 113 311

รหัส J (ล้างข้อมูลแล้ว) (ขออภัยไม่มีคำอธิบาย):

a=.>,{,~<>:i.100
b=.>,{,~<i.10
num=.".@(1&":)@#~
p=.(*/"1@:((1&p:)@num) (]-"1(0,=@i.@#)))"1 1
]res=./:~~.,b (p#num)"1 1/ a

แก้ไข: มีคนทำการวิเคราะห์เชิงลึกมากกว่าที่ฉันทำที่นี่

ไม่ใช่วิธีการแก้ปัญหา แต่เป็นการประมาณคร่าวๆเกี่ยวกับจำนวนของวิธีแก้ปัญหาแบบ n หลัก

สร้างรหัส J

   ops=: 'title ','Estimated number of solutions by digits',';xcaption ','digits',';ycaption ','log10 #'
   ops plot 10^.((%^.)%(2&(%~)@^.@(%&10))^(10&^.))(10&^(2+i.100))

Javascript (กำลังดุร้าย)

ยังไม่พบจำนวนที่สูงขึ้น

http://jsfiddle.net/79FDr/4/

โดยไม่ต้องมีห้องสมุด bigint, JavaScript จะถูก จำกัด <= 2^53จำนวนเต็ม

เนื่องจากเป็น Javascript เบราว์เซอร์จะบ่นถ้าเราไม่ปล่อยเธรดการดำเนินการเพื่อให้ UI อัปเดตดังนั้นฉันจึงตัดสินใจติดตามว่าอัลกอริทึมนั้นอยู่ในขั้นตอนใดใน UI

function isPrime(n){
    return n==2||(n>1&&n%2!=0&&(function(){
        for(var i=3,max=Math.sqrt(n);i<=max;i+=2)if(n%i==0)return false;
        return true;
    })());
};

var o=$("#o"), m=Math.pow(2,53),S=$("#s");

(function loop(n){
    var s = n.toString(),t,p=true,i=l=s.length,h={};
    if(isPrime(n)){
        while(--i){
            t=s.substring(0,i-1) + s.substring(i,l); // cut out a digit
            if(!h[t]){   // keep a hash of numbers tested so we don't end up testing 
                h[t]=1;  // the same number multiple times
                if(!isPrime(+t)){p=false;break;}
            }
        }
        if(p)
            o.append($("<span>"+n+"</span>"));
    }
    S.text(n);
    if(n+2 < m)setTimeout(function(){
        loop(n+2);
    },1);
})(99444901133);

ลิงก์ไปยังการวิเคราะห์ปัญหาถูกโพสต์ แต่ฉันคิดว่ามันหายไปเล็กน้อย ลองดูตัวเลขหลัก m ประกอบด้วยลำดับ k ของตัวเลขที่เหมือนกัน 1 ตัวหรือมากกว่า มันแสดงให้เห็นว่าถ้าเราแบ่งตัวเลขออกเป็นกลุ่ม {0, 3, 6, 9}, {1, 4, 7} และ {2, 5, 8} โซลูชันจะไม่สามารถมีตัวเลขจากทั้งกลุ่มที่สองและกลุ่มที่สาม และต้องมีตัวเลข 3n + 2 หลักจากกลุ่มใดกลุ่มหนึ่งเหล่านี้ อย่างน้อยสองในลำดับ k จะต้องมีจำนวนเลขคี่ จากตัวเลข {1, 4, 7} เพียง 1 และ 7 สามารถเป็นตัวเลขต่ำสุด ไม่มี {2, 5, 8} ที่สามารถเป็นตัวเลขที่ต่ำที่สุด ดังนั้นจึงมีตัวเลือกสี่ (1, 3, 7, 9) หรือสอง (3, 9) ตัวเลือกสำหรับตัวเลขต่ำสุด

มีผู้สมัครกี่คน? เรามีการแยก m ตัวเลขในลำดับ k อย่างน้อย 1 หลัก มีวิธี (m - k + 1) มากกว่า (k - 1) ในการเลือกความยาวของลำดับเหล่านี้ซึ่งเป็นเรื่องเกี่ยวกับ (m - 1.5k + 2) ^ (k - 1) / (k - 1)! มี 2 ​​หรือ 4 ตัวเลือกสำหรับตัวเลขต่ำสุด, หกรวม มีตัวเลือกหกตัวสำหรับตัวเลขอื่น ๆ ยกเว้น 36/7 ตัวเลือกสำหรับตัวเลขสูงสุด รวมคือ (6/7) * 6 ^ k มี 2 ​​^ k วิธีในการเลือกว่าความยาวของลำดับนั้นเป็นเลขคู่หรือคี่ k + 1 ของสิ่งเหล่านี้ได้รับการยกเว้นเพราะไม่มีใครคนเดียวหรือแปลก เราคูณจำนวนตัวเลือกด้วย (1 - (k + 1) / 2 ^ k) ซึ่งก็คือ 1/4 เมื่อ k = 2, 1/2 เมื่อ k = 3, 11/16 เมื่อ k = 4 เป็นต้นจำนวน ของตัวเลขจากชุด {1, 4, 7} หรือ {2, 5, 8} ต้องเป็น 3n + 2 ดังนั้นจำนวนตัวเลือกจะถูกหารด้วย 3

การคูณตัวเลขเหล่านี้ทั้งหมดจำนวนผู้สมัครคือ

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (6/7) * 6^k * (1 - (k + 1) / 2^k) / 3

หรือ

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (2/7) * 6^k * (1 - (k + 1) / 2^k)

ผู้สมัครเองและหมายเลข k ที่ถูกสร้างขึ้นโดยการลบตัวเลขทั้งหมดจะต้องเป็นช่วงเวลา ความน่าจะเป็นที่เลขจำนวนเต็มแบบสุ่มรอบ N เป็นค่าเฉพาะคือประมาณ 1 / ln N ความน่าจะเป็นสำหรับตัวเลขหลักแบบสุ่มคือประมาณ 1 / (m ln 10) อย่างไรก็ตามตัวเลขที่นี่ไม่ได้สุ่ม พวกเขาทั้งหมดถูกเลือกให้ไม่หารด้วย 2, 3, หรือ 5. 8 จากจำนวนเต็ม 30 ตัวใด ๆ ที่ต่อเนื่องกันจะไม่หารด้วย 2, 3 หรือ 5 ดังนั้นความน่าจะเป็นที่จะเป็น (30/8) / (m ln 10) หรือประมาณ 1.6286 / m

จำนวนที่คาดหวังของการแก้ปัญหาเป็นเรื่องเกี่ยวกับ

(m - 1.5k + 2)^(k - 1) / (k - 1)! * (2/7) * 6^k * (1 - (k + 1) / 2^k) * (1.6286 / m)^(k + 1)

หรือขนาดใหญ่ประมาณ m

(1 - (1.5k - 2) / m)^(k - 1) / (k - 1)! * 0.465 * 9.772^k * (1 - (k + 1) / 2^k) / m^2

สำหรับ k = 2, 3, 4, ... เราได้รับดังต่อไปนี้:

k = 2: 11.1 * (1 - 1/m) / m^2
k = 3: 108 * (1 - 2.5/m)^2 / m^2 
k = 4: 486 * (1 - 4/m)^3 / m^2


k = 10: 10,065 * (1 - 13/m)^9 / m^2

จาก k = 10 เป็นต้นไปจำนวนจะลดลงอีกครั้ง