सबसे बड़ा प्राइम खोजें जिसकी लंबाई, योग और उत्पाद अभाज्य है

Question

संख्या 113पहला अभाज्य है जिसकी लंबाई 3अभाज्य है, डिजिटल राशि 5 = 1 + 1 + 3अभाज्य है, और डिजिटल उत्पाद 3 = 1 * 1 * 3अभाज्य है।

एक प्रधान जिसमें ये 3 गुण हैं, को सर्वोच्च प्रधान कहा जाएगा । प्रिम्स 11117और 1111151अन्य उदाहरण हैं।

लक्ष्य

एक प्रोग्राम है जो सबसे बड़ा पा सकते हैं लिखें सर्वोच्च प्रधानमंत्री (जैसे पसंदीदा कल्पना के रूप में नंबर एक घंटे से भी कम समय में संभव एक सभ्य आधुनिक व्यक्तिगत कंप्यूटर पर यहाँ )।

आपको हमें केवल एक बड़ा सर्वोच्च नहीं देना चाहिए। आपको हमें अपनी खोज प्रक्रिया को कोड के साथ दिखाना होगा जो वास्तव में काम करता है। आप अपने या अन्य लोगों के समाधान पर निर्माण कर सकते हैं लेकिन उन्हें क्रेडिट देना सुनिश्चित करें। हम सांप्रदायिक रूप से एक घंटे में एक सामान्य कंप्यूटर पर सबसे बड़ा सर्वोच्च प्राइमरी खोजने की कोशिश कर रहे हैं।

स्कोरिंग

प्रस्तुत है कि सबसे बड़ा सर्वोच्च प्रमुख जीतता है। अगर यह पता चलता है कि बारी-बारी से कई सर्वोच्च प्राइम हैं, तो पहला सबमिशन जो सर्वोच्च सर्वोच्च जीत उत्पन्न करता है।

(यदि आप गणितीय रूप से साबित कर सकते हैं कि या तो वहाँ हैं या असीम रूप से कई सर्वोच्च अपराध नहीं हैं, तो मैं आपको केवल 200 बार निरस्त कर दूंगा क्योंकि :)।

विवरण

• आप अपने primes (जैसे इंटरनेट) उत्पन्न करने के लिए किसी भी स्रोत का उपयोग कर सकते हैं।
• आप संभाव्य परीक्षण विधियों का उपयोग कर सकते हैं।
• सब कुछ बेस 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}।

Comments

क्या हम अपराधों की सूची के साथ शुरू कर सकते हैं, या इंटरनेट से एक सूची प्राप्त कर सकते हैं, और सुपरमैन की जाँच कर रहे घंटे खर्च कर सकते हैं?

— शुक्राणु

यदि आप सर्वोच्च ज्ञात सर्वोच्च प्राइम के साथ शुरू कर सकते हैं तो यह एक चुनौती बन जाता है कि कौन एक प्रोग्राम लिख सकता है जो दो सुप्रीम प्राइम्स के बीच सबसे बड़ा संभावित अंतर को पूरा करने में एक घंटा खर्च करता है। :(

— स्पर्म जूल

0 नहीं होने के बाद, किसी भी संभावित सर्वोच्च प्राइम को स्पष्ट रूप से 1 ^ n [3 | 5 | 7] 1 ^ m, अर्थात कुछ 1s, 10 से नीचे कोई भी अभाज्य और कुछ अधिक 1 s होना चाहिए। और भी अड़चनें हैं जिन्हें आप तुरंत दूर कर सकते हैं।

— इंगो बुर्क

रयान ने एमएसई पर एक संबंधित प्रश्न शुरू किया है क्योंकि असीम रूप से कई सर्वोच्च अपराधों का अस्तित्व है। यदि आपके पास उस प्रश्न के लिए कोई अंतर्दृष्टि है, तो कृपया वजन करें!

— अर्धवार्षिक

मैं आसानी से दिखा सकता हूं कि वर्तमान में सर्वोच्च अपराधों की एक अनंत संख्या का प्रमाण नहीं है (और यह कि काम का एक बड़ा हिस्सा इसकी ओर चला गया है)। Michaelnielsen.org/polymath1/… के अनुसार , हम जानते हैं कि अपराध 246 की तुलना में छोटे अंतराल के साथ होते हैं, लेकिन अनंत सर्वोच्च अपराधों के प्रमाण के लिए, हमें 2, 4, या 6 के अंतर की आवश्यकता होती है (जो कि primes के साथ संबंधित हैं) 3, 5, या 7 उनमें कहीं)।

