फ्रैक्टल स्मोक सीक्वेंस

Question

परिचय

A229037 में एक बहुत ही पेचीदा साजिश है (कम से कम पहले कुछ शब्दों के लिए):

अनुमान है, कि यह वास्तव में किसी प्रकार की भग्न संपत्ति हो सकती है।

इस क्रम का निर्माण कैसे किया जाता है?

परिभाषित करें a(1) = 1, a(2) = 1तो प्रत्येक के लिए n>2पूर्णांक एक न्यूनतम सकारात्मक लगता है a(n)ऐसा है कि हर गणित 3 अवधि दृश्य के लिए n,n+k,n+2kसूचकांकों की, अनुक्रम के संगत मानों a(n),a(n+k),a(n+2k)है नहीं अंकगणितीय अनुक्रम।

चुनौती

nइनपुट के रूप में एक धनात्मक पूर्णांक को देखते हुए , इस क्रम के पहले nशब्दों a(1), ... , a(n)को आउटपुट करें । (किसी भी उचित स्वरूपण के साथ। संभावित अग्रणी / प्रशिक्षण वर्ण / तार अप्रासंगिक हैं।)

इस अनुक्रम को उपलब्ध करने के लिए स्निपेट हैं, लेकिन मुझे लगता है कि अन्य दृष्टिकोण कुछ भाषाओं के लिए अधिक गोल्फ / अधिक उपयुक्त हो सकते हैं।

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

पहले कुछ परीक्षण मामले:

1, 1, 2, 1, 1, 2, 2, 4, 4, 1, 1, 2, 1, 1, 2, 2, 4, 4, 2, 4, 4, 5, 5, 8, 5, 5, 9, 1, 1, 2, 1, 1, 2, 2, 4, 4, 1, 1, 2, 1, 1, 2, 2, 4, 4, 2, 4, 4, 5, 5, 8, 5, 5, 9, 9, 4, 4, 5, 5, 10, 5, 5, 10, 2, 10, 13, 11, 10, 8, 11, 13, 10, 12, 10, 10, 12, 10, 11, 14, 20, 13

अधिक टेस्टकेस:

  a(100)  =   4
  a(500)  =   5
 a(1000)  =  55
 a(5000)  =  15
a(10000)  = 585

सभी शर्तें n=100000यहां उपलब्ध हैं: https://oeis.org/A229037/b229037.txt

धन्यवाद @ मार्टिनबटनर की मदद और प्रोत्साहन के लिए।

Comments

अरे, मैंने यह ग्राफ पहले कहाँ देखा है? :

— लुइस मेंडो

