บทนำ

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)ของลำดับนี้ (ด้วยการจัดรูปแบบที่สมเหตุสมผลใด ๆ ตัวละคร / สตริงที่เป็นไปได้ / trainling อาจไม่เกี่ยวข้อง)

มีตัวอย่างข้อมูลสำหรับการสร้างลำดับนี้ แต่ฉันคิดว่าวิธีการอื่น ๆ อาจจะเล่นกอล์ฟได้ / เหมาะสำหรับบางภาษา

โปรดแจ้งให้เราทราบว่าโปรแกรมของคุณทำงานอย่างไร หากคุณมีอัลกอริทึมที่มีประสิทธิภาพเป็นพิเศษคุณอาจต้องการพูดถึงเรื่องนั้นเช่นกันเพราะมันจะช่วยให้สามารถพล็อตเงื่อนไขของลำดับในเวลาที่สั้นลง

กรณีทดสอบสองสามประการแรก:

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

ขอบคุณ @ MartinBüttnerสำหรับความช่วยเหลือและกำลังใจ

Python 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)ทำหน้าที่เป็นจักรวาลของผู้สมัคร)

Mathematica, 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]]&

ไม่ใช่วิธี golfiest แต่จริงๆแล้วมันค่อนข้างมีประสิทธิภาพเมื่อเทียบกับอัลกอริทึมที่ฉันลองจากหน้า OEIS

ตรงข้ามกับการตรวจสอบค่าที่ต้องห้ามทั้งหมดสำหรับแต่ละs (n)เมื่อเราไปถึงที่นั่นฉันใช้วิธีการกรองแบบตะแกรง เมื่อเราพบค่าใหม่s (n)เราตรวจสอบได้ทันทีค่าที่ห้ามนี้ม> n จากนั้นเราก็แก้หาs (n + 1)โดยค้นหาค่าแรกที่ไม่ได้รับอนุญาต

นี้สามารถทำมีประสิทธิภาพมากขึ้นโดยการเปลี่ยนเงื่อนไขการ--i>0 2n-#<=--i>0ในกรณีนี้เราหลีกเลี่ยงการตรวจสอบค่าที่ต้องห้ามสำหรับn ที่มากกว่าอินพุต

สำหรับรุ่นที่อ่านง่ายกว่านี้ฉันเริ่มด้วยรหัสนี้ซึ่งเก็บผลลัพธ์ไว้maxในฟังก์ชั่นfแล้วนำไปฟังก์ชั่น pure หนึ่งบรรทัดด้านบน:

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

Haskell, 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), a (x-2k)] ไม่ใช่ลำดับเลขคณิต

ความซับซ้อนของเวลาที่ จำกัด บน (โดยใช้ข้อเท็จจริงจากหน้า OEIS ที่ (n) <= (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)!)

ฉันไม่แน่ใจว่าขอบเขตนี้ดีแค่ไหนเพราะการคำนวณค่า 1k แรกของ 't' และใช้โมเดลเชิงเส้นบนบันทึกของค่าที่ให้ appx O (22 ^ n) โดยมีค่า p <10 ^ (- 1291) ในกรณีที่สำคัญ

ในระดับการนำไปใช้งานการคอมไพล์ด้วย '-O2' ใช้เวลาประมาณ 35 นาทีในการคำนวณค่า 20 อันดับแรก

Brachylog , 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ℕ₁≜∧.¬{...}∧ปัจจัย subsequence a(n-1),a(n-2),...,a(0)และออกผลลัพธ์เป็น a(n),a(n-1),a(n-2),...,a(0)subsequence

~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

Ruby , 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กลายพันธุ์อาเรย์อาร์กิวเมนต์และส่งกลับโดยปริยาย

APL (Dyalog Extended) , ^SBCSขนาด 37 ไบต์

ขอบคุณAdámสำหรับความช่วยเหลือของเขาในการเขียนและเล่นกอล์ฟคำตอบนี้ในAPL Orchardซึ่งเป็นสถานที่ที่เหมาะสำหรับการเรียนรู้ภาษา APL ลองออนไลน์!