— टिम एस।

Answer 1

पर्ल, 15101 अंक, {83} 7 {15017}, 8 मिनट। अधिकतम मिला: 72227 अंक

मेरे मॉड्यूल का उपयोग करना :: प्राइम :: यूटिल और इसका जीएमपी बैक एंड । इसमें ES_prob_prime () ES BPSW परीक्षण (Pari के ispseudoprime की तुलना में थोड़ा अधिक कठोर), is_prime () जो एक यादृच्छिक-आधार MR जोड़ता है और is_provable_prime () जो BLS75 T5 या ECPP चलाएगा , सहित कई सम्मिश्रण परीक्षण हैं । इन आकारों और प्रकारों पर, एक प्रमाण करने में एक लंबा समय लगने वाला है। मैं पांडित्य सत्यापनकर्ता उप में एक और एमआर परीक्षण में फेंक दिया। एक Core2 E7500 पर टाइम्स जो निश्चित रूप से मेरा सबसे तेज कंप्यूटर नहीं है (यह मेरे i7-4770K पर 2.5 मिनट लेता है)।

जैसा कि टिम एस बताते हैं, हम बड़े मूल्यों की खोज कर सकते हैं, उस बिंदु तक जहां एक एकल परीक्षण में एक घंटा लगता है। इस E7500 पर ~ 15000 अंकों पर एक एमआर परीक्षण के लिए 26 के बारे में और पूर्ण is_prime के लिए 2 मिनट लगते हैं (परीक्षण प्रभाग प्लस बेस -2 एमआर प्लस ईएस लुकास प्लस एक यादृच्छिक-आधार एमआर)। मेरा i7-4770K 3x से अधिक तेज है। मैंने कुछ आकारों की कोशिश की, मुख्य रूप से यह देखकर कि यह अन्य लोगों के परिणामों पर कैसे किया। मैंने 8k, 20k और 16k की कोशिश की, प्रत्येक को ~ 5 मिनट के बाद मार दिया। मैंने तब ~ 10 मीटर प्रत्येक के लिए प्रगति में 15k की कोशिश की और 4 वें पर भाग्यशाली रहा।

OpenPFGW के PRP परीक्षण निश्चित रूप से पिछले 4000 या इतने अंकों के बाद एक बार तेज होते हैं, और वास्तव में 50k + रेंज में बहुत तेज होते हैं। इसके परीक्षण में झूठी सकारात्मकता की एक उचित मात्रा है, जो इसे एक महान पूर्व-परीक्षण बनाता है, लेकिन कोई फिर भी परिणामों को कुछ और के साथ सत्यापित करना चाहेगा।

इसे पर्ल थ्रेड्स के साथ समानांतर किया जा सकता है या मॉड्यूल में समानांतर फाइबोनैचि प्राइम फाइंडर उदाहरणों के समान MCE का उपयोग किया जा सकता है।

एकल कोर का उपयोग करते हुए एक निष्क्रिय 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 मिनट, 15101 अंक, {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 के लिए मैंने क्रमिक स्क्रिप्ट को 500 के इनपुट वेतन वृद्धि में एक घंटे के लिए 6 रन दिया जब तक कि 57 मिनट में 57 परिणाम वापस नहीं आए। 72k अंकों का परिणाम 70k अप से लगातार primes कर रहा था, इसलिए निश्चित रूप से एक घंटे में नहीं मिला (हालांकि एक बार जब आप जानते हैं कि कहां से शुरू करना है, तो यह है)।

लिपी:

#!/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";
}

Comments

