স্টিভির ক্রম: + * - / + * - /

Question

আসুন, চারটি বুনিয়াদি ক্রিয়াকলাপ, সংযোজন +, গুণ *, বিয়োগ -এবং বিভাগ /(ভাসা, পূর্ণসংখ্যা নয়) ব্যবহার করি।

স্টিভির ক্রমটি নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

x = [x(1), x(2)]    // Two initial numbers (one indexed)
x(3) = x(1) + x(2)
x(4) = x(2) * x(3)
x(5) = x(3) - x(4)
x(6) = x(4) / x(5)
x(7) = x(5) + x(6)
... and so on.

চ্যালেঞ্জ:

দুটি অ-নেতিবাচক পূর্ণসংখ্যা ( x(1), x(2)) এবং একটি ইতিবাচক পূর্ণসংখ্যা Nইনপুট হিসাবে নিন।

x(1)এবং x(2)আপনার সিকোয়েন্সের দুটি প্রথম সংখ্যা হবে এবং আপনার Nযে ক্রমটির আউটপুট দিতে হবে তার দৈর্ঘ্য হবে। (আপনি 0-ভিত্তিক তালিকাটি বেছে নিতে পারেন, যার ক্ষেত্রে Nদৈর্ঘ্যের চেয়ে কম হবে)।

• আপনি ধরে নিতে পারেন না x(2) >= x(1)।
• Nসর্বদা >21-ভিত্তিক, ( >1যদি 0-ভিত্তিক) হয়।
• আপনার শূন্য ত্রুটি দ্বারা বিভাগ পরিচালনা করতে হবে না।
  • ২ য় পরীক্ষার কেসটি নোট করুন। আপনি পাবেন না 0, 1, এবং N=6ইনপুট হিসাবে, যেহেতু ফলশ্রুতি শূন্য দ্বারা বিভক্ত হবে, তবে আপনাকে অবশ্যই সমর্থন করতে হবে 0, 1এবং N=5।
• ধরে নিই কেবল বৈধ ইনপুট দেওয়া হবে।
• ইনপুট এবং আউটপুট যে কোনও সুবিধাজনক বিন্যাসে হতে পারে তবে দশমিক পয়েন্টের পরে আপনাকে কমপক্ষে 3 টি সংখ্যা সমর্থন করতে হবে যদি আউটপুট অ-পূর্ণসংখ্যার হয়।

পরীক্ষার কেস:

1 3
8
1, 3, 4, 12, -8, -1.5, -9.5, 14.25

0 1
5
0, 1, 1, 1, 0     // N=6 would give division by zero error. You don't need to handle that case.

1 0
9
1, 0, 1, 0, 1, 0, 1, 0, 1

6 3
25
6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96, -0.375, -79.335, 29.7506, -109.086, -0.272727, -109.358, 29.825, -139.183, -0.214286, -139.398, 29.8709, -169.269

Comments

কোনও ফাংশন x (1) এবং x (2) কে তালিকা হিসাবে নিতে পারে? নাকি আলাদা যুক্তি?

— ফ্লিপট্যাক

যাই হোক না কেন আপনার জন্য :) সুবিধাজনক

— Stewie গ্রিফিন

N0 ভিত্তিক হতে পারে? সুতরাং আপনার উদাহরণগুলিতে প্রদর্শিত এন এর চেয়ে কম 1 ইনপুট হিসাবে নিন। আমি অনুমান করি যে এন -2 নেওয়া খুব বেশি জিজ্ঞাসা করার জন্য ... :

— লুইস মেন্ডো

আপনি যখন লেখেন আউটপুট কোনও সুবিধাজনক বিন্যাসে থাকতে পারে , এর মধ্যে কি শুরুতে চূড়ান্ত উপাদান এবং শেষে সূচনা-উপাদানগুলির সাথে একটি তালিকা অন্তর্ভুক্ত থাকে (বিপরীত তালিকা)?

— এমিগানা

@ এমিগনা, না আমি মনে করি এটি কিছুটা প্রসারিত ... সংখ্যাগুলি সঠিক ক্রমে হওয়া উচিত

— স্টিভি গ্রিফিন

Answer 1

এমএটিএল , 19 18 17 বাইট

q:"y'+*-/'@)hyhUV

ইনপুটটি ফর্ম্যাটে রয়েছে: N(0-ভিত্তিক) x(1), x(2)(স্ট্রিং হিসাবে); সমস্ত নিউলাইন দ্বারা পৃথক।

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন (সামান্য পরিবর্তিত কোড; ফাঁকা রেখার দ্বারা আলাদা আউটপুট ক্রম)।

ব্যাখ্যা

এমএটিএল এর সঠিক evalফাংশন নেই, তবে U( str2num) ইনফিক্স অপারেটরগুলির সাথে সংখ্যার এক্সপ্রেশনগুলি মূল্যায়ন করতে পারে।

প্রতিটি নতুন পদ গণনা করা হয় এবং পূর্ববর্তী শর্তাদি রেখে স্ট্যাকের উপরে ধাক্কা দেয়। পুরো স্ট্যাকটি শেষে মুদ্রিত হয়।

