गिलब्रेट का अनुमान

Question

मान लें कि हम अभाज्य संख्याओं की अनंत सूची से शुरू करते हैं:

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, ...

फिर, हम प्रत्येक जोड़ी के बीच, बार-बार होने वाले पूर्ण अंतरों को लेते हैं:

[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, ...
[1, 0, 2, 2, 2, 2, 2, 2, 4, 4, 2, 2, 2, 2, 0, 4, 4, 2, ...
[1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 4, 0, 2, ...
[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

ध्यान दें कि हर बार अग्रणी संख्या 1 है। गिल्ब्रेथ का अनुमान भविष्यवाणी है कि यह हमेशा के लिए जारी रहता है।

एकमात्र तरीका अग्रणी संख्या 1 होना बंद हो जाएगा यदि अगला नंबर न तो 0 था और न ही 2। दूसरा नंबर 0 या 2 नहीं होगा एकमात्र तरीका यह है कि उसके बाद का नंबर न तो था 0 और न ही 2. और इतने पर।

सबसे बड़ी संख्या का सूचकांक, जो कि अग्रणी 1 के अलावा है, जो कि न तो 0 है और न ही 2 है, क्रम की एक जोड़ी के बीच कभी भी 1 से अधिक नीचे नहीं जा सकता है। इस तथ्य का उपयोग बहुत मजबूत निचली सीमा पर करने के लिए किया गया है, अगर कभी भी, एक अनुक्रम में पहले तत्व के रूप में 1 नहीं हो सकता है।

इस चुनौती में, आपको एक अनुक्रम का सूचकांक दिया जाएगा, और आपको उस क्रम में पहली संख्या के सूचकांक का उत्पादन करना होगा जो कि अग्रणी 1 नहीं है, और 0 या 2 नहीं है।

उदाहरण के लिए, ऊपर 4 के पूर्ण अंतर अनुक्रम में:

[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

पहली प्रविष्टि जो न तो शून्य है और न ही पहली प्रविष्टि के अलावा कोई अन्य, 15 वीं स्थिति है, 14 शून्य अनुक्रमित है। तो अगर इनपुट 4 था, तो आप 14 आउटपुट करेंगे।

1 से 30 तक इनपुट के लिए, आउटपुट होना चाहिए:

[3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176, 176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

यह OEIS A000232 है ।

यह मान रहा है कि आपके पास 1 अनुक्रमित इनपुट और 0 अनुक्रमित आउटपुट हैं। जब तक आप सभी अनुक्रमों के अनुरूप इनपुट की सीमा को स्वीकार कर सकते हैं, तब तक आप किसी भी निरंतर पूर्णांक पर अपने इनपुट और आउटपुट को इंडेक्स कर सकते हैं।

आवश्यकताएँ: आपका समाधान 30 तक के इनपुट पर अधिकतम 1 मिनट में चलना चाहिए। यदि यह पर्याप्त है कि यह कंप्यूटर चश्मा पर निर्भर करता है, तो इसकी अनुमति है।

सबसे छोटा कोड जीतता है।

Comments

क्या मैं अपना इनपुट 2-इंडेक्स कर सकता हूं?

— लीक नून

@LeakyNun ज़रूर।

— इसहाक

क्या आउटपुट इनपुट- आधारित इंडेक्सिंग का उपयोग कर सकता है ?

— लुइस मेंडो

@LuisMendo सही, तय। नहीं, अनुक्रमण एक स्थिर होना चाहिए।

— isaacg

Answer 1

जेली , 17 बाइट्स

ÆNạ2\Ḋ¿Ḣ’Ị
R‘ÇпL

इसे ऑनलाइन आज़माएं!

इनपुट 2-इंडेक्सिंग है। आउटपुट 1-इंडेक्सिंग है।

TIO पर सभी टेस्टकेस में कुल 22.309 s लगते हैं।

Answer 2

मैथेमेटिका, 66 बाइट्स

(For[z=1,Last@Nest[Abs@*Differences,Array[Prime,z+#],#]<3,z++];z)&

शुद्ध फ़ंक्शन एक सकारात्मक पूर्णांक को तर्क के रूप में लेता है और 1-अनुक्रमित पूर्णांक वापस करता है। वें पहले primes की सूची की पुनरावृत्त निरपेक्ष अंतर सूची की Nest[Abs@*Differences,Array[Prime,z+#],#]गणना करता है । जब तक परिणामी सूची का अंतिम तत्व कम से कम है , और तब आउटपुट है , तब तक इस गणना को बंद कर देता है। (ध्यान दें कि एल्गोरिथ्म की शुद्धता गिल्ब्रेथ के अनुमान को मानती है!)#z+#For[z=1,Last@...<3,z++]3z

Answer 3

पायथ , 32 बाइट्स

-l.W>3h.WtHaVZtZ>QH+ZfP_TheZ.fP_

इसे ऑनलाइन आज़माएं!

2-अनुक्रमण का उपयोग करता है।

Answer 4

MATL , 18 बाइट्स

`@:YqG:"d|]3<A}@G-

इनपुट और आउटपुट 1-आधारित हैं। परीक्षण के प्रत्येक मामले में TIO में 40 सेकंड से कम समय लगता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

जब तक पुनरावृत्त निरपेक्ष लगातार अंतर कम से कम एक मूल्य से अधिक देते हैं, तब तक यह अपराधों के प्रारंभिक अनुक्रमों की कोशिश करता रहता है 2।

`        % Do... while loop
  @:Yq   %   Array of first k primes, where k is iteration index
  G:"    %   Do this as many times as the input
    d|   %     Absolute value of consecutive differences
  ]      %   End
  3<A    %   Are they all less than 3? This is the loop condition
}        % Finally (execute before exiting loop)
  @G-    %   Push last iteration index minus input. This is the output
         % End (implicit). Continue with next iteration if top of stack is true
         % Display (implicit)

Answer 5

पर्ल 6 , 136 120 बाइट्स

{->\i,\n{i??&?BLOCK(i-1,lazy
n.rotor(2=>-1).map: {abs .[1]-.[0]})!!1+n.skip.first:
:k,none 0,2}($_,grep &is-prime,2..*)}

Ungolfed:

{   # Anonymous function with argument in $_
    sub f(\i, \n) {  # Recursive helper function
        if i != 0 {  # If we're not done,
            # Recurse on the absolute differences between adjacent entries:
            f(i - 1, lazy n.rotor(2 => -1).map: { abs .[1] - .[0] });
        } else {
            # Otherwise, return the first index after 0
            # where the value is neither 0 nor 2.
            1 + n.skip.first: :k, none 0, 2;
        }
    }
    # Call the helper function with the argument passed to the top-level
    # anonymous function (the recursion depth), and with the prime numbers
    # as the initial (infinite, lazy) list:
    f($_, grep &is-prime, 2 .. *);
}

30 के इनपुट के साथ, फ़ंक्शन मेरे मामूली लैपटॉप पर लगभग चार सेकंड में चलता है।

... जो मेरे सात महीने पुराने पर्ल 6 इंस्टॉलेशन को अपग्रेड करने के बाद 1.4 सेकंड का हो जाता है (जो मुझे वह skipतरीका भी देता है जिससे मैं अपने पहले समाधान से कई बाइट्स निकाल सकता हूं)। 1 से 30 तक के सभी परीक्षण मामलों में लगभग दस सेकंड लगते हैं।

Answer 6

हास्केल , 94 बाइट्स

f(a:b:r)=abs(a-b):f(b:r)
length.fst.span(<3).(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)

इसे ऑनलाइन आज़माएं! अंतिम पंक्ति एक अनाम फ़ंक्शन है। जैसे बाँधो और जैसे gपुकारो g 4। सभी परीक्षण मामले संयुक्त रूप से TIO पर 2 सेकंड से कम समय लेते हैं।

यह काम किस प्रकार करता है

[n|n<-[2..],all((>0).mod n)[2..n-1]]एक अनंत सूची बनाता है।
f(a:b:r)=abs(a-b):f(b:r)एक अनंत सूची के तत्वों के पूर्ण अंतर से उपजने वाला एक कार्य है। एक संख्या को देखते हुए n, प्रिम्स की सूची में कई बार (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)लागू होता है f n। length.fst.span(<3)परिणामी सूची के उपसर्ग की लंबाई की गणना करता है जहां तत्व 3 छोटे होते हैं।

Answer 7

Axiom, 289 बाइट्स

g(n:PI):PI==(k:=n*10;c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)];repeat(a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)]);j:=0;c:=a;repeat(j=n=>break;j:=j+1;b:=a;a:=[abs(b.(i+1)-b.i)for i in 1..(#b-1)]);j:=2;repeat(j>#a=>break;a.j~=2 and a.j~=1 and a.j~=0=>return j-1;j:=j+1);k:=k*2))

यह ungolf और परीक्षण

f(n:PI):PI==
  k:=n*10
  c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)]
  repeat
    a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)])
    j:=0;c:=a
    repeat
       j=n=>break
       j:=j+1
       b:=a
       a:=[abs(b.(i+1)-b.i)  for i in 1..(#b-1)]
    j:=2
    repeat
       j>#a=>break
       a.j~=2 and a.j~=1 and a.j~=0 => return j-1
       j:=j+1
    k:=k*2

(4) -> [g(i)  for i in 1..30]
   (4)
   [3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176,
    176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

यदि यह समाधान नहीं मिल रहा है, तो एक लूप में 2 * x की प्राइम सूची का विस्तार करें और सभी शेष सूचियों को फिर से खोलें। खोज के लिए 3 सेकंड g (30)