इस लाइब्रेरी से मुझे परिचित कराने के लिए +1! मेरी मशीन पर टाइमिंग 10 ^ 7 से कम की उम्र के पुनरावृत्तियों के लिए होती है (CPython के साथ gmpy2, और PyPy की तुलना में my_math): codepad.org/aSzc0esT

— primo

खुश हूँ कि आपने इसे पसंद किया! ऐसे अन्य तरीके हैं जिनमें forprimes { ...do stuff... } 1e7;10x या उससे अधिक तेज (कई महान विचारों के लिए Pari / GP के लिए kudos) शामिल हैं। मैं हमेशा प्रतिक्रिया की सराहना करता हूं, तो मुझे बताएं कि अगर कोई ऐसा काम नहीं कर रहा है जो आप चाहते हैं।

— दनाज

Answer 2

PyPon 2.7 PyPy पर, {2404} 3 {1596} (~ 10 ^ 4000)

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

4000 से शुरू होने के लगभग 50 मिनट बाद यह मिला। इसलिए, मुझे लगता है कि यह इस कोड दृष्टिकोण की ऊपरी सीमा है।

परिवर्तन: मैंने देखा है कि कुछ लंबाई दूसरों की तुलना में इस तरह के प्राइम को उत्पन्न करने के लिए अधिक फलदायी लगती है, इसलिए मैंने अंकों के केवल 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

Comments

मैं लिंक से ज्यादा कुछ नहीं जानता, दुर्भाग्य से। मुझे यहाँ लिंक मिला: codegolf.stackexchange.com/questions/10739/… पहला उत्तर

— isaacg

ठीक है फिर। मैं आपको श्रेय दूंगा।

— isaacg

यह ASCII की तरह है जहां वैली है ...

— ट्राइकोप्लाक्स

हो सकता है कि आपको फ़ंक्शन का नाम बदलना चाहिए is_very_very_very_very_very_very_very_probably_prime()...

— ट्राइकोप्लाक्स

Mathmatica और Maple दोनों एक ही विधि का उपयोग करते हैं, इसलिए यह सब बुरा नहीं हो सकता।

— प्रिमो जूल

Answer 3

PARI / GP, 4127 अंक

(१० ^{४१२ 5} -1) / ९ + २ * १० ^५१५

यह एक काफी सरल खोज है: केवल प्रमुख अंकों की लंबाई की जांच करें, फिर उपयोग करने के लिए संभावित अपराधों की गणना करें, फिर सभी संभावनाओं के माध्यम से पुनरावृति करें। मैंने उन सामान्य मामलों को विशेष रूप से कैस किया है जहाँ उपयोग के लिए 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 मिनट का समय लगा। यह एक घंटे में 5000 से अधिक अंकों का एक प्रमुख खोजने में कोई परेशानी नहीं होगी, मुझे यकीन है, लेकिन मैं भी अधीर हूं।

एक बेहतर समाधान यह होगा कि किसी भी उचित भाषा का उपयोग सब कुछ करने के लिए किया जाए लेकिन अंतरतम लूप, फिर प्राइमफॉर्म के लिए एक एबीसी फाइल का निर्माण करें जो कि उस विशेष प्रकार की गणना के लिए अनुकूलित हो। यह गणना को कम से कम 10,000 अंकों तक धकेलने में सक्षम होना चाहिए।

संपादित करें : मैंने ऊपर वर्णित हाइब्रिड समाधान को लागू किया है, लेकिन मेरी पुरानी मशीन पर मैं एक घंटे से भी कम समय में> = 10,000 अंकों के साथ पहला शब्द नहीं ढूंढ सकता। जब तक मैं इसे कुछ तेज़ी से नहीं चलाता, मुझे कम उदासीन लक्ष्य में बदलना होगा।

Comments

आप 4100 पर कैसे शुरू करना जानते हैं?

— isaacg

