প্রদত্ত দুটি ধনাত্মক পূর্ণসংখ্যা পি এবং কুই , আপনার টাস্ক অ্যারে ফিরে আসতে হয় একটি নিম্নলিখিত অ্যালগরিদম প্রয়োগের দ্বারা তৈরি করা হয়েছে:

সঙ্গে স্টার্ট একটি = [পি, কুই] এবং ঘ = 2
A তে সংযুক্ত সংখ্যার প্রতিটি জোড়ার (x, y) জন্য যার যোগফল d দ্বারা বিভাজ্য , x এবং y এর মধ্যে (x + y) / d সন্নিবেশ করান ।
যদি কমপক্ষে একটি মিলে যাওয়া জুটির সন্ধান পাওয়া যায় তবে ইনক্রিমেন্ট ডি এবং # 2 পদক্ষেপ নিয়ে যান। অন্যথায়, থামুন এবং ফিরে আসুন ।

উদাহরণ

নীচে পি = 1 এবং কিউ = 21 এর প্রক্রিয়াটির বিশদ বর্ণনা করা হয়েছে ।

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

সুতরাং প্রত্যাশিত আউটপুট: [1, 1, 4, 3, 11, 8, 21]

ব্যাখ্যা এবং বিধি

ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে পরিচালনা করা যায়। পূর্ণসংখ্যা পি এবং কিউ 0 এর চেয়ে বড় হওয়ার গ্যারান্টিযুক্ত এটি যদি সহায়তা করে তবে আপনি Q ≥ p ধরে নিতে পারেন ।
অ্যালগরিদমের দ্বিতীয় ধাপটি পুনরাবৃত্তভাবে এমন উপাদানগুলিতে প্রয়োগ করা উচিত নয় যা কেবল একই পুনরাবৃত্তিতে sertedোকানো হয়েছে। উদাহরণস্বরূপ, এ = [1, 1] এবং ডি = 2 এর ফলে [1, 1, 1] (1 এর অসীম তালিকা নয়) হওয়া উচিত।
এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর!

পরীক্ষার মামলা

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

আপনি যদি কিছুটা বড় পরীক্ষার ক্ষেত্রে আপনার কোডটি পরীক্ষা করতে চান তবে এখানে প্রত্যাশিত আউটপুট রয়েছে:

পি = 12096 (2 ⁶ * 3 ³ * 7)
কি = 24192 (2 ⁷ * 3 ³ * 7)

code-golf array-manipulation

— Arnauld
সূত্র

6

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

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

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

~~হ্যাঁ, শক্তিশালীভাবে উন্নত করা যেতে পারে এখনও রিফ্যাক্টর কাজ।~~

~~সম্ভবত এটি যতটা ভাল পাচ্ছি।~~

-1 ধন্যবাদ, আর কে কিন্তু, এমিগনা! আউটপুট দেখানোর জন্য রেজিস্টারগুলির চেয়ে ভাল কাজ করেছে।

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