q          % Implicitly input N (0-based). Subtract 1
:"         % Repeat that many times
  y        %   Duplicate x(n-1), where n is the number of already computed terms
           %   In the first iteration, which corresponds to n=2, this implicitly 
           %   inputs x(1) and x(2) as strings (and then duplicates x(1))
  '+*-/'   %   Push this string
  @)       %   Push iteration number and apply as modular index into the string. 
           %   So this gives '+' in the first iteration, '*' in the second etc
  h        %   Concatenate horizontally. This gives a string of the form
           %   '*x(n-1)+', where '+' is the appropriate operator 
  &y       %   Duplicate x(n)
  hh       %   Concatenate horizontally. This gives a string of the form
           %   'x(n-1)+x(n)'
  U        %   Convert to number. This evaluates the string
  V        %   Convert back to string. This is the new term, x(n+1)
           % Implicitly end loop and display stack

Answer 2

হাস্কেল, 69 68 64 বাইট

x#n=take n$x++zipWith3 id(cycle[(+),(*),(-),(/)])(x#n)(tail$x#n)

x1এবং x2একটি তালিকা হিসাবে নেওয়া হয়। ব্যবহারের উদাহরণ: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25]।

অলসতা অসীম পুনরাবৃত্তির তালিকাটিকে সংজ্ঞায়িত করা সম্ভব করে যেখানে আমরা প্রথম এন উপাদানগুলিকে নিই।

হাস্কেল, 66 বাইট

(h%g)y x=x:g(h x y)y
a=(+)%b
b=(*)%c
c=(-)%d
d=(/)%a
(.a).(.).take 

বিভিন্ন পদ্ধতির, কিছুটা দীর্ঘ। আর্গুমেন্ট অর্ডার N, x2, x1। ব্যবহারের উদাহরণ: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25]।

সংজ্ঞায়িত 4 ফাংশন a, b, cএবং dযা দুই আর্গুমেন্ট গ্রহণ করা y, x এবং রেখে একটি তালিকা তৈরি করুন xসঙ্গে পরবর্তী ফাংশন একটি কল সামনে yদ্বিতীয় যুক্তি হিসেবে এবং x op yপ্রথম হিসাবে। উদাহরণস্বরূপ aহল: a y x = x : (b (x+y) y), bগুণ আছে: b y x = x : (c (x*y) y)ইত্যাদি

সম্পাদনা করুন: @ মাইকেল ক্লেইন 1 ম ভেরিয়েন্ট ( #) এ একটি বাইট সংরক্ষণ করেছে । ভাগ্যক্রমে আমি দ্বিতীয় বৈকল্পিকের জন্য একটি বাইটও পেয়েছি, সুতরাং উভয়ের আবার একই দৈর্ঘ্য রয়েছে।

দ্বিতীয় সম্পাদনা করুন: @ জাগারব সংরক্ষণ করতে দ্বিতীয় সংস্করণে 2 বাইট খুঁজে পেয়েছিল এবং প্রথমটিতে আমি 4 পেয়েছি, সুতরাং সেগুলি আর একই দৈর্ঘ্যের নয়।

Comments

বাইটের জন্য তালিকা হিসাবে (অনুমোদিত) হিসাবে আর্গুমেন্টগুলি গ্রহণ করুন

— মাইকেল ক্লেইন

(.)অন্যান্য ফাংশনগুলির সাথে রচনা করা থাকলে আমি সর্বদা বিভ্রান্ত হয়ে পড়ে থাকি : পি

— টমসমেডিং

g x=(`take`f)whereএকটি বাইট সংরক্ষণ করে না: - /

— বার্গি

বিকল্প পদ্ধতির 2 বাইট সংরক্ষণ করুন:(h%g)y x=x:g(h x y)y

— Zgarb

@ জাগারব: ওহ, খুব সুন্দর। ধন্যবাদ! বিটিডাব্লু, আপনার পরামর্শগুলিতে সম্পাদনা করার সময় আমি প্রথম সংস্করণে সেভ করার জন্য 4 বাইট পেয়েছি।

— নিমি

Answer 3

ES6 (জাভাস্ক্রিপ্ট), 79, 67, 65 বাইট

হালনাগাদ

• @ETHProductions এর পরামর্শ অনুসারে i = 2 দিয়ে শুরু করে বিয়োগ 2 বাইট
• 3 বাইট সংরক্ষণ করা হয়েছে, @ নীলের কাছ থেকে চমৎকার পরামর্শের জন্য ধন্যবাদ!

Golfed

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

পরীক্ষা

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

>S(8,[1,3])
Array [ 1, 3, 4, 12, -8, -1.5, -9.5, 14.25 ]

>S(5,[0,1])
Array [ 0, 1, 1, 1, 0 ]

>S(9,[1,0])
Array [ 1, 0, 1, 0, 1, 0, 1, 0, 1 ]

>S(25,[6,3])
Array [ 6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, ...]

Comments

আপনি ++i2 iবার 1 যোগ করা এড়াতে ব্যবহার করতে পারবেন না ?

— নীল

অথবা, বিকল্পভাবে, লেখা ?S(n,a,i+1,a.push(...)):aআপনাকে কিছু বাইট বাঁচাতে পারে।

— নীল

অথবা আপনি a.pushনতুন দৈর্ঘ্যটি ফিরিয়ে আনার বিষয়টি ব্যবহার করতে পারেনS=(n,a,i=2)=>i<n?S(n,a,a.push(...)):a

— নীল

আমি এখনও মনে করি আপনি i=2যদিও এটি শুরু করে আরও বাইট সংরক্ষণ করতে পারেন ।

— নীল

নীলের পরামর্শ সহ, আমি মনে করি আপনি S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"+*-/"[i%4]+a[i-1]))):a2 বাইট সংরক্ষণ করতে পারেন ।