@isaacg: मैं सिर्फ (गलत) गणितज्ञ समाधान की तुलना में बड़ा होने की कोशिश कर रहा था, जो कि सिर्फ 4000 से अधिक था। मैं सिर्फ 'कुछ नहीं-मेरी-आस्तीन' संख्या के रूप में 100 के अगले एकाधिक में गया। वास्तव में ऐसा लगता है कि यह एक दुर्भाग्यपूर्ण शुरुआती जगह थी, क्योंकि मुझे एक प्राइम खोजने के लिए मेरी अपेक्षा से अधिक समय तक (और गणितज्ञ की तुलना में!) जाना था।

— चार्ल्स

नहीं, वास्तव में, आप अविश्वसनीय रूप से भाग्यशाली थे। (4127,3) 4100 के बाद पहली जोड़ी है, और शुद्ध संयोग से यह एक प्रमुख है। बहुत सारे जोड़े का कोई अभिप्राय नहीं है।

— isaacg

@ आइसाकग: शायद। मेरे उत्तराधिकार स्पष्ट रूप से बंद हैं, क्योंकि मैंने किसी जोड़े में एक प्रमुख को खोजने के लिए संभावना ~ 80% की उम्मीद की होगी: 1 - ऍक्स्प (-15 / (4 * लॉग 10)), लेकिन वे इससे कहीं अधिक दुर्लभ प्रतीत होते हैं, इसलिए यादृच्छिक आकार (2, 3, 5) की तरह काम न करें (जब तक कि मैं गणना से अलग न हो जाऊं) उनके आकार की संख्या।

— चार्ल्स

@isaacg: किसी भी मामले में मैं "बेहतर समाधान" पर काम कर रहा हूं जिसका मैंने अब उल्लेख किया है: कड़ी मेहनत को pfgw पर धकेलना। इसे 10 ^ 10000 से ऊपर की पहली 20 जोड़ियों को बिना कुछ पाए खोजा गया है, लेकिन इसमें केवल ~ 15 मिनट का समय लगा।

— चार्ल्स

Answer 4

गणितज्ञ 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}

इसका मतलब है कि अंक 1 के 3180 उदाहरण और अंक 7 का एक भी उदाहरण था।

अंक 7 किस स्थिति में है?

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

142

तो अंक 7 142 वां अंक है। बाकी सभी 1 के हैं।

---

बेशक, अंकों का गुणनफल 7 होना चाहिए।

digitProduct = Times @@ digits

7

---

और अंकों का योग भी एक प्रमुख है।

digitSum = Plus @@ digits
PrimeQ[digitSum]

3187
सच है

---

और हम जानते हैं कि अंकों की संख्या एक प्रमुख है। याद रखें, हमने 450 वां प्रधान चुना, जिसका नाम 3118 है।

इसलिए सभी शर्तों को पूरा किया गया है।

Comments

अगर मैं गलत नहीं हूं, तो इसका योग 4009 है जो कि प्रमुख नहीं है।

— gerw

एक बात: क्या यह उन सभी अंकों का योग नहीं होना चाहिए जो अभाज्य है और अंकों की संख्या नहीं है? आपके मामले में आपको परीक्षण करना होगा 4002 * 1 + 7 = 4009और कल्पना के अनुसार 4003 नहीं।

— जॉनराइड

@ जॉनराइड: दोनों प्राइम होने चाहिए।

— gerw

@gerw सही है। अंकों की संख्या और अंकों का योग और अंकों का गुणनफल सभी का अभाज्य होना चाहिए।

— केल्विन के

आप सभी सही थे। अपने पहले के सबमिशन में मैं प्राइमलिटी के लिए अंकों के योग की जांच करना भूल गया। यह अब यह देखने के द्वारा किया जाता है कि क्या निम्न में से कोई एक (यह कोई फर्क नहीं पड़ता) कौन सा है: अंक की लंबाई + 2, अंक की लंबाई _4, या अंक की लंबाई +6।

— डेविड ०

Answer 5

पायथन 2.7, 6217 अंक: {23} 5 {6193} 6 मिनट 51 सेकंड