ডিবাগ ডাম্প এর জন্য [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

ডিবাগ দিয়ে এটি অনলাইন চেষ্টা করুন!

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

ওহ তাই এটি কিভাবে üকাজ করে ... এটি আমার পূর্ববর্তী উত্তরগুলির একটির উন্নতি করতে

— পেরেছিল

@ এসোসটেইনেট [1,2,3,4] ü = [[1,2],[2,3],[3,4]], আপনি যদি 05AB1E চালানোর সময় আর্গুমেন্টগুলিতে "-d" যুক্ত করেন তবে এটি "ডিবাগ" আউটপুট তৈরি করে যা আমি উপরে সংযুক্ত করেছি। (উপরেও ডিবাগ লিঙ্ক যুক্ত করা হয়েছে)। পেয়ারওয়াইজ ঝরঝরে হওয়ার কারণ হ'ল কমান্ডগুলি যা স্বয়ংক্রিয়ভাবে ভেক্টরাইজ হয়, এটি কেবল জোড় কমান্ড প্রয়োগ করে ( ü)একটি তালিকায় দৌড়ানো এটি ভাল দেখায়)।

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

আমি বুঝতে পেরেছি, এটি আমাকে উত্তরটিতে 1 বাইট সংরক্ষণ করতে দেয় । হিসাবে -d... আমি ,q"মুদ্রণ এবং থামাতে" "ডিবাগিং" পরে, এটি খুব দেরী waaay খুঁজে পেয়েছি । এটা খুবই কষ্টকর ছিল.

— স্কটিনেট

@scottinet আমি একটি পূর্ণ বছরের জন্য 05AB1E ব্যবহার হয়েছে চাই এটি সম্পর্কে :( শেখার আগে আমি ব্যবহার করা হয়েছে। =কারণ এটি পপ নয়, এবং মাত্র শেষ আইটেম স্ট্যাকে ধাক্কা ছাপে।

— ম্যাজিক অক্টোপাস ভস্মাধার

যদি আপনি সরাতে Uআপনি প্রতিস্থাপন করতে পারেন Xসঙ্গে Š।

— Emigna

8

গণিত, 72 64 59 58 বাইট

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

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

কিভাবে এটা কাজ করে

আমরা ইনপুটটিকে একটি তালিকা হিসাবে নিই {p,q}। পুনরাবৃত্তি পদক্ষেপটি এই হিসাবে সংস্কার করা হয়:

প্রতি দুটি উপাদানের (a+b)/dমধ্যে সন্নিবেশ করান এবং : এর এর ক্রম গণনা করে , শেষে একটি দিয়ে। আমরা দ্বারা বিভাজন , এবং প্রতিটি এবং এর মধ্যে সন্নিবেশ করান । বৃদ্ধি ।ab(x+{##2,}&@@x)a+ba+NulldRiffle(a+b)/dabd
Integerফলাফলের তালিকার উপাদানগুলি বেছে নিন । ( এটিও Nullপ্রবর্তন থেকে মুক্তি পেয়ে যায় {##2,}))

ফলাফল পরিবর্তন না হওয়া পর্যন্ত এটি পুনরাবৃত্তি করা হয় (যা কেবল তখনই ঘটতে পারে কারণ আমরা সমস্ত নতুন উপাদান সরিয়ে দিয়েছি, কারণ তাদের কোনওটিই পূর্ণসংখ্যার ছিল না)।

-8 বাইটস //.পরিবর্তে FixedPoint(এবং তালিকা হিসাবে ইনপুট নেওয়া থেকে) ব্যবহার করে @ মার্টিনইেন্ডারকে ধন্যবাদ জানায় ।

-6 আরও কারণ এটি ListConvolveআসলে দুর্দান্ত নয়

— মিশা লাভরভ
সূত্র

1

//.ট্রাম্প FixedPoint, এবং আমি কেবল দুটি পৃথক পূর্ণসংখ্যার পরিবর্তে পূর্ণসংখ্যার জোড় হিসাবে ইনপুট নেব:(d=2;#//.x_:>x~Riffle~ListConvolve[{1,1}/d++,x]~Cases~_Integer)&

— মার্টিন ইন্ডার

ধন্যবাদ! আমি প্রতিস্থাপন করতে ভুলে রাখা //.সঙ্গে FixedPoint, কারণ আমি সত্যিই সত্যিই পছন্দ করি, FixedPoint।

— মিশা লাভরভ

1

এটি মাত্র 64 বাইট tes দেখে মনে হচ্ছে আপনি দুটি অপ্রিন্টেবল ভিতরে .োকালেন Integer।

— মার্টিন ইন্ডার

আবার ধন্যবাদ! পরিবর্তনের পরে কেন আমার কোডটি ব্যর্থ করে দিয়েছিল তা আমি জানতাম না এবং আমি যখন এমন কাজগুলি করতাম যা সত্যই কোনও পার্থক্য না ঘটে তখন কাজ করে ফিরে যাব।

— মিশা লাভরভ

1

মন্তব্যে কোড স্নিপেটগুলির মাঝে মাঝে এই ছাপানো অক্ষরগুলি থাকে, বিশেষত যখন কোড স্নিপেটের একটি লাইন ব্রেক হয়। এসই কেন এগুলি .োকায় তা নিশ্চিত নয়।

— মার্টিন ইন্ডার

4

রুবি , 80 বাইট

->a,d=2{*b=a[0];a.each_cons 2{|x,y|z=x+y;b+=z%d>0?[y]:[z/d,y]};b==a ?a:f[b,d+1]}

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

fঅ্যারে হিসাবে ইনপুট গ্রহণ করা পুনরাবৃত্তি ফাংশন [p, q]।

— জলখাবার
সূত্র

4

হাস্কেল, 85 81 বাইট

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

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

ইনপুটটি তালিকা হিসাবে নেওয়া হয়, যেমন [1,2]।

সম্পাদনা করুন: -4 বাইট @ লাইকনি ধন্যবাদ।

— nimi
সূত্র

সঙ্গে দুটি বাইট সংরক্ষণ করুন l%d|l==l#d=l|e<-d+1=l#d%e।

— লাইকনি

@ লাইকনি: আসলে এটি চারটি বাইট ধন্যবাদ!

— নিমি

3

পাইথন 2 , 112 110 108 105 103 বাইট

^{-2 বাইট জোনাথন}
^{ফ্রেচকে ধন্যবাদ -5 বাইট ধন্যবাদ এরিক দ্য আউটগোল্ফারকে ধন্যবাদ}

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

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

— যষ্টি
সূত্র

y+=[...]*(...);y+=b,সমান নয় কি y+=[...]*(...)+[b]?

— জোনাথন ফ্রেচ

@ জোনাথনফ্রেচ হ্যাঁ

— রোড

103 বাইট

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

@EriktheOutgolfer আমি এই কাজ করার চেষ্টা ছিল, কিন্তু ছিল 110b উপর @ @।

— ডান্ডা

3

পাইথন 2 , 98 বাইট

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

হিসাবে আহ্বান f([p,q])। এটি অনলাইন চেষ্টা করুন!

জোনাথন অ্যালান 12 বাইট সংরক্ষণ করেছিলেন। ধন্যবাদ ~!

ব্যাখ্যা

fএকটি recursive ফাংশন হল: f(A, B, d)evalutes করতে f(next_A, A, d+1), যদি না A == B, যে ক্ষেত্রে এটা ফেরৎ A। (এটি দ্বারা পরিচালিত হয় A*(A==B)or …: যদি A ≠ B, A*(A==B)খালি তালিকা, যা মিথ্যা- y, তাই …অংশটি মূল্যায়ন করা হয়; যদি A = B A*(A==B)হয় A, যা খালি নয় এবং এভাবে সত্য হয় এবং এটি ফিরে আসে))

next_A হিসাবে গণনা করা হয়:

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

উদাহরণস্বরূপ এটি সর্বোত্তমভাবে ব্যাখ্যা করা হয়েছে। যখন যেমন d = 5 এবং A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]

— লিন
সূত্র

zipগণনার জায়গায় একটি ব্যবহার করে এবং এর প্রাথমিক মান [A[0]]হিসাবে 8 টি বাইট সংরক্ষণ করুনsum ।

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

পুনরাবৃত্ত ফাংশনটি ব্যবহার করে আরও 4 টি সংরক্ষণ করুন

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

নিবন্ধন করুন আমি অন্য বাইট প্রতিস্থাপন সংরক্ষিত [A[0]]সঙ্গে A[:1]:)

— লিন

1

এবং এখন আমি 3 বাইট দ্বারা এগিয়ে নেতৃত্ব করছি ধন্যবাদ A*(A==B)।

— লিন

2

পাইথন 2 , 111 বাইট

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

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

-8 রড ধন্যবাদ ।
-২ লিনকে ধন্যবাদ ।

— এরিক দ্য আউটগল্ফার
সূত্র

আপনার প্রয়োজন নেই iএবং এর a[x:x]চেয়ে ছোটa.insert

— রোড

@ রড নিস (আব) এর ব্যবহার o: পি

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

ত্যাগ zipও দুই বাইট সংরক্ষণ !

— লিন

একটি বিকল্প 111: পুরো forলুপটি এর দ্বারা প্রতিস্থাপন করুনwhile A[o+1:]:o+=1;s=A[o-1]+A[o];b=s%d<1;A[o:o]=[s/d]*b;m|=b;o+=b

— লিন

2

হুশ , 22 বাইট

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

একটি 2-উপাদান তালিকা নেয়, পূর্ণসংখ্যার এবং ভাসমানগুলির তালিকা দেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.

— Zgarb
সূত্র

1

পার্ল 5 , 92 + 1 ( `-a`) = 93 বাইট

do{$c=0;@n=shift@F;$.++;push@n,($t=$_+$n[-1])%$.?$_:($c=$t/$.,$_)for@F;@F=@n}while$c;say"@F"

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

— Xcali
সূত্র

1

রেটিনা , 111 বাইট

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

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

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

ব্যাখ্যা:

এটি প্রশ্নের মতো একই উদাহরণ ব্যবহার করবে।

\d+
$*1;

আমরা সংখ্যার ইনপুট অ্যারেটিকে একটি সেমিকোলন দ্বারা পৃথক করা অ্যানারি অ্যারেতে পরিবর্তন করি, তাই আমরা চাই:

1; 111111111111111111111;

^
11@

dশুরুতে আমাদের কোডটি লিখুন , আমাদের প্রদান করুন:

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

এটি কিছুটা জটিল। {এক পর্যায়ে একটি গোষ্ঠী শুরু করে যা নির্ধারিত পর্যায়ে পৌঁছানো পর্যন্ত কার্যকর করা হবে। তারপরে, +ইঙ্গিত দেয় যে এই পর্যায়ে নিজেই একটি নির্দিষ্ট পয়েন্ট অবধি কার্যকর করা উচিত। এই পর্যায়ে প্রতিটি সংলগ্ন সংখ্যার যুক্ত করে তবে অতিরিক্ত সেমিকোলন ছাড়াই এগুলি সন্নিবেশ করে। এখন আমাদের আছে:

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

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

11@1; a11111111111; 111111111111111111111;

1+

এটি এমন নম্বরগুলি মুছে দেয় যা dএই রাউন্ডের আগে বা অ্যারেতে বিভাজ্য ছিল না । এটি আমাদের উদাহরণে কোনও পরিবর্তন করে না।

.*a
1&$

এই লোভের সাথে স্ট্রিংয়ের শুরু থেকে ইনপুটটির শেষ অক্ষরের aসাথে মেলে । এর অর্থ সর্বাধিক এক ম্যাচ হতে পারে। আমরা যদি কোনও পরিবর্তন করি তবে আমরা এতে যুক্ত করব d, অন্যথায় এটিকে একইভাবে রেখে দিচ্ছি যাতে আমরা লুপটি থেকে বেরিয়ে যেতে পারি।

111@1; a11111111111; 111111111111111111111;

)`a

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

111@1; 11111111111; 111111111111111111111;

1+@

এই স্তরটি আমাদের আউটপুট থেকে সরিয়ে দেয়:

1; 11111111111; 111111111111111111111;

1+
$.&

এই পর্যায়ে দশমিক সংখ্যার সাথে অবিচ্ছিন্ন সংখ্যাগুলি প্রতিস্থাপন করে:

1; 11; 21;

চূড়ান্ত পর্যায়ে সেমিকোলনগুলি থেকে মুক্তি পাওয়া যায়:

1 11 21

স্পষ্টতই, লুপটি এড়িয়ে যাওয়া আমাদের এখানে একটি ভুল ফলাফল তৈরি করে, তবে আশা করি এটি খুব বিভ্রান্তিকর নয়।

— FryAmTheEggman
সূত্র

আমার মার্কআপ পূর্বরূপটি যে আউটপুট আমি দেখছি তার চেয়ে আলাদা দেখায় - কারও কোনও ধারণা আছে? বিশেষত কোড ব্লকগুলির একগুচ্ছ এক সাথে যোগদান করছে যখন আমি মনে করি না যে সেগুলি হওয়া উচিত।

— FryAmTheEggman

1

জাভাস্ক্রিপ্ট (ES6), 89 87 82 বাইট

ধন্যবাদ -আরনাউল্ড -২ বাইটের জন্য এবং আরও ৫ টি বাইট সংরক্ষণের জন্য ধন্যবাদ

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

একটি অ্যারে হিসাবে ইনপুট লাগে: f([p,q])।

পরীক্ষার মামলা

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— জাস্টিন মেরিনার
সূত্র

আমি মনে করি আপনি 1 বাইট সংরক্ষণ করার পরিবর্তে v( v+=b[++i]) আপডেট করতে পারবেন s। এর |rপরিবর্তে আপনি অন্য একটি বাইট সংরক্ষণ করতে পারেন &&r(আমি মনে করি এটি নিরাপদ তবে আমি ডাবল-চেক করিনি)।

— আর্নল্ড

@ আরনাউল্ড ধন্যবাদ! |rপ্রকৃতপক্ষে ব্যবহার করে সমস্ত পরীক্ষার কেস কেটে গেছে।

— জাস্টিন মেরিনার

এখানে একটি 85-বাইট বৈকল্পিক রয়েছে push()।

— আর্নৌল্ড

@ আরনাউল্ড নিস, আমি মূলত pushদু'বার পরিবর্তে একবার ব্যবহার করার কথা ভেবেছিলাম ; যে ধারণা পুনরায় পরিদর্শন পর আমি এসে এই 86 বাইট জন্য। এর কি উন্নতি হতে পারে?

— জাস্টিন মেরিনার

আপনি করতে পারেন push(v,...)এবং তারপরে v+=আবার 84 বাইট ব্যবহার করতে পারেন ।

— আর্নল্ড

1

রাদা , 90 বাইট

f a,d=2{A=[a()|slide 2|[_,(_1+_)/d]if[(_1+_2)%d=0]else[_1]]+a[-1]f A,d=d+1 if[a!=A]else A}

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

— fergusq
সূত্র

1

জাভা 8, 180 বাইট

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

ব্যাখ্যা:

এখানে চেষ্টা করুন।

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method

— কেভিন ক্রুইজসেন
সূত্র

1

সি #, 280 বাইট

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

কোড গল্ফ এ প্রথম প্রচেষ্টা, যা পুরো প্রোগ্রাম। এটা পরীক্ষা করো

2, 159 বাইট চেষ্টা করুন

ভাস্কর্যটি কেড়ে নেওয়া, যেহেতু কাজটি এমন একটি ফাংশন সরবরাহ করা যা একজোড়া সংখ্যার (একটি অ্যারে কাজ করে) নিতে পারে এবং একটি অ্যারে প্রদান করে। প্রদত্ত যে একটি Func <int- এ [], int- []> এফ প্রয়োজনীয়তা সন্তুষ্ট করতে ব্যবহার করা যেতে পারে, শুধু সংজ্ঞায়িত এফ :

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

এখানে সম্পূর্ণ প্রোগ্রাম পরীক্ষা করুন

এটি সাধারণ হতে পারে যদি জেনেরিক তালিকাটিকে বৈধ আউটপুট হিসাবে বিবেচনা করা হয় (10 বাইট সংরক্ষণ করতে .ToArray () বাদ দিন)।

যদি ইনপুটটিও পরিবর্তন করা যায়, তবে অ্যারের পরিবর্তে একটি তালিকা <int> এ পাস করা আউটপুট আরম্ভ করার প্রয়োজনীয়তা সরিয়ে ফেলবে (126 বাইটে আসে)।

এটি আরও একধাপ এগিয়ে নিয়ে যাওয়া, এই ক্ষেত্রে রিটার্ন মান হওয়ার দরকার নেই। পরিবর্তে কোনও অ্যাকশন ব্যবহার করা রিটার্ন স্টেটমেন্ট দ্বারা ব্যবহৃত 9 বাইট সরিয়ে দেয়।

— পল্লব
সূত্র

পিপিসিজিতে আপনাকে স্বাগতম! ভাল উত্তর।

— আর্নৌল্ড

1

জেলি , 19 বাইট

®‘©‘÷@+2\⁸żFfṀR$µÐL

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

— ডেনিস
সূত্র

একটি বিস্তৃত অ্যারে

উদাহরণ

ব্যাখ্যা এবং বিধি

পরীক্ষার মামলা

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

গণিত, 72 64 59 58 বাইট

কিভাবে এটা কাজ করে

রুবি , 80 বাইট

হাস্কেল, 85 81 বাইট

পাইথন 2 , 112 110 108 105 103 বাইট

পাইথন 2 , 98 বাইট

ব্যাখ্যা

পাইথন 2 , 111 বাইট

হুশ , 22 বাইট

ব্যাখ্যা

পার্ল 5 , 92 + 1 ( -a) = 93 বাইট

রেটিনা , 111 বাইট

ব্যাখ্যা:

জাভাস্ক্রিপ্ট (ES6), 89 87 82 বাইট

পরীক্ষার মামলা

রাদা , 90 বাইট

জাভা 8, 180 বাইট

জেলি , 19 বাইট

পার্ল 5 , 92 + 1 ( `-a`) = 93 বাইট