इन दिनों समग्र होना कठिन और कठिन होता जा रहा है

Question

एक गैर खाली सूची को देखते हुए एल से अधिक पूर्णांकों का 1 , हम परिभाषित घ (एल) सबसे छोटी सकारात्मक पूर्णांक ऐसा है कि के रूप में n + घ (एल) है समग्र प्रत्येक के लिए एन में एल ।

हम अनुक्रम को _{n के} रूप में परिभाषित करते हैं :

• एक ₀ = 2
• एक _{i + 1} की तुलना में छोटी से छोटी पूर्णांक अधिक है एक _मैं ऐसा है कि घ (क ₀ , ..., एक _मैं , एक _{i + 1} )> घ (क ₀ , ..., एक _मैं )

आपका कार्य

आप या तो:

• पूर्णांक N लें और अनुक्रम का N-th शब्द लौटाएं (0-अनुक्रमित या 1-अनुक्रमित)
• एक पूर्णांक N लें और अनुक्रम के पहले N पदों को वापस करें
• कोई इनपुट न लें और अनुक्रम हमेशा के लिए प्रिंट करें

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

यदि आपका कोड N जितना बड़ा हो रहा है, तो यह ठीक है , लेकिन इसे कम से कम 2 मिनट में 20 पहले शब्द ढूंढने चाहिए।

पहली शर्तें

• एक ₀ = 2 और डी (2) = 2 (हमें 2 जोड़ने की आवश्यकता है ताकि 2 + 2 समग्र हो)
• एक ₁ = 3 क्योंकि घ (2, 3) = 6 (हम 6 ताकि 2 + 6 और 3 + 6 मिश्रित कर रहे हैं जोड़ने की जरूरत है)
• a ₂ = 5 क्योंकि d (2, 3, 5) = 7 (हमें 7 जोड़ने की आवश्यकता है ताकि 2 + 7, 3 + 7 और 5 + 7 सभी समग्र हों), जबकि d (2, 3, 4) अभी भी है 6 के बराबर
• आदि।

नीचे अनुक्रम की 100 पहली शर्तें हैं (पोस्टिंग के समय ओईआईएस पर अज्ञात)।

  2,   3,   5,   6,  10,  15,  17,  19,  22,  24,
 30,  34,  35,  39,  41,  47,  51,  54,  56,  57,
 70,  79,  80,  82,  92,  98, 100, 103, 106, 111,
113, 116, 135, 151, 158, 162, 165, 179, 183, 186,
191, 192, 200, 210, 217, 223, 226, 228, 235, 240,
243, 260, 266, 274, 277, 284, 285, 289, 298, 307,
309, 317, 318, 329, 341, 349, 356, 361, 374, 377,
378, 382, 386, 394, 397, 405, 409, 414, 417, 425,
443, 454, 473, 492, 494, 502, 512, 514, 519, 527,
528, 560, 572, 577, 579, 598, 605, 621, 632, 642

Answer 1

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

Pu+GfP_+Tf!fP_+ZYG)eGQ]2

प्रदर्शन

असल में, हम इसके साथ शुरू करते हैं [2], फिर तत्वों को एक बार में वैकल्पिक रूप से खोजकर 1 जोड़ते हैं d, फिर एक तत्व जोड़ते हैं, और आगे। nअनुक्रम के पहले तत्वों को आउटपुट करता है ।

एक बार-बार लूप के अंदर पहले पूर्णांक फ़िल्टर के अंदर पहले पूर्णांक फ़िल्टर के अंदर एक फ़िल्टर होता है।

स्पष्टीकरण:

Pu+GfP_+Tf!fP_+ZYG)eGQ]2
 u                   Q]2    Starting with `[2]`, do the following as many times
                            as the input
         f        )         Starting from 1 and counting upward, find d where
          !f     G          None of the elements in the current list
            P_+ZY           plus d give a prime.
    f              eG       Starting from the end of the current list and counting
                            upward, find the first number which
     P_+T                   plus d gives a prime.
  +G                        Append the new number to the current list
P                           Trim the last element of the list

दोनों के बीच स्पष्ट रूप से दोहराया प्रयास है "जोड़ें और जांचें कि क्या प्राइम" कॉल करता है, लेकिन मुझे यकीन नहीं है कि इसे कैसे खत्म किया जाए।

Answer 2

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

ṛ,;1+ÆPẸṆʋ1#ⱮẎ</
Ḷ߀‘Ṫç1#ƊḢƲ2⁸?

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

जेली पुनरावृत्ति अनुक्रम में बेकार है। : /

Answer 3

रेटिना , 74 बाइट्स

K`__;
"$+"{/;(?!(__+)\1+\b)/+`;
;_
.+$
$&¶$&
)/;(__+)\1+$/+`.+$
_$&_
%`\G_

इसे ऑनलाइन आज़माएं! 0 अनुक्रमित। स्पष्टीकरण:

K`__;

प्रत्येक पंक्ति iworkarea में दो एकल मान हैं, aᵢ;d+aᵢ। हम शुरुआत करते हैं a₀=2और d+a₀=0(क्योंकि यह गोल्फ खिलाड़ी है)।

"$+"{
...
)

लूप Nबार दोहराएं ।

/;(?!(__+)\1+\b)/+`

कम से कम एक गैर-संयुक्त संख्या होने पर दोहराएं।

;
;_

वृद्धि d।

.+$
$&¶$&

अंतिम पंक्ति डुप्लिकेट, कॉपी करने aᵢ₋₁के लिए aᵢ।

/;(__+)\1+$/+`

कंपोज करते समय दोहराएं d+aᵢ।

.+$
_$&_

वृद्धि aᵢ।

%`\G_

परिणामों को दशमलव में बदलें।

Answer 4

क्लीन , 138 130 128 बाइट्स

import StdEnv
$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2])

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

विस्तारित:

$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1
$l=until(                                         )inc 1  // first value from 1 upwards where _
         \v=all(                                )l        // _ is true for everything in l
                \n=any(              )[2..n+v-1]          // any of [2,3..n+v-1] match _
                             gcd(n+v)                     // the gcd of (n+v) and ^
                           o                              // (composed) ^ is _
                       (<)1                               // greater than 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2]) 
map hd(                                                 ) // the first element of each list in _
       iterate(                                     )[2]  // infinite repeated application of _ to [2]
               \l=hd[                              ]      // the head of _
                     [n:l]                                // n prepended to l
                          \\n<-[hd l..]                   // for every integer n greater than the head of l
                                       | $[n:l]> $l       // where d(n0..ni+1) > d(n0..ni)

Answer 5

जूलिया 0.6 , 145 130 बाइट्स

~L=(x=1;while any(map(m->all(m%i>0 for i=2:m-1),L+x));x+=1;end;x)
!n=n<1?[2]:(P=!(n-1);t=P[end]+1;while ~[P;t]<=~P;t+=1;end;[P;t])

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

-15 मेरे नए और बेहतर गोल्फ कौशल का उपयोग करते हुए बाइट्स - ऑपरेटर ओवरलोड्स, टर्नरी द्वारा सशर्त की जगह और इसलिए returnकीवर्ड कीवर्ड।)

विस्तारित :

function primecheck(m)
    all(m%i>0 for i∈2:m-1)
end

function d(L)
    x = 1
    while any(map(primecheck, L+x))
        x += 1
    end
    return x
end

function a(n)
    n > 0 || return [2]
    Prev = a(n-1)
    term = Prev[end] + 1
    while d([Prev;term]) ≤ d(Prev)
        term += 1
    end
    return [Prev;term]
end