मैं अपने स्वयं के संस्करण पर काम कर रहा था और यह देखकर निराश था कि @issacg ने मुझे बहुत ही समान दृष्टिकोण के साथ पंच के लिए पीटा था, इसके साथ is_ (very_probably) _prime ()। हालांकि, मैं देखता हूं कि मेरे कुछ महत्वपूर्ण अंतर हैं, जिनके परिणामस्वरूप कम समय में बेहतर जवाब मिलता है (जब मैं is_prime का भी उपयोग करता हूं)। यह स्पष्ट करने के लिए, जब 4000 से शुरू होता है, तो मैं केवल 26 मिनट, 37 सेकंड में मानक पायथन दुभाषिया (संस्करण 2.7 पर भी) का उपयोग करते हुए 4001 अंकों के बेहतर उत्तर ({393} 7 {3607}) पर पहुंचता हूं, PyPy नहीं संस्करण। इसके अलावा, मैं संख्याओं की जाँच 'स्पॉट' नहीं कर रहा हूँ। सभी उम्मीदवारों की जाँच की जाती है।

यहां प्राथमिक सुधार हैं:

1. प्राइमरों की सूची बनाने के लिए प्राइम जनरेटर ( https://stackoverflow.com/questions/567222/simple-prime-generator-in-python/568618#568618 ) का उपयोग करें और उसके ("छोटे अपराधों के संस्करण") की जाँच करें। और पात्र संख्या की लंबाई पैदा करने के लिए।

2. हम अपना समय किसी दिए गए लंबाई के सबसे बड़े सर्वोच्च प्रधान की तलाश में बिताना चाहते हैं, न कि सबसे छोटा, इसलिए, मैं सबसे बड़ी संभव संख्याओं की जाँच सबसे पहले करता हूँ, न कि सबसे छोटी। फिर, एक बार मिल जाने के बाद, हम तुरंत अगली लंबाई की ओर बढ़ सकते हैं।

संपादित करें: अब मल्टीप्रोसेसिंग के साथ

यह पिछले संस्करणों में एक महत्वपूर्ण बदलाव है। इससे पहले, मैंने देखा कि मेरी 8-कोर मशीन शायद ही काम कर रही थी, इसलिए, मैंने पायथन (पहली बार) में मल्टीप्रोसेसिंग में अपना हाथ आजमाने का फैसला किया। परिणाम बहुत अच्छे हैं!

इस संस्करण में, 7 बच्चों की प्रक्रियाओं को जन्म दिया जाता है, जो संभावित संभावनाओं (num_length + योग्य अंकों) की एक कतार से 'कार्य' को पकड़ लेते हैं। वे अलग-अलग [7,5,3] पदों को पाने की कोशिश करते हैं, जब तक कि यह एक नहीं मिल जाता। यदि ऐसा होता है, तो नई सबसे लंबी लंबाई की मास्टर प्रक्रिया को सूचित करता है जो कि मिली है। यदि बच्चे एक num_length पर काम कर रहे हैं जो कम है, तो वे बस जमानत करते हैं, और अगली लंबाई प्राप्त करते हैं।

मैंने इसे 6000 के साथ शुरू किया था, और यह अभी भी चल रहा है, लेकिन अभी तक, मैं परिणामों से बहुत खुश हूं।

कार्यक्रम अभी तक सही ढंग से बंद नहीं हुआ है, लेकिन मेरे लिए बहुत बड़ी बात नहीं है।

अब कोड:

#!/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))

Comments

यदि आप कोडपैड लिंक को [टूटा हुआ, यदि आवश्यक हो] आयात के रूप में प्रतिनिधित्व करते हैं तो यह अधिक साफ-सुथरी तरह से पढ़ा जाएगा

— Sparr

मुझे लगता है कि यह भ्रामक होगा, क्योंकि दूसरे छोर पर कोड वास्तव में उस तरह से आयात करने योग्य नहीं है।

— मोकेस्टिनन

isaacg के सिंटैक्स का उपयोग करें। URL पर टिप्पणी करें, फिर एक समरूप पैकेज (my_math, उसके मामले में) से आयात करें

— Sparr

दरअसल, मैं सबसे बड़ी से लेकर सबसे छोटी तक की संख्या भी उत्पन्न करता हूं। मुझे नहीं लगता कि हमारे कोड अंतर बहुत महत्वपूर्ण हैं। मुझे उम्मीद है कि हमारे कोड की तुलना में हमारे कंप्यूटरों में अधिक अंतर होगा। फिर भी, अच्छी तरह से किया है, और साइट पर आपका स्वागत है।

— isaacg

my_mathभी primes की एक सूची उत्पन्न करने के लिए इस्तेमाल किया जा सकता है, एक ला while prime < 20006: prime = next_prime(prime)। लगता है के रूप में उपवास के रूप में 3 गुना gen_primes, और कहीं अधिक स्मृति कुशल है।

— प्रिमो

Answer 6

सी, जीएमपी - {7224} 5 {564} = 7789

Kudos @ प्रेरणास्रोत और चाल के लिए आप सभी लोगों को।
और इस प्रश्न के लिए भी मास्टरफुल प्रश्नकर्ता @ केल्विन के शौक।

संकलित करें: gcc -I/usr/local/include -o p_out p.c -pthread -L/usr/local/lib -lgmp

अगर आपको ऐसा लगता है कि अपनी गणना शक्ति या प्रदर्शन में उत्सुकता है, तो कोड को कॉपी करें और संकलन करें। ;) आपको स्थापित जीएमपी की आवश्यकता होगी।

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