— ইটিএইচ প্রডাকশন

Answer 4

পাইথন 3, 90 80 74 বাইট

এক্সনর সম্ভবত এই সমাধানটি এসে ধ্বংস করতে চলেছে ...

def F(s,n,i=2):
 while i<n:s+=eval('%s'*3%(s[-2],'-/+*'[i%4],s[-1])),;i+=1

ফাংশনটি এতে পাসের তালিকাটি পরিবর্তন করে। এটি ব্যবহার করুন:

s = [1,3] 
F(s,8)

Repl.it চেষ্টা করুন!

-6 বাইটস কপারকে ধন্যবাদ

Comments

যেহেতু আপনি কেবল Oএকবার ব্যবহার করেন , আপনি '-/+*'[i%4]এর ঘোষণাটি করে এবং মুছে ফেলে কিছু বাইট সংরক্ষণ করতে পারেন O। এছাড়াও, আপনি strএরকম কিছু করে বার বার কল করতে পারবেন eval('%s'*3%(s[-2],'-/+*'[i%4],s[-1]))।

— তামা

হ্যাঁ, এবং s+=[...]প্রতিস্থাপন করা যেতে পারে s+=...,(পিছনে কমা নোট করুন)।

— তামা

xnor কেবলমাত্র আপনার সমাধানটি ধ্বংস করতে পারে না। আরও একজন ব্যক্তি আছেন: ডেনিস (মোড)।

— এরিক আউটগল্ফার

আপনাকে iইনপুট হিসাবে পাওয়ার গ্যারান্টিযুক্ত , সুতরাং এর জন্য আপনার ডিফল্ট মান প্রয়োজন হবে না ( i=2ন্যায়সঙ্গত হতে পারে i)। দুই বাইট বন্ধ।

— আর্টঅফকোড

nপরিবর্তে যদি অনুক্রমের তম আইটেমটি ফেরত দেওয়ার অনুমতি দেওয়া হয়, তবে এটি পুনরাবৃত্তির সাথে 1 বাইট সংক্ষিপ্ত:f=lambda x,n:n<2and x[n-1]or eval('%s'*3%(f(x,n-2),'*-/+'[n%4],f(x,n-1)))

— mbomb007

Answer 5

পার্ল 6 ,  75 71  61 বাইট

->\a,\b,\c{$_=[|(&[+],&[*],&[-],&[/])xx*];(a,b,{.shift.($^a,$^b)}...*)[^c]}

এটা পরীক্ষা করো

{$_=[|(&[+],&[*],&[-],&[/])xx*];($^a,$^b,{.shift.($^a,$^b)}...*)[^$^c]}

এটা পরীক্ষা করো

{($^a,$^b,{(&[+],&[*],&[-],&[/])[$++%4]($^a,$^b)}...*)[^$^c]}

এটা পরীক্ষা করো

সম্প্রসারিত:

{ # bare block lambda with placeholder parameters ｢$a｣ ｢$b｣ ｢$c｣

  # generate sequence
  (
    # initialize sequence
    $^a, # declare and use first argument
    $^b, # second argument

    {  # bare block lambda with two placeholder parameters ｢$a｣ ｢$b｣

      (

        &[+], &[*], &[-], &[/] # the four operators

      )[             # index into the list of operators

         $++        # increment (++) an anonymous state variable ($)
         % 4        # modulo 4

      ]( $^a, $^b ) # and use it on the previous two values in sequence

    }

    ...  # repeat that until

    *    # indefinitely

  )[     # take only

    ^    # upto and excluding:     ( Range object )
    $^c  # third argument

  ]
}

Answer 6

গণিত, 68 বাইট

