ফ্র্যাক্টাল স্মোক সিকোয়েন্স

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) , এই ক্রমের । (যে কোনও যুক্তিসঙ্গত বিন্যাস সহ। সম্ভাব্য নেতৃস্থানীয় / প্রশিক্ষণ অক্ষর / স্ট্রিং অপ্রাসঙ্গিক।)

এই ক্রমটি তৈরি করার জন্য স্নিপেটগুলি উপলব্ধ রয়েছে, তবে আমি মনে করি যে অন্যান্য পদ্ধতির নির্দিষ্ট ভাষার জন্য আরও গল্ফযোগ্য / আরও উপযুক্ত হতে পারে।

আপনার প্রোগ্রামটি কীভাবে কাজ করে তা আমাদের জানান। যদি আপনি একটি ক্রুশ হয়ে আসেন একটি বিশেষ দক্ষ দক্ষ অ্যালগরিদম আপনি এটিও উল্লেখ করতে চাইতে পারেন, কারণ এটি স্বল্প সময়ে ক্রমের আরও শর্তগুলি প্লট করার অনুমতি দেয়।

প্রথম কয়েকটি পরীক্ষার মামলা:

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

আরে আমি এই গ্রাফটি আগে কোথায় দেখেছি? :-D

— লুইস মেন্ডো