अपने सिर को कुछ बाईं ओर शिफ्ट करें, थोड़ा सा ज़ूम करें, वहां आप जाएं! (:

— दोष

एक संख्यापूर्ण वीडियो बस पॉप अप किया गया: youtube.com/watch?v=o8c4uYnnNnc

— त्रुटी

मुझे यकीन है कि उसका कोड लगभग गोल्फ जैसा नहीं है!

— लुइस मेंडो

Answer 1

पायथन 2, 95 बाइट्स

l=[];n=input()
exec"a=min(set(range(n))-{2*b-c for b,c in zip(l,l[1::2])});print-~a;l=[a]+l;"*n

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

? 4 2 2 1 1 2 1 1   a b c
^ ^ ^               ? 4 2
^   ^   ^           ? 2 1
^     ^     ^       ? 2 2
^       ^       ^   ? 1 1

अन्य संख्याओं के युग्मित सदस्य lऔर हर दूसरे तत्व हैं l, इसलिए zip(l,l[1::2])। यदि यह जोड़ी है (b,c)तो अंकगणितीय प्रगति (a,b,c)होती है a=2*b-c। aसे बचने के लिए सेट जनरेट करने के बाद , कोड न्यूनतम पूरक लेता है, इसे प्रिंट करता है, और इसे सूची में प्रस्तुत करता है। (दरअसल, अभिकलन संख्या 1 से घटाया जाता है, और 1 उच्चतर मुद्रित किया range(n)जाता है, उम्मीदवारों के ब्रह्मांड के रूप में सेवा करने के लिए ।)

Answer 2

गणितज्ञ, 95 बाइट्स

For[n_~s~k_=0;n=0,n<#,For[i=n,--i>0,s[2n-i,2f@n-f@i]=1];For[++n;i=1,n~s~i>0,++i];Print[f@n=i]]&

निश्चित रूप से गोल्फ दृष्टिकोण नहीं है, लेकिन यह वास्तव में काफी कुशल है, ओईआईएस पृष्ठ से मैंने जो एल्गोरिदम की कोशिश की थी।

जब हम वहां पहुंचते हैं , तो प्रत्येक s (n) के लिए सभी निषिद्ध मूल्यों की जाँच करने का विरोध करते हुए, मैं एक छलनी-आधारित दृष्टिकोण का उपयोग कर रहा हूं। जब हम एक नया मान पाते हैं (n) तो हम तुरंत जाँचते हैं कि कौन सा मान > m> n के लिए निषिद्ध है । तब हम केवल पहले मूल्य की तलाश करके s (n + 1) को हल करते हैं जो निषिद्ध नहीं था।

यह सशर्त --i>0को बदलकर और भी अधिक कुशल बनाया जा सकता है 2n-#<=--i>0। उस स्थिति में, हम इनपुट से अधिक n के लिए निषिद्ध मानों की जाँच करने से बचते हैं ।

कुछ अधिक पठनीय संस्करण के लिए, मैंने इस कोड के साथ शुरुआत की, जो परिणामों को maxकिसी फ़ंक्शन में संग्रहीत करता है f, और फिर इसे एक-पंक्ति शुद्ध फ़ंक्शन में संग्रहीत किया जाता है:

 max = 1000;
 ClearAll[sieve, f];
 sieve[n_, k_] = False;
 For[n = 0, n < max,
  temp = f[n];
  For[i = n - 1, i > 0 && 2 n - i <= max, --i,
   sieve[2 n - i, 2 temp - f[i]] = True;
   ];
  ++n;
  i = 1;
  While[sieve[n, i], ++i];
  f@n = i;
  ]

Answer 3

हास्केल, 90 , 89 , 84 , 83 बाइट्स

शायद अधिक गोल्फ हो सकता है, लेकिन यह अभी भी एक अच्छा पहला प्रयास है:

a n|n<1=0|n<3=1|1<2=[x|x<-[1..],and[x/=2*a(n-k)-a(n-k-k)||a(n-k-k)<1|k<-[1..n]]]!!0

Ungolfed:

a n | n<1        = 0 
    | n<3        = 1
    | otherwise  = head (goods n)

goods n = [x | x <- [1..], isGood x n]

isGood x n = and [ x - a(n-k) /= a(n-k) - a(n-k-k) || a(n-k-k) == 0 | k <- [1..n] ]

यह एक सरल कार्यान्वयन है जो सीमा से बाहर के लिए '0' देता है। फिर, प्रत्येक संभावित मान के लिए, यह जांचता है कि सभी k <= n और सीमा में, [x, a (xk), (x-2k)] अंकगणितीय अनुक्रम नहीं है।

ऊपरी समयबद्धता पर बाध्य (OEIS पृष्ठ से इस तथ्य का उपयोग करके कि (a) <= (n + 1) / 2:

t n <= sum[ sum[2*t(n-k) + 2*t(n-k-k) | k <- [1..n]] | x <- [1..(n+1)/2]]
    <= sum[ sum[4*t(n-1)              | k <- [1..n]] | x <- [1..(n+1)/2]]
    <= sum[     4*t(n-1)*n                         ] | x <- [1..(n+1)/2]]
    <=          4*t(n-1)*n*(n+1)/2
    ->
O(t(n)) == O(2^(n-2) * n! * (n+1)!)

मुझे यकीन नहीं है कि यह बाध्य कितना अच्छा है क्योंकि 't' के पहले 1k मानों की गणना करना और दिए गए मानों के लॉग पर रैखिक मॉडल का उपयोग करना है। ओ (22 ^ एन), पी-मान के साथ <10 ^ (- 1291), मामले में यह मायने रखता है।

कार्यान्वयन स्तर पर, '-O2' के साथ संकलन करते हुए, पहले 20 मूल्यों की गणना करने में ~ 35 मिनट का समय लगा।

Comments

आपके कार्यक्रम के लिए समय की जटिलता क्या है?

— दोष

@flawr ने पोस्ट में कुछ समय जटिलता विश्लेषण जोड़ा

— माइकल क्लेन

Answer 4

ब्रेकीलॉग , 33 31 बाइट्स

;Ė{~b.hℕ₁≜∧.¬{ġh₃hᵐs₂ᶠ-ᵐ=}∧}ⁱ⁽↔

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

इस मामले में यह मायने रखता है: 2-बाइट गोल्फ एक ऐसी सुविधा के लिए संभव था, जो मैंने इस चुनौती पर काम करने के बाद अनुरोध किया था ।

व्याख्या

हम क्रमिक रूप से अनुक्रम को रिवर्स ऑर्डर में एक सूची के रूप में उत्पन्न करते हैं, उदाहरण के लिए [2,2,1,1,2,1,1], और इसे अंत में रिवर्स करें।

यहाँ नेस्टेड प्रेडिकेट्स के एक जोड़े हैं। आइए अंदर से उन्हें देखें। पहले वाला, ġh₃hᵐs₂ᶠ-ᵐ=एक उम्मीदवार को बाद में लेता है a(n),a(n-1),...,a(0)और निर्धारित करता a(n),a(n-k),a(n-2k)है कि कुछ के लिए अंकगणितीय अनुक्रम है या नहीं k।

ġ            Group the list into equal-length sublists (with the possible exception of
             the last sublist, which might be shorter)
 h₃          Get the first 3 sublists from that list
   hᵐ        and get the head of each of those 3 sublists
             We now have a list containing a(n),a(n-k),a(n-2k) for some k
     s₂ᶠ     Find all 2-element sublists of that list: [a(n),a(n-k)] and [a(n-k),a(n-2k)]
        -ᵐ   Find the difference of each pair
          =  Assert that the two pairwise differences are equal

उदाहरण के लिए, इनपुट के साथ [1,2,1,1,2,1,1]:

ġ has possible outputs of
    [[1],[2],[1],[1],[2],[1],[1]]
    [[1,2],[1,1],[2,1],[1]]
    [[1,2,1],[1,2,1],[1]]
    [[1,2,1,1],[2,1,1]]
    [[1,2,1,1,2],[1,1]]
    [[1,2,1,1,2,1],[1]]
    [[1,2,1,1,2,1,1]]
h₃ has possible outputs of
    [[1],[2],[1]]
    [[1,2],[1,1],[2,1]]
    [[1,2,1],[1,2,1],[1]]
hᵐ has possible outputs of
    [1,2,1]
    [1,1,2]
    [1,1,1]
s₂ᶠ has possible outputs of
    [[1,2],[2,1]]
    [[1,1],[1,2]]
    [[1,1],[1,1]]
-ᵐ has possible outputs of
    [-1,1]
    [0,-1]
    [0,0]
= is satisfied by the last of these, so the predicate succeeds.

अगले विधेय बाहर की ओर, ~b.hℕ₁≜∧.¬{...}∧इनपुट के बाद एक a(n-1),a(n-2),...,a(0)और अगले बड़े परिणाम आउटपुट a(n),a(n-1),a(n-2),...,a(0)।

~b.hℕ₁≜∧.¬{...}∧
~b.                 The input is the result of beheading the output; i.e., the output is
                    the input with some value prepended
  .h                The head of the output
    ℕ₁              is a natural number >= 1
      ≜             Force a choice as to which number (I'm not sure why this is necessary,
                    but the code doesn't work without it)
        ∧           Also,
         .          the output
          ¬{...}    does not satisfy the nested predicate (see above)
                    I.e. there is no k such that a(n),a(n-k),a(n-2k) is an arithmetic sequence
                ∧   Break unification with the output

अंत में, मुख्य विधेय ;Ė{...}ⁱ⁽↔एक इनपुट नंबर लेता है और अनुक्रम के कई शब्दों को आउटपुट करता है।

;Ė{...}ⁱ⁽↔
;           Pair the input number with
 Ė          the empty list
  {...}ⁱ⁽   Using the first element of the pair as the iteration count and the second
            element as the initial value, iterate the nested predicate (see above)
         ↔  Reverse, putting the sequence in the proper order

Answer 5

रूबी , 71 बाइट्स

->n,*a{a.fill(0,n){|s|([*1..n]-(1..s/2).map{|o|2*a[s-o]-a[s-2*o]})[0]}}

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

सभी निषिद्ध मान उत्पन्न करता है, फिर उस सरणी के पूरक को (1.n) में लेता है और परिणाम का पहला मूल्य लेता है। इसका मतलब है कि मैं यह मान रहा हूँ कि a[n] <= nसभी n के लिए, जो आसानी से इंडक्शन का उपयोग करके सिद्ध किया जाता है (यदि पहले n / 2 शब्द सभी n / 2 से कम हैं, तो एक अंकगणितीय प्रगति नहीं हो सकती है) n।

यहाँ वाक्यात्मक चाल भी काफी रोचक है: *a इसका उपयोग अतिरिक्त तर्कों की एक सरणी को आरंभीकृत करने के लिए किया जाता है (जिसे अनदेखा किया जाएगा यदि हम किसी भी पारित हो गए हैं), और फिर a.fillतर्क सरणी को उत्परिवर्तित करते हैं और निहित रूप से इसे वापस करते हैं।

Comments

-1 बाइट: के बजाय a[s-o]और a[s-2*o], आप उपयोग कर सकते हैं a[s-=1]औरa[s-o]

— जीबी

Answer 6

APL (Dyalog Extended) , 37 बाइट्स ^SBCS

इस उत्तर को एपीएल ऑर्चर्ड में लिखने और गोल्फिंग में मदद के लिए Adám को बहुत धन्यवाद, एपीसी भाषा सीखने के लिए एक शानदार जगह।इसे ऑनलाइन आज़माएं!

संपादित करें: -6 बाइट्स Adám के लिए धन्यवाद

⌽{⍵,⍨⊃(⍳1+≢⍵)~-¯2⊥⍵[2×⍀⍥⍳⌊2÷⍨≢⍵]}⍣⎕,⍬

व्याख्या

{⍵,⍨⊃(⍳1+≢⍵)~-¯2⊥⍵[2×⍀⍥⍳⌊2÷⍨≢⍵]}  ⍵ is our right argument, the sequence S

                        ⌊2÷⍨≢⍵    We start by calculating X = ⌊len(S)÷2⌋
                       ⍳          Get a range [1, X]
                   2×⍀⍥           With that we can get S[:X] and S[:X×2:2]
                                  or S up to halfway and every 2nd element of S
             -¯2⊥⍵[           ]   And with that we can get 2*S[:X] - S[:X×2:2]
                                  Which is C=2*B-A of a progression A B C
     (⍳1+≢⍵)~                     We remove these Cs from our possible a(n)s
                                  I use range [1, len(S)+1]
    ⊃                             Get the first result, which is the minimum
 ⍵,⍨                              And then prepend that to S


⌽{...}⍣⎕,⍬

 {...}⍣⎕    We iterate an "input" ⎕ times
        ,⍬  with an empty list ⍬ as the initial S
⌽           and reversing S at the end as we have built it backwards

एपीएल (डायलॉग यूनिकोड) , 43 39 38 बाइट्स ^{एसबीसीएस}

यहां एक तेज़ लेकिन कम गोल्फ समाधान है जो ⍺(10000)कुछ सेकंड में गणना कर सकता है ।

⌽{⍵,⍨⊃(⍳1+≢⍵)~-⌿⍵[1 2 1∘.×⍳⌊2÷⍨≢⍵]}⍣⎕,⍬

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

Answer 7

MATLAB, 156 147 बाइट्स

मैं अंत में यह थोड़ा नीचे गोल्फ के लिए मिल गया है:

N=input('');s=[0;0];for n=1:N,x=s(n,~~s(n,:));try,a(n)=find(~ismember(1:max(x)+1,x),1);catch,a(n)=1;end,s(n+1:2*n-1,end+1)=2*a(n)-a(n-1:-1:1);end,a

Ungolfed:

N=input('');                                   % read N from stdin

s=[0;0];
for n=1:N,
    x=s(n,~~s(n,:));                           % x=nonzeros(s(n,:));
    try,
        a(n)=find(~ismember(1:max(x)+1,x),1);  % smallest OK number
    catch,
        a(n)=1;                                % case of blank page for n
    end,

    s(n+1:2*n-1,end+1)=2*a(n)-a(n-1:-1:1);     % determined new forbidden values
end,
a                                              % print ans=...

इनपुट STDIN से पढ़ा जाता है, और प्रिंटिंग स्वचालित रूप से ans=और सामान के साथ किया जाता है। मुझे उम्मीद है कि यह "उचित" आउटपुट के रूप में योग्य है।

यह एक छलनी-आधारित समाधान भी है: चर s(i,:)उन अनुक्रम मानों का ट्रैक रखता है जिनके लिए मना किया जाता है a(i)। try-catchब्लॉक एक खाली (जिसका अर्थ है पूर्ण शून्य) के मामले के इलाज के लिए की जरूरत है sमैट्रिक्स: इस मामले में सबसे कम मूल्य 1पहले से ही अनुमति दी है।

हालाँकि, मेमोरी की जरूरत (या रनटाइम?) ऊपर बहुत गड़बड़ हो जाती है N=2000। तो यहाँ एक गैर प्रतिस्पर्धा, अधिक कुशल समाधान है:

%pre-alloc
s = zeros([N,fix(N*0.07+20)]); %strict upper bound, needs adjusting later
i = zeros(1,N);

a = 1;
for n = 2:N,
    x = s(n,1:i(n));
    if isempty(x),
        a(n) = 1;
    else
        a(n) = find(~ismember(1:max(x)+1,x),1);
    end,

    j = n+1:min(2*n-1,N);
    i(j) = i(j)+1;
    s(N,max(i(j))) = 0;   %adjust matrix size if necessary
    b = a(n-1:-1:1);
    s(sub2ind([N,size(s,2)+1],j,i(j))) = 2*a(n)-b(1:length(j));
end

इस कार्यान्वयन में sमैट्रिक्स में फिर से निषिद्ध मूल्य शामिल हैं, लेकिन एक सुव्यवस्थित तरीके से, बिना किसी शून्य ब्लॉक (जो प्रतिस्पर्धा संस्करण में मौजूद हैं)। इंडेक्स वेक्टर iमना किए गए वैक्टर की संख्या पर नज़र रखता है s। पहली नजर में कोशिकाओं को संग्रहीत जानकारी का ट्रैक रखना बहुत अच्छा होगाs , लेकिन वे धीमे होंगे, और हम एक ही समय में उनमें से एक समूह को अनुक्रमित नहीं कर सकते हैं।

MATLAB की एक बुरा विशेषता यह है कि जब आप कह सकते हैं M(1,end+1)=3;और स्वचालित रूप से एक मैट्रिक्स का विस्तार कर सकते हैं, तो आप रैखिक अनुक्रमण के साथ ऐसा नहीं कर सकते। यह समझ में आता है (कैसे MATLAB परिणामी सरणी आकार को जानना चाहिए, जिसके ढांचे में इसे रैखिक सूचकांकों की व्याख्या करनी चाहिए?), लेकिन इसने मुझे अभी भी आश्चर्यचकित किया है। यह सुपरफ्लस लाइन का कारण है s(N,max(i(j))) = 0;: यह sहमारे लिए मैट्रिक्स का विस्तार करेगा जब भी आवश्यक हो। शुरुआती आकार का अनुमान N*0.07+20एक रैखिक फिट से पहले कुछ तत्वों तक आता है, वैसे।

रनटाइम का परीक्षण करने के लिए, मैंने कोड का थोड़ा संशोधित संस्करण भी जांचा, जहाँ मैंने sआकार के लिए मैट्रिक्स को इनिशियलाइज़ किया था N/2। पहले 1e5तत्वों के लिए यह एक बहुत ही उदार अनुमान लगता है, इसलिए मैंने sपिछले पैराग्राफ में उल्लिखित विस्तार कदम को हटा दिया । ये एक साथ यह कहते हैं कि कोड तेज होगा, लेकिन बहुत अधिक कम मजबूत भी होगाN (क्योंकि मुझे नहीं पता है कि श्रृंखला वहां कैसी दिखती है)।

तो यहाँ कुछ रनटाइम्स हैं, तुलना कर रहे हैं

• v1: प्रतिस्पर्धा गोल्फ संस्करण,
• v2: निम्न-प्रारंभिक-आकार, मूर्ख-प्रूफ संस्करण और
• v3: उदार-शुरू-आकार, बड़ा-एन संस्करण के लिए असफल हो सकता है।

मैंने R2012b पर इनका मापन किया, नामांकित फ़ंक्शन परिभाषा के अंदर 5 रन का सर्वश्रेष्ठ लिया tic/toc।

1. N=100:
   • v1: 0.011342 s
   • वी 2: 0.015218 s
   • v3: 0.015076 s
2. N=500:
   • v1: 0.101647 s
   • वी 2: 0.085277 s
   • v3: 0.081606 s
3. N=1000:
   • v1: 0.641910 s
   • वी 2: 0.187911 s
   • v3: 0.183565 s
4. N=2000:
   • v1: 5.010327 s
   • वी 2: 0.452892 s
   • v3: 0.430547 s
5. N=5000:
   • v1: एन / ए (प्रतीक्षा नहीं)
   • वी 2: 2.021213 s
   • v3: 1.572958 s
6. N=10000:
   • v1: एन / ए
   • वी 2: 6.248483 s
   • v3: 5.812838 s

ऐसा लगता है कि v3संस्करण काफी महत्वपूर्ण है, लेकिन बहुत तेजी से नहीं। मुझे नहीं पता कि अनिश्चितता का एक तत्व (बहुत बड़ी के लिए N) रनटाइम में मामूली वृद्धि के लायक है या नहीं।

Comments

M=1;M(end+1)=2;मेरे लिए पूरी तरह से ठीक काम करता है?

— 17

@flawr जो स्केलर और वैक्टर के लिए काम करेगा। M=rand(2); M(end+1)=2इसके बजाय की कोशिश करें :)

— Andras Deak

अब मैं देख रहा हूँ =)

— दोष

Answer 8

जेली , 24 19 बाइट्स

काफी देर में यह मेरा पहला जेली जवाब है। वापस आकर खुशी हुई।

यह मेरे एपीएल उत्तर का एक बंदरगाह है जो स्वयं यहां उपयोग किए जाने वाले कई एल्गोरिदम का अनुकूलन है। मुख्य अंतर यह है कि यह 0-अनुक्रमित है।

संपादित करें: जोनाथन एलन को -5 बाइट्स धन्यवाद।

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

Ḋm2ɓṁḤ_
ŻJḟÇṂ;
1Ç¡U

व्याख्या

Ḋm2ɓṁḤ_  First link. Takes our current sequence S as our left argument.

         We are trying to calculate, of an arithmetic progression A B C, 
           the C using the formula, C = 2*B - A
Ḋ        Remove the first element of S.
 m2      Get every element at indices 0, 2, 4, ...
           This is equivalent to getting every second element of S, a list of As.
   ɓ     Starts a dyad with reversed arguments.
           The arguments here are S and As.
    ṁ    This molds S in the shape of As, giving us a list of Bs.
     Ḥ   We double the Bs.
      _  And subtract As from 2 * Bs.

ŻJḟÇṂ;  Second link. Takes S as our left argument.

Ż       Append a 0 to S.
 J      Range [1, len(z)]. This gets range [1, len(S) + 1].
  ḟÇ    Filter out the results of the previous link, our Cs.
    Ṃ   Take the minimum of Cs.
     ;  And concatenate it with the rest of the sequence so far.

1Ç¡U  Third link. Where we feed our input, n.

1     A list with the element 1.
 Ç¡   Run the previous link n times.
   U  Reverse everything at the end.

Comments

ḟके रूप में बस के रूप में अच्छा प्रदर्शन करेंगे œ-एक बाइट बचत

— जोनाथन एलन

बहुत यकीन है कि आप ( अनुक्रम के अनुसार ) शून्य सूचकांक कर सकते हैं और इसलिए एक पूर्ण-कार्यक्रम से एक सूची के जेली प्रतिनिधित्व को आउटपुट करने के “”साथ बदल सकते हैं 1, और अधिक बचत।

— जोनाथन एलन

Œœị@2Ḋm2दो को बचाने के लिए गोल्फ हो सकता है ।

— जोनाथन एलन

L‘RŻJएक को बचाने के लिए गोल्फ हो सकता है ।

— जोनाथन एलन

@JonathanAllan पांच पूरे बाइट्स! धन्यवाद!

— शर्लक

Answer 9

ईएस 6, 114 बाइट्स

n=>[...r=Array(n)].map((x,i,s)=>{for(y=1;x&&x[y];y++);r[i]=y;for(j=i;++j<n;s[j][y+y-r[i+i-j]]=1)s[j]=s[j]||[]}&&r

अनुक्रम के पहले n तत्वों की एक सरणी लौटाता है, इसलिए सूचकांक नीचे दिए गए ungolfed संस्करण से 1 हैं। मैंने छलनी का उपयोग किया। यह संस्करण लगभग n = 2000 के बाद धीमा हो जाता है; पिछले संस्करण ने सरणी की शुरुआत से पढ़ने से परहेज किया था जिसका मतलब था कि यह लगभग n = 2500 तक धीमा नहीं था। पुराने संस्करण ने चलनी सरणी का उपयोग बूलियन सरणी के बजाय निषिद्ध मानों की एक सूची के रूप में किया था, जिसमें मानों को निषिद्ध किया गया था; यह पसीने को तोड़ने के बिना लगभग n = 5000 तक मिल सकता है। मेरे मूल संस्करण ने बिटमास्क का उपयोग करने की कोशिश की, लेकिन वह अनहेल्दी निकला (और 198 बाइट्स पर बहुत लंबा था)।

बिल्कुल इतना धीमा संस्करण नहीं है:

function smoke(n) {
    result = [];
    sieve = [];
    for (i = 1; i <= n; i++) {
        value = 1;
        if (sieve[i]) {
            while (sieve[i][value]) {
                value++;
            }
        }
        result[i] = value;
        for (j = 1; j < i && i + j <= n; j++) {
            if (!sieve[i + j]) sieve[i + j] = [];
            sieve[i + j][value + value - result[i - j]] = true;
        }
    }
    return result;
}