(±1=#;±2=#2;±n_:=1##[#-#2,#/#2,+##][[n~Mod~4]]&[±(n-2),±(n-1)];±#3)&

স্নিগ্ধভাবে তৃতীয় স্থানে! তিনটি আর্গুমেন্টের নামহীন ফাংশন, যা হেল্পার আনারি অপারেটর ব্যবহার করে ±যেমন ±nস্টিও ক্রমটির ঠিক নবম উপাদান x (n)। প্রথম দুটি আর্গুমেন্ট হল এক্স (1) এবং এক্স (2), এবং তৃতীয় তর্কটি এনটি নির্দেশ করে যা আমরা কোন এক্স (এন) আউটপুট আউট করব।

পূর্ববর্তী দুটি শর্তে কোন বাইনারি ফাংশন প্রয়োগ করতে হবে তা চয়ন করার জন্য একটি মোড -4 গণনা ব্যবহার করে সরাসরি বাস্তবায়ন। সঠিক বাইনারি ফাংশন বাছাই, যা এটির 1##[#-#2,#/#2,+##]সাহায্য করে যা এই মজাদার কয়েকটি ম্যাথমেটিকা ​​গল্ফিং কৌশল ব্যবহার করে ।

Answer 7

05 এ বি 1 ই , 21 19 18 বাইট

ইনপুট N (0-ভিত্তিক), x (2) , x (1) ক্রমে নেওয়া হয় । কারুসোমপুটিংয়ের
জন্য 1 বাইট সংরক্ষণ করা হয়েছে ।

GUDXsX"/+*-"Nè.V})

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

 G                   # for N in [0 ... n-1] do:
  U                  # save top element of stack in X
   D                 # duplicate top of stack
    X                # push X
     s               # swap top 2 elements on stack
      X              # push X
       "/+*-"Nè      # index into the string with the current iteration number
               .V    # evaluate
                 }   # end loop
                  )  # wrap stack in list

পূর্ববর্তী সমস্ত উপাদানগুলিকে যথাযথভাবে রেখে আমরা পুনরায় ক্রম অনুসারে সর্বশেষতম উপাদান সহ স্ট্যাকটি তৈরি করি।
তারপরে আমরা একবারে সমস্ত মান প্রদর্শন করতে একটি তালিকাতে স্ট্যাকটি গুটিয়ে রাখি।

Comments

আমি এটি বুঝতে পারি না, তবে ব্যবহার করে XYএবং UVআপনার বাইটগুলি সংরক্ষণ করতে পারে।

— ম্যাজিক অক্টোপাস উরন

@ কারাসোকম্পুটিং: দুর্দান্ত ধরা! নিবন্ধ থেকে হারিয়ে যাওয়া বাইটটি সংরক্ষণ করে ব্যবহার করে অন্তর্নিহিত UX

— ইনপুটটিতে

Answer 8

কমন লিস্প, 158

(lambda(x y n)(loop repeat n for a = x then b for b = y then r for o in '#1=(+ * - / . #1#)for r =(ignore-errors(funcall o a b))collect(coerce a'long-float)))

সত্যিই প্রতিযোগিতামূলক নয়, তবে আমি পছন্দ করি এটি কীভাবে প্রকাশিত হয় স্বাভাবিকভাবে:

(lambda (x y n)
  (loop 
    repeat n
    for a = x then b
    for b = y then r
    for o in '#1=(+ * - / . #1#)
    for r = (ignore-errors (funcall o a b))
    collect (coerce a 'long-float)))

আর কে গণনা করার সময় আমরা ত্রুটিগুলি উপেক্ষা করি, যা আর (এবং তারপরে বি) সম্ভবত NIL এর মান নেয়। এটি পরবর্তী মানটি অপরিবর্তিত থাকলেও বর্তমান ফলাফলকে আউটপুট করতে দেয়। তারপরে, শেষ পর্যন্ত লুপটি ব্যর্থ হবে, তবে এটি নিয়মের মধ্যে রয়েছে।

টেস্ট

আমরা ফাংশনটির নামকরণ করি Fএবং যাচাই করি যে প্রত্যাশিত মানগুলি পরীক্ষিতটির সমান are

(loop
  for (args expected)
    in
  '(((1 3 8)
     (1 3 4 12 -8 -1.5 -9.5 14.25))

    ((0 1 5)
     (0 1 1 1 0))

    ((1 0 9)
     (1 0 1 0 1 0 1 0 1))

    ((6 3 25)
     (6 3 9 27 -18 -1.5 -19.5 29.25 -48.75 -0.6 -49.35 29.61 -78.96 -0.375 -79.335 29.7506 -109.086 -0.272727 -109.358 29.825 -139.183 -0.214286 -139.398 29.8709 -169.269)))

  for result = (apply #'f args)
  always (every (lambda (u v) (< (abs (- u v)) 0.001)) result expected))

=> T

আনুমানিক পরীক্ষার কারণ হ'ল গণনা করা মানগুলি প্রয়োজনের তুলনায় কিছুটা সুস্পষ্ট; এখানে, এর জন্য (f 6 3 25):

(6.0d0 3.0d0 9.0d0 27.0d0 -18.0d0 -1.5d0 -19.5d0 29.25d0 -48.75d0 -0.6d0
 -49.35d0 29.61d0 -78.96d0 -0.375d0 -79.335d0 29.750625d0 -109.085625d0
 -0.2727272727272727d0 -109.35835227272727d0 29.825005165289255d0
 -139.18335743801654d0 -0.21428571428571427d0 -139.39764315230224d0
 29.870923532636194d0 -169.26856668493843d0)

Answer 9

ডিসি, 112 110 108 বাইট

5k?sarfsmsn[pSnla1-Sa]sh[lmlndSm]sv[lvx/lhx]sb[lvx+lhx]sc[lvx*lhx]sd[lvx-lhx]se[lcx2la>d2la>e2la>b2la>j]dsjx

কখনও কখনও dcউত্তরগুলি দীর্ঘ দীর্ঘ হতে পারে এবং কখনও কখনও সেগুলি খুব কম হতে পারে। এগুলি কেবলমাত্র চ্যালেঞ্জের উপর নির্ভর করে যেমন অন্যান্য অনেক ভাষার ক্ষেত্রে। যাইহোক, এটি অনুরোধের পরে স্পেস-বিচ্ছিন্ন এক-ইনডেক্সড কমান্ড লাইন ইনপুটটির জন্য 3 টি পূর্ণসংখ্যার অনুরোধ জানায় x(1), x(2), Nএবং দশমিক বিন্দুর পরে 5 সংখ্যাসহ অ-পূর্ণসংখ্যার আউটপুটগুলির সাথে পৃথক লাইনে ক্রমের প্রতিটি উপাদানকে আউটপুট দেয়।

উদাহরণস্বরূপ, ইনপুট 6 3 25নিম্নলিখিত ফলাফলের ফলাফল:

6
3
9
27
-18
-1.50000
-19.50000
29.25000
-48.75000
-.60000
-49.35000
29.61000
-78.96000
-.37500
-79.33500
29.75062
-109.08562
-.27272
-109.35834
29.82420
-139.18254
-.21428
-139.39682
29.86995
-169.26677

Answer 10

পার্ল, 62 + 3 ( -plaপতাকা) = 65 বাইট

push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"

ব্যবহার:

perl -plae 'push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"' <<< '1 3 8'

Answer 11

রুবি, 79 বাইট

->(b,c,d){a=[b,c];(d-2).times{|i|a<<a[i].send(%i{+ * - /}[i%4],a[i+1]).to_f};a}

আমি সন্দেহ করি এটি অনুকূল থেকে খুব দূরে (এবং আমি এখনও অন্য উত্তরগুলির দিকে নজর দিইনি) তবে তা মজাদার।

আমি কিছুটা মজা করতে চেয়েছিলাম Enumerable#cycle, তবে দুঃখের বিষয়, এটি ব্যবহার করতে 4 টি কম অক্ষর রয়েছে %4।

Answer 12

সি ++ 14, 118 বাইট

[](auto&v,int N){for(int i=0;++i<N-1;){auto p=v.rbegin(),q=p+1;v.push_back(i%4?i%4<2?*q+*p:i%4<3?*q**p:*q-*p:*q/ *p);}

নামবিহীন ল্যাম্বদা হিসাবে এর ইনপুটটি পরিবর্তন করছে। প্রয়োজন vহতে একটি vector<double>বা vector<float>।

অবহেলিত এবং ব্যবহার:

#include<iostream>
#include<vector>

auto f=
[](auto&v,int N){
  for(int i=0; ++i<N-1;){
    auto p=v.rbegin(),q=p+1;
    v.push_back(
      i%4 ?
        i%4<2 ? *q+*p : 
          i%4<3 ? *q**p : *q-*p
      : *q/ *p
    );
  }
};

int main(){
  std::vector<double> v={1,3};
  f(v,8);
  for (auto x:v) std::cout << x << ", ";
  std::cout << "\n";
}

Answer 13

x86-64 মেশিন কোড, 34 বাইট

কলিং কনভেনশন = x86-64 সিস্টেম ভি x32 এবিআই (দীর্ঘ মোডে 32-বিট পয়েন্টার সহ আর্কগুলি নিবন্ধ করুন)।

ফাংশন স্বাক্ষর হয় void stewie_x87_1reg(float *seq_buf, unsigned Nterms);। ফাংশনটি অ্যারের প্রথম দুটি উপাদানগুলিতে x0 এবং x1 বীজের মান গ্রহণ করে এবং ক্রমটি কমপক্ষে আরও N উপাদানগুলিতে প্রসারিত করে। বাফারটি 2 + এন-গোলাকৃত-আপ-থেকে-পরবর্তী-একাধিক-4-এ প্যাড করতে হবে। (যেমন 2 + ((N+3)&~3), বা কেবল এন + 5)।

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

বাফারে ইতিমধ্যে নেই এমন একটি ফাংশন আর্গ হিসাবে x0 এবং x1 পাস করার জন্য আমাদের কেবলমাত্র 3 বাইট (এক movlps [rdi], xmm0বা জন্য movups [rdi], xmm0) ব্যয় করতে হবে, যদিও এটি সিস্টেমের ভি struct{ float x,y; };পৃথক দুটি পৃথক এক্সএমএম রেজিস্টারে পাস হওয়ার কারণে এটি একটি মানক নয় calling

এটি objdump -drw -Mintelমন্তব্য যুক্ত করার জন্য কিছুটা ফর্ম্যাটেটিং দিয়ে আউটপুট

0000000000000100 <stewie_x87_1reg>:
       ;; load inside the loop to match FSTP at the end of every iteration
       ;; x[i-1] is always in ST0
       ;; x[i-2] is re-loaded from memory
 100:   d9 47 04                fld    DWORD PTR [rdi+0x4]
 103:   d8 07                   fadd   DWORD PTR [rdi]
 105:   d9 57 08                fst    DWORD PTR [rdi+0x8]
 108:   83 c7 10                add    edi,0x10            ; 32-bit pointers save a REX prefix here

 10b:   d8 4f f4                fmul   DWORD PTR [rdi-0xc]
 10e:   d9 57 fc                fst    DWORD PTR [rdi-0x4]

 111:   d8 6f f8                fsubr  DWORD PTR [rdi-0x8]
 114:   d9 17                   fst    DWORD PTR [rdi]

 116:   d8 7f fc                fdivr  DWORD PTR [rdi-0x4]
 119:   d9 5f 04                fstp   DWORD PTR [rdi+0x4]

 11c:   83 ee 04                sub    esi,0x4
 11f:   7f df                   jg     100 <stewie_x87_1reg>
 121:   c3                      ret    

0000000000000122 <stewie_x87_1reg.end>:
## 0x22 = 34 bytes

এই সি রেফারেন্স বাস্তবায়ন gcc -Osকিছুটা অনুরূপ কোডকে সংকলন করে (সহ )। জিসিসি একই কৌশলটিকে বেছে নিয়েছে, একটি রেজিস্টারে কেবল একটি পূর্ববর্তী মান রাখার জন্য।

void stewie_ref(float *seq, unsigned Nterms)
{
    for(unsigned i = 2 ; i<Nterms ; ) {
        seq[i] = seq[i-2] + seq[i-1];       i++;
        seq[i] = seq[i-2] * seq[i-1];       i++;
        seq[i] = seq[i-2] - seq[i-1];       i++;
        seq[i] = seq[i-2] / seq[i-1];       i++;
    }
}

আমি দ্বি-নিবন্ধের x87 সংস্করণ সহ কোড সহ অন্যান্য উপায়ে পরীক্ষা করেছিলাম:

; part of loop body from untested 2-register version.  faster but slightly larger :/
; x87 FPU register stack    ;       x1, x2   (1-based notation)
fadd    st0, st1            ; x87 = x3, x2
fst     dword [rdi+8 - 16]  ; x87 = x3, x2

fmul    st1, st0            ; x87 = x3, x4
fld     st1                 ; x87 = x4, x3, x4
fstp    dword [rdi+12 - 16] ; x87 = x3, x4
; and similar for the fsubr and fdivr, needing one fld st1

আপনি যদি গতিতে যাচ্ছিলেন তবে আপনি এটি এইভাবে করতেন (এবং এসএসই উপলব্ধ ছিল না)

একবারে প্রবেশের পরিবর্তে লুপের ভিতরে মেমরি থেকে বোঝা চাপানো হয়ত সাহায্য করতে পারে, যেহেতু আমরা কেবল সাব এবং ডিভ ফলাফলগুলি অর্ডার থেকে সঞ্চার করতে পারি, তবে এখনও প্রবেশের উপর স্ট্যাক স্থাপনের জন্য এটি দুটি এফএলডি নির্দেশিকা প্রয়োজন needs

আমি এসএসই / এভিএক্স স্কেলার গণিতটি ব্যবহার করার চেষ্টা করেছি (xmm0 এবং xmm1 এর মান দিয়ে শুরু করে) তবে বৃহত্তর নির্দেশের আকার হত্যাকারী। ব্যবহার করা addps(যেহেতু এটি 1B এর চেয়ে কম addss) একটি সামান্য বিটকে সহায়তা করে। অ-পরিবহনের নির্দেশাবলীর জন্য আমি অ্যাভিএক্স ভেক্স-প্রিফিক্স ব্যবহার করেছি, যেহেতু ভ্যাঙ্কসএসএসএসইবিপিএস (এবং এসইউবিএসএস-এর সমান দৈর্ঘ্য) এর চেয়ে এক বাইট বেশি দীর্ঘ।

; untested.  Bigger than x87 version, and can spuriously raise FP exceptions from garbage in high elements
addps   xmm0, xmm1      ; x3
movups  [rdi+8 - 16], xmm0
mulps   xmm1, xmm0      ; xmm1 = x4,  xmm0 = x3
movups  [rdi+12 - 16], xmm1
vsubss  xmm0, xmm1, xmm0      ; not commutative.  Could use a value from memory
movups  [rdi+16 - 16], xmm0
vdivss  xmm1, xmm0, xmm1      ; not commutative
movups  [rdi+20 - 16], xmm1

---

এই পরীক্ষার জোতা দিয়ে পরীক্ষিত:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int main(int argc, char**argv)
{
    unsigned seqlen = 100;
    if (argc>1)
        seqlen = atoi(argv[1]);
    float first = 1.0f, second = 2.1f;
    if (argc>2)
        first = atof(argv[2]);
    if (argc>3)
        second = atof(argv[3]);

    float *seqbuf = malloc(seqlen+8);  // not on the stack, needs to be in the low32
    seqbuf[0] = first;
    seqbuf[1] = second;

    for(unsigned i=seqlen ; i<seqlen+8; ++i)
        seqbuf[i] = NAN;

    stewie_x87_1reg(seqbuf, seqlen);
//  stewie_ref(seqbuf, seqlen);
    for (unsigned i=0 ; i< (2 + ((seqlen+3)&~3) + 4) ; i++) {
        printf("%4d: %g\n", i, seqbuf[i]);
    }

    return 0;
}

সঙ্গে সংকলন nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

সাথে প্রথম পরীক্ষা-মামলা চালান ./stewie 8 1 3

যদি আপনার কাছে x32 লাইব্রেরি ইনস্টল করা না থাকে nasm -felf64তবে ডিফল্ট ব্যবহার করে জিসিসি ব্যবহার করুন এবং ছেড়ে দিন -m64। আমি আসলে (স্ট্যাকের) mallocপরিবর্তে float seqbuf[seqlen+8]এক্স 32 হিসাবে তৈরি না করে একটি কম ঠিকানা পেতে ব্যবহার করেছি।

---

মজাদার ঘটনা: YASM- এ একটি ত্রুটি রয়েছে: লুপ শাখার জন্য এটি একটি rel32 জিসিসি ব্যবহার করে, যখন শাখার লক্ষ্যবস্তুতে বৈশ্বিক প্রতীক হিসাবে একই ঠিকানা থাকে।

global stewie_x87_1reg
stewie_x87_1reg:
   ;; ended up moving all prologue code into the loop, so there's nothing here
.loop:

...
sub    esi, 4
jg     .loop

একত্রিত ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

Answer 14

05 এ বি 1 ই , 12 বাইট

λ£"-/+*"Nè.V

এটি অনলাইন চেষ্টা করুন!

Answer 15

জাপট , 20 বাইট

@OxVs2n)q"-/+*"gY}hV

চেষ্টা করে দেখুন

Answer 16

বাশ, 224 বাইট (কোনও যোগাযোগ নেই)

বেসে একটি বিশাল আকারের বাস্তবায়ন ।

টাস্কটি বেশ আক্ষরিক অর্থে গ্রহণ করে এবং একটি অবিচ্ছিন্ন পাইপে সমস্ত কিছু করে, ডাব্লু / ও কোনও অপরিষ্কার নিয়ন্ত্রণ প্রবাহ কাঠামো বা পুনরাবৃত্তি।

ইনপুট

$ 1, $ 2 - প্রাথমিক উপাদান

$ 3 - লক্ষ্য ক্রমের আকার

Golfed

{ echo "a[0]=$1;a[1]=$2;a[0];a[1]";paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);}|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/'|bc -l