আপনার মাথাটি কিছুটা বাম দিকে চালিত করুন, কিছুটা জুম করুন, আপনি সেখানে যান! (:

— flawr

একটি নম্বর ফাইলের সবেমাত্র আপ আপ করা হয়েছে: youtube.com/watch?v=o8c4uYnnNnc

— flawr

আমি বাজি ধরছি তার কোডটি প্রায় গোলাপী নয়!

— লুইস মেন্ডো

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

অবশ্যই গল্ফিয়াস্ট পদ্ধতির নয়, তবে আমি ওইআইএস পৃষ্ঠা থেকে চেষ্টা করা অ্যালগরিদমের তুলনায় এটি আসলেই যথেষ্ট দক্ষ।

প্রতিটি এস (এন) এর জন্য সমস্ত নিষিদ্ধ মানগুলি পরীক্ষা করার বিপরীতে যখন আমরা সেখানে পৌঁছে যাই আমি চালনী-ভিত্তিক পদ্ধতির ব্যবহার করছি। আমরা যখন একটি নতুন মান খুঁজে গুলি (ঢ) আমরা অবিলম্বে পরীক্ষা, যার জন্য এই নিষেধের মান মি> এন । তারপরে আমরা কেবল নিষিদ্ধ ছিল না এমন প্রথম মানটি সন্ধান করে এস (এন + 1) সমাধান করব ।

শর্তসাপেক্ষে পরিবর্তন করে এটি আরও বেশি দক্ষ --i>0করা যায় 2n-#<=--i>0। সেক্ষেত্রে আমরা এন এর জন্য নিষিদ্ধ মানগুলি পরীক্ষা করা এড়িয়ে চলিসেক্ষেত্রে আমরা ইনপুট এর চেয়ে বড় ।

কিছুটা বেশি পঠনযোগ্য সংস্করণের জন্য, আমি এই কোডটি দিয়ে শুরু করেছি, যা 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' প্রদান করে। তারপরে, প্রতিটি সম্ভাব্য মানের জন্য, এটি পরীক্ষা করে যে সমস্ত কে <= n এবং সীমানায়, [x, a (xk), a (x-2k)] একটি গাণিতিক ক্রম নয়।

সময়ের জটিলতার উপরের উপরের আবদ্ধ (ওইআইএস পৃষ্ঠা থেকে সত্যটি ব্যবহার করে যে একটি (এন) <= (এন + 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)!)

আমি নিশ্চিত না যে এই গণ্ডিটি কতটা ভাল, কারণ 'টি' এর প্রথম 1 কে মান গণনা করা এবং মানগুলির লগগুলিতে লিনিয়ার মডেল ব্যবহার করে অ্যাপেক্স gave ও (22 ^ n), পি-মান <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 সমস্ত এন এর জন্য, যা সহজেই আনয়ন ব্যবহার করে প্রমাণিত হয় (যদি প্রথম এন / 2 পদগুলি সমস্ত এন / 2 এর চেয়ে কম হয়, তবে n এর দিকে পাটিগণিতের অগ্রগতি হতে পারে না)।

এখানে সিনট্যাকটিক ট্রিকটিও মৃদুভাবে আকর্ষণীয়: *aঅতিরিক্ত যুক্তিগুলির অ্যারে শুরু করার জন্য ব্যবহৃত হয় (যা আমরা যদি পাস করি তবে তা উপেক্ষা করা হবে), এবং তারপরে a.fillআর্গুমেন্ট অ্যারেটিকে রূপান্তরিত করে এবং স্পষ্টতই এটি ফেরত দেয়।

Comments

-1 বাইট: এর পরিবর্তে a[s-o]এবং a[s-2*o]আপনি ব্যবহার করতে পারেন a[s-=1]এবংa[s-o]

— জিবি

Answer 6

এপিএল (ডায়ালগ প্রসারিত) , 37 বাইট ^{এসবিসিএস}

এপিএল ভাষা শেখার দুর্দান্ত জায়গা, এপিএল অর্চার্ডে এই উত্তরটি লেখার এবং গল্ফ করার ক্ষেত্রে তাঁর সহায়তার জন্য আদমকে অনেক ধন্যবাদ । এটি অনলাইন চেষ্টা করুন!

সম্পাদনা করুন: -6 বাইট অ্যাডম ধন্যবাদ

⌽{⍵,⍨⊃(⍳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

ম্যাটল্যাব, 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=...

এসটিডিআইএন থেকে ইনপুট পড়া হয়, এবং প্রিন্টিং স্বয়ংক্রিয়ভাবে সম্পন্ন হয় 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। প্রথম দর্শনে কক্ষগুলিতে সঞ্চিত তথ্যের উপর নজর রাখা ভাল bes তবে সেগুলি ধীর হবে এবং আমরা একই সাথে তাদের একগুচ্ছ তালিকা করতে পারি না।

ম্যাটল্যাবের একটি বাজে বৈশিষ্ট্যটি হ'ল আপনি যখন M(1,end+1)=3;ম্যাট্রিক্সটি বলতে এবং স্বয়ংক্রিয়ভাবে প্রসারিত করতে পারেন, আপনি লিনিয়ার ইনডেক্সিংয়ের সাথে এটি করতে পারবেন না। এটি সাজিয়ে তোলে (ম্যাটল্যাব কীভাবে ফলাফলের অ্যারে আকারটি জানবে, এর কাঠামোর মধ্যে এটি রৈখিক সূচকগুলি ব্যাখ্যা করা উচিত?), তবে এটি এখনও আমাকে অবাক করে দেয়। অতিরিক্ত অতিরিক্ত লাইনের কারণ s(N,max(i(j))) = 0;: এটি sযখনই প্রয়োজন হবে আমাদের জন্য ম্যাট্রিক্স প্রসারিত করবে । শুরুর আকার অনুমানটি N*0.07+20লিনিয়ার ফিট থেকে শুরু করে প্রথম কয়েকটি উপাদানগুলিতে আসে।

রানটাইম পরীক্ষা করার জন্য, আমি কোডটির কিছুটা পরিবর্তিত সংস্করণও পরীক্ষা করেছিলাম, যেখানে আমি sম্যাট্রিক্সটি আকারে শুরু করেছি N/2। প্রথম 1e5উপাদানগুলির জন্য এটি খুব উদার অনুমান হিসাবে মনে হয়, তাই আমি sপূর্ববর্তী অনুচ্ছেদে উল্লিখিত প্রসারিত পদক্ষেপটি সরিয়েছি । এগুলি একত্রিত করে বোঝায় যে কোডটি দ্রুততর হবে, তবে খুব উচ্চেও কম শক্তিশালী N(যেহেতু আমি জানি না যে সিরিজটি সেখানে কেমন দেখাচ্ছে)।

সুতরাং এখানে কয়েকটি রানটাইম তুলনা করা হচ্ছে

• ভি 1: প্রতিযোগিতামূলক গল্ফযুক্ত সংস্করণ,
• ভি 2: নিম্ন-প্রারম্ভিক আকার, বোকা-প্রমাণ সংস্করণ এবং
• 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:
   • ভি 1: এন / এ (অপেক্ষা করেননি)
   • v2: 2.021213 s
   • v3 এর: 1.572958 s
6. N=10000:
   • ভি 1: এন / এ
   • v2: 6.248483 s
   • v3 এর: 5.812838 s

দেখে মনে হবে v3সংস্করণটি উল্লেখযোগ্য, তবে অতিমাত্রায় দ্রুত নয়। আমি জানি না যে অনিশ্চয়তার কোনও উপাদান (খুব বড় জন্য N) রানটাইমের সামান্য বর্ধনের পক্ষে মূল্যবান কিনা।

Comments

M=1;M(end+1)=2;আমার জন্য পুরোপুরি ঠিক কাজ করে?

— flawr

@ ফ্লোয়ার যা স্কেলার এবং ভেক্টরদের জন্য কাজ করবে। M=rand(2); M(end+1)=2পরিবর্তে চেষ্টা করুন :)

— আন্দ্রেস ডেক

আহ এখন আমি দেখছি =)

— 13:44 এ flawr

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একটি সংরক্ষণ করতে গল্ফ করা যেতে পারে ।

— জোনাথন অ্যালান

@ জোনাথন অ্যালান পাঁচটি পুরো বাইট! ধন্যবাদ!

— শার্লক

Answer 9

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

সিকোয়েন্সের প্রথম এন উপাদানগুলির একটি অ্যারে প্রদান করে, তাই সূচকগুলি নীচের অদৃশ্য সংস্করণে 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;
}