Answer 7

PFGW, 6067 अंक, {5956} 7 {110}

भागो PFGW निम्नलिखित इनपुट फ़ाइल के साथ और -f100संख्या prefactor करने के लिए। मेरे कंप्यूटर (i5 हैसवेल) पर लगभग 2-3 सीपीयू मिनटों में, यह PRP (10 ^ (6073-6) -1) / 9 + 6 * 10 ^ 110, या {5956} 7 {110} का पता लगाता है । मैंने 6000 अंकों को एक शुरुआती बिंदु के रूप में चुना, जो कि मेरे पिछले-स्लेम संख्या से कुछ अधिक है।

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

इस आधार पर कि मैं इसे कितनी जल्दी पा सकता था, मैं आसानी से अंकों की संख्या से टकरा सकता था और अभी भी एक घंटे के भीतर पीआरपी खोज सकता हूं। नियमों को कैसे लिखा जाता है, मैं भी सिर्फ उस आकार को पा सकता हूं जहां मेरा सीपीयू, सभी 4 कोर पर चल रहा है, एक घंटे में एक पीआरपी परीक्षण समाप्त कर सकता है, पीआरपी खोजने के लिए एक लंबा समय ले सकता है और मेरी "खोज" पूरी तरह से सम्‍मिलित है एक पीआरपी का।

PS कुछ अर्थों में, यह एक "कोड" समाधान नहीं है क्योंकि मैंने इनपुट फ़ाइल के अलावा कुछ भी नहीं लिखा था ... लेकिन फिर, गणितीय समस्याओं के लिए कई एक-पंक्ति वाले गणितज्ञ समाधानों को उसी तरह वर्णित किया जा सकता है, जैसा कि हो सकता है। एक पुस्तकालय का उपयोग करना जो आपके लिए कड़ी मेहनत करता है। वास्तव में, मुझे लगता है कि दोनों के बीच एक अच्छी रेखा खींचना कठिन है। यदि आप चाहें, तो मैं एक स्क्रिप्ट लिख सकता हूं जो PFGW इनपुट फ़ाइल बनाता है और PFGW कहता है। स्क्रिप्ट भी समानांतर में खोज सकती है, सभी 4 कोर का उपयोग करने के लिए और ~ 4 ​​गुना (मेरे सीपीयू पर) द्वारा खोज को गति दें।

पीपीएस मुझे लगता है कि एलएलआर इन नंबरों के लिए पीआरपी परीक्षण कर सकता है, और मुझे उम्मीद है कि यह पीएफजीडब्ल्यू की तुलना में कहीं अधिक तेज होगा । PFGW के एक-बार की तुलना में इन नंबरों को फैक्टर करने के लिए एक समर्पित sieving प्रोग्राम भी बेहतर हो सकता है। यदि आपने इन्हें संयोजित किया है, तो मुझे यकीन है कि आप सीमा को वर्तमान समाधानों की तुलना में बहुत अधिक बढ़ा सकते हैं।