কম গল্ফড

{ 
 echo "a[0]=$1;a[1]=$2;a[0];a[1]";
 paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);
}\
|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/' \
|bc -l

পরীক্ষা

>./stewie.sh 1 3 8
1
3
4
12
-8
-1.50000000000000000000
-9.50000000000000000000
14.25000000000000000000

পাইপলাইন পর্যায়

প্রতিটি আউটপুট সিকোয়েন্স উপাদান (প্রতি লাইনে একটি) জন্য উপাদান সূচকগুলির একটি টেবিল তৈরি করুন:

...
2   0   +   1
3   1   *   2
4   2   -   3
5   3   /   4
6   4   +   5
7   5   *   6
...

এটিকে লিনিয়ার বিসি প্রোগ্রামে রূপান্তর করতে সেড ব্যবহার করুন :

...
a[2]=a[0]+a[1];a[2];
a[3]=a[1]*a[2];a[3];
a[4]=a[2]-a[3];a[4];
a[5]=a[3]/a[4];a[5];
a[6]=a[4]+a[5];a[6];
a[7]=a[5]*a[6];a[7];
...

এটি বিসি খাওয়ান এবং এটি সমস্ত কাজ করতে দিন

Answer 17

পাইথ - 20 বাইট

আউটপুটিং সমস্ত nখরচ আমার।