แก้ไข: -6 bytes ขอบคุณ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

APL (Dyalog Unicode) , 43 39 38 ไบต์^SBCS

นี่คือวิธีแก้ปัญหาที่เร็วขึ้น แต่น้อยกว่าสนามกอล์ฟที่สามารถคำนวณได้⍺(10000)ในไม่กี่วินาที

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

ลองออนไลน์!

MATLAB, 156 147 bytes

ในที่สุดฉันก็ได้เล่นกอล์ฟนี้ลงเล็กน้อย:

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(เนื่องจากฉันไม่รู้ว่าซีรี่ส์มีลักษณะอย่างไร)

ดังนั้นที่นี่มี runtimes ไม่กี่เปรียบเทียบ

• v1: เวอร์ชันที่แข่งขันกอล์ฟ
• v2: ขนาดเริ่มต้นต่ำรุ่นที่ป้องกันคนโง่และ
• v3: รุ่นเริ่มต้นขนาดใหญ่อาจจะล้มเหลวสำหรับขนาดใหญ่ N

ฉันวัดเหล่านี้บน R2012b การที่ดีที่สุดของ 5 tic/tocลานภายในนิยามฟังก์ชันชื่อด้วย

1. N=100:
   • v1: 0.011342 s
   • v2: 0.015218 s
   • v3: 0.015076 s
2. N=500:
   • v1: 0.101647 s
   • v2: 0.085277 s
   • v3: 0.081606 s
3. N=1000:
   • v1: 0.641910 s
   • v2: 0.187911 s
   • v3: 0.183565 s
4. N=2000:
   • v1: 5.010327 s
   • v2: 0.452892 s
   • v3: 0.430547 s
5. N=5000:
   • v1: N / A (ไม่รอ)
   • v2: 2.021213 s
   • v3: 1.572958 s
6. N=10000:
   • v1: N / A
   • v2: 6.248483 s
   • v3: 5.812838 s

ดูเหมือนว่าv3รุ่นดังกล่าวจะมีความหมาย แต่จะไม่เร็วกว่าอย่างท่วมท้น ฉันไม่ทราบว่าองค์ประกอบของความไม่แน่นอน (สำหรับใหญ่มากN) มีค่าเพิ่มขึ้นเล็กน้อยในรันไทม์

เยลลี่ , 24 19 ไบต์

นี่เป็นคำตอบแรกของฉันในชั่วขณะหนึ่ง ดีใจที่ได้กลับมา

นี่คือพอร์ตของคำตอบ APL ของฉันซึ่งตัวมันเองเป็นการดัดแปลงอัลกอริทึมมากมายที่ใช้ที่นี่ ข้อแตกต่างที่สำคัญคือนี่คือดัชนี 0

แก้ไข: -5 ไบต์ขอบคุณ Jonathan Allan

ลองออนไลน์!

Ḋ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.

ES6, 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 แรกของลำดับดังนั้นดัชนีจะเป็น 1 จากเวอร์ชันที่ไม่ถูกปรับแต่งด้านล่าง ฉันใช้วิธีตะแกรง รุ่นนี้ช้าลงหลังจากประมาณ n = 2000; รุ่นก่อนหน้าหลีกเลี่ยงการอ่านจุดเริ่มต้นของอาเรย์ซึ่งหมายความว่ามันจะไม่ช้าลงจนถึงประมาณ n = 2500 เวอร์ชันที่เก่ากว่าใช้อาร์เรย์ตะแกรงเป็นรายการของค่าที่ต้องห้ามมากกว่าอาร์เรย์บูลีนซึ่งเป็นค่าที่ต้องห้าม สิ่งนี้สามารถไปถึงประมาณ n = 5000 โดยไม่ทำให้เหงื่อออก เวอร์ชันเดิมของฉันพยายามใช้ bitmasks แต่กลับกลายเป็นว่าไม่ช่วยเหลือ (และก็ยาวเกินไปที่ 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;
}