Answer 8

पायथन 2.7, 17-19 अंक

11111111171111111

3 सेकंड में 5111111111111 (13 अंक) मिला और 3 मिनट में यह 17 अंकों का सर्वोच्च अंक है। मुझे लगता है कि लक्ष्य मशीन इसे चला सकती है और एक घंटे से भी कम समय में 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

Answer 9

गणितज्ञ 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]

थ्रो इसका कारण बनता है अन्य अंकों के लिए परीक्षण को उसी अंक के साथ रोकना जैसा कि वर्तमान में पाया गया है। चूंकि यह सबसे महत्वपूर्ण अंक का परीक्षण शुरू करता है, इसका मतलब यह होगा कि यह हमेशा सबसे बड़ी संख्या देता है जब तक कि अंकों की संख्या एक प्रमुख ट्रिपल का सदस्य नहीं है।

बस पूर्ववर्ती उत्तरों में से एक के मूल्य के नीचे परीक्षण शुरू किया :)

एक बार जब यह खत्म हो जाता है, तो संख्या को चर में संग्रहीत किया जाता है

Answer 10

जावास्क्रिप्ट, 3019 अंक, {2,273} 5 {745}

यह टॉम वू द्वारा BigInteger.js में शामिल मिलररबीन टेस्ट का उपयोग करता है।

से शुरू 0 => 2,046 अंक = {1799} 7 {263} एक घंटे में ।

3000 => 3,019 अंकों से शुरू होकर {{2,273} 5 {745} एक घंटे में, कम 3 सेकंड ।

जब यह 0 से शुरू हुआ, तो प्रोग्राम आगे खिसक गया और 1.5 s की लंबाई में फिर से खोजना शुरू किया, जो पिछले s-prime की लंबाई पाया गया। फिर जब मैंने देखा कि यह कितनी तेजी से चल रहा है तो मैंने अनुमान लगाया कि यह एक घंटे में 3000 से शुरू होगा - जिसे उसने केवल 3 सेकंड के लिए छोड़ दिया।

आप इसे यहाँ आज़मा सकते हैं: http://goo.gl/t3TmTk
(सभी s-primes की गणना करने के लिए सेट करें, या आगे सक्षम करें।)

कार्यक्रम सभी "1" के तार का निर्माण करके काम करता है, लेकिन एक "3", "5", या "7" के साथ। मैंने "5" में समाप्त होने वाली संख्या को अस्वीकार करने के लिए IsStrPrime फ़ंक्शन में एक त्वरित चेक जोड़ा।

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

यह बहुत मजेदार था। मुझे एक पहेली की याद दिलाता है कि मैंने गणना करने के लिए कई साल पहले क्या किया था जिसे एक अंक निकाला गया प्रधान कहा जाता है । यह एक अभाज्य संख्या है यदि आप किसी अंक को हटाते हैं, तो शेष संख्या अभी भी अभाज्य है। उदाहरण के लिए 1037 एक हटाया गया अभाज्य है क्योंकि 1037, 037, 137, 107 और 103 प्रमुख हैं। मैंने एक 84 अंक लंबा पाया, और सबसे लंबा मुझे पता है कि 332 अंक लंबा है। मुझे यकीन है कि हम इस पहेली के लिए इस्तेमाल की जाने वाली तकनीकों के साथ एक लंबे समय तक मिल सकते हैं। (लेकिन ट्रायल नंबर चुनना थोड़ा मुश्किल है - शायद?)

Comments

RE: अंकों को हटा दिया गया प्राइम, हमने यहां एक लिया है । 332 अंक भी जीत गए होंगे।

— प्रिमो

Answer 11

Axiom, 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

529 सेकंड में प्रारंभ मूल्य 3000 से परिणाम

(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