u+Gvj@"+*-/"H>2GttEQ

খ্রিস্টের অনলাইন কিউজে কাজ করে না।

Answer 18

সিলোন, 195 বাইট

Float[]s(Integer a,Integer b,Integer n)=>loop([a.float,b.float,[Float.divided,Float.plus,Float.times,Float.minus].cycled.rest])(([x,y,o])=>[y,(o.first else nothing)(x)(y),o.rest]).take(n)*.first;

ফর্ম্যাট এবং মন্তব্য:

// Print the first n entries of the Stewies sequence with given starting entries.
//
// Question:  http://codegolf.stackexchange.com/q/101145/2338
// My answer: http://codegolf.stackexchange.com/a/101251/2338

// Declare a function `s` which takes three integers, and returns a tuple
// of floats. (The more common syntax for the return value is [Float*],
// but Float[] is shorter.)
Float[] s(Integer a, Integer b, Integer n)
       // it is implemented by evaluating the following expression for each call.
         =>
        // start a loop with ...
        loop([
              // ... float versions of the integers, and ...
              a.float, b.float,
              // ... an infinite sequence of the four operators, ever repeating.
              // I needed the `.rest` here so the whole thing gets a {...*} type
              // instead of {...+}, which doesn't fit to what o.rest returns.
              // Each operator has the type Float(Float)(Float), i.e. you apply
              // it twice to one float each to get a Float result.
              [Float.divided, Float.plus, Float.times, Float.minus].cycled.rest])
               // in each iteration of the loop, map the triple of two numbers
               // and a sequence of operators to a triple of ... 
            (([x, y, o]) => [
               // the second number, 
                y,
               //the result of the first operator with both numbers
               // (using this "else nothing" here to convince the
               //  compiler that o.first is not null),
                   (o.first else nothing)(x)(y),
               // and the sequence of operators without its first element.
               // (that one unfortunately has a {...*} type, i.e. a possibly
               //  empty sequence.)
                                                 o.rest])
            // now we got an infinite sequence of those triples.
            // We just want the first n of them ...
                .take(n)
            // and of each triple just the first element.
            // (The *. syntax produces a tuple, non-lazily.
            //  We could also have used .map((z) => z.first)
            //  or .map(Iterable.first) or .map((z) => z[0]), each of
            //  which would return a (lazy) sequence, but they all would be
            //  longer.)
                *.first;

ব্যবহারের উদাহরণ:

shared void run() {
    print(s(1, 3, 8));
    print(s(0,1,11));
    print(s(1,0,9));
    print(s(6, 3, 29));
}

উদাহরণ আউটপুট:

[1.0, 3.0, 4.0, 12.0, -8.0, -1.5, -9.5, 14.25]
[0.0, 1.0, 1.0, 1.0, 0.0, Infinity, Infinity, Infinity, NaN, NaN, NaN]
[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]
[6.0, 3.0, 9.0, 27.0, -18.0, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96000000000001, -0.37499999999999994, -79.33500000000001, 29.750625, -109.08562500000001, -0.2727272727272727, -109.35835227272727, 29.825005165289255, -139.18335743801651, -0.2142857142857143, -139.39764315230224, 29.870923532636194, -169.26856668493843, -0.17647058823529413, -169.44503727317374, 29.90206540114831, -199.34710267432206]

দ্বিতীয় উদাহরণটি দেখায় যে এটি কীভাবে শূন্য দ্বারা বিভাগ পরিচালনা করবে। শেষ উদাহরণটি দেখায় যে ফলাফল কোনটি গাণিতিক (এবং বৃত্তাকার) ব্যবহার করছে তার উপর নির্ভর করে কিছুটা বিচ্যুত হয়েছে ... আমার মনে হয় সিলোন এর than৪ বিট ভাসমান বিন্দু গাণিতিকটি প্রশ্নটিতে পোস্ট হওয়ার চেয়ে কিছুটা আরও নিকটবর্তী হতে হবে ।

Answer 19

Clojure, 99 বাইট

#(let[ops[+ * - /]](take %3(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[%1 %2 0]))))

এই সংস্করণটি অনুশীলনে ব্যবহারের জন্য সুন্দর তবে এতে 110 বাইট রয়েছে:

(defn f[a b n](let[ops[+ * - /]](take n(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[a b 0])))))

আমার পুনরাবৃত্ত ক্রিয়াকলাপ এবং ক্রিয়াকলাপের একটি চক্রীয় ক্রম ফুজ করতে সমস্যা হয়েছিল তাই এর পরিবর্তে আমাকে একটি কাউন্টার ব্যবহার করতে হয়েছিল। এফএসএম রূপান্তর টেবিলের মতো ব্যবহার করার চেষ্টাও {+ * * - - / / +}করেছিলাম তবে আমি এটি কম কোডে চেপে ধরতে পারিনি।

একটি বেনামি ফাংশন হিসাবে প্রকাশ করা যেতে পারে

আন golfed:

(defn f [a b n]
  (let [ops [+ * - /]]
    (->> [a b 0]
         (iterate (fn [[a b i]]
                    [b
                     ((ops i) a b)
                     (mod (inc i) 4)]))
         (map first)
         (take n))))

ভাসমান সংস্থাগুলির সাথে অবশ্যই কল করা উচিত (f 6.0 3.0 25)অন্যথায় আপনি যুক্তিযুক্ত সংখ্যাগুলি পেয়ে যান। বিকল্পভাবে পুনরাবৃত্তি শুরু হতে পারে [a (float b) 0]যা থেকে কিছু অতিরিক্ত অক্ষর নিয়ে আসে।

Answer 20

অক্টাভা , 91 বাইট

@(x,n)eval 'for i=3:n,x(i)=eval([(n=@num2str)(x(i-2)),"*-/+"(mod(i,4)+1),n(x(i-1))]);end,x'

এটি অনলাইন চেষ্টা করুন!

কিছু গল্ফ:

• প্রথম evalকলের জন্য কোনও বন্ধনী নেই
• প্রথম evalকলের জন্য কোনও সমালোচনা নেই
• এর ইনলাইন অ্যাসাইনমেন্ট *-/+(এমএটিএলবি তে সম্ভব নয়)
• সংযুক্ত 'এবং "এস্ট্রোফেসগুলি এড়িয়ে চলতে এড়াতে (এমএটিএলবিতে সম্ভব নয়)
• n=@num2strএটি দু'বার ব্যবহৃত হওয়ার পরে সংরক্ষণ করা হচ্ছে (এমএটিএলবি তে সম্ভব নয়)