ভূমিকা

দুটি খালি খালি পূর্ণসংখ্যার অ্যারে বিবেচনা করুন, এ = [0 3 2 2 8 4] এবং বি = [7 8 7 2] বলুন । কর্ম সঞ্চালন করার জন্য প্রান্তিককরণ উপরন্তু তাদের উপর, আমরা নিচের কাজগুলো করুন:

মোট দৈর্ঘ্যের এলসিএম (দৈর্ঘ্য (এ), দৈর্ঘ্য (বি)) রাখার জন্য প্রতিটি অ্যারে পর্যাপ্ত সময় পুনরাবৃত্তি করুন । এখানে এলসিএম হ'ল সর্বনিম্ন সাধারণ একাধিক।
```
A -> [0 3 2 2  8 4][0 3  2 2 8 4]
B -> [7 8 7 2][7 8  7 2][7 8 7 2]
```
পুনরাবৃত্ত অ্যারেগুলিতে উপাদান অনুসারে সংযোজন সম্পাদন করুন এবং প্রতিটি অবস্থাতেই ফলাফল কেটে নিন যেখানে তাদের উভয়টিতেই কাটা আছে।
```
A -> [0  3 2 2   8  4][0 3  2  2  8 4]
B -> [7  8 7 2][ 7  8  7 2][7  8  7 2]
  -> [7 11 9 4][15 12][7 5][9 10 15 6]
```
অ্যারেগুলির এই অ্যারেটি আপনার ফলাফল।

কাজটি

আপনার ইনপুটগুলি পূর্ণসংখ্যার দুটি খালি খালি অ্যারে হয় এবং আপনার আউটপুট উপরের সংজ্ঞায়িত হিসাবে তাদের প্রান্তিককরণ সংযোজনের ফলাফল হবে। ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে হতে পারে। সংযোজন সম্পাদন করার সময় আপনাকে পূর্ণসংখ্যার ওভারফ্লো সম্পর্কে চিন্তা করতে হবে না।

বিধি এবং স্কোরিং

আপনি একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। সর্বনিম্ন বাইট গণনা জিতেছে।

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

[1] [4] -> [[5]]
[1,2,-3,-4] [15] -> [[16],[17],[12],[11]]
[0,-4] [2,1,0,-3] -> [[2,-3],[0,-7]]
[0,3,2,2,8,4] [7,8,7,2] -> [[7,11,9,4],[15,12],[7,5],[9,10,15,6]]
[18,17,16] [-1,-2,-3,-4] -> [[17,15,13],[14],[16,14],[15,13],[15],[16,14,12]]
[18,17,16,15] [-1,-2,-3,-4] -> [[17,15,13,11]]
[1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7],[6,7,3,2],[7],[6,7,6,7,6],[7,3,2],[7,6],[7,6,7,6,7],[3,2],[7,6,7],[6,7,6,7,3],[2],[7,6,7,6],[7,6,7,3,2]]
[1,1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7,6],[7,3,2],[7,6,7],[6,7,6,7,3,2]]
[1,1,1,1,1,1,1] [6,5,6,5,6,5,6,2,1] -> [[7,6,7,6,7,6,7],[3,2],[7,6,7,6,7],[6,7,3,2],[7,6,7],[6,7,6,7,3,2],[7],[6,7,6,7,6,7,3],[2],[7,6,7,6,7,6],[7,3,2],[7,6,7,6],[7,6,7,3,2],[7,6],[7,6,7,6,7,3,2]]

code-golf array-manipulation

— Zgarb
সূত্র

সি এর অ্যারের দৈর্ঘ্য জানার উপায় নেই - আমি কি অ্যারের দৈর্ঘ্যটিকে আর্গুমেন্ট হিসাবে অনুরোধ করতে পারি, বা অ্যারের শুরুতে এটি সঞ্চয় করতে পারি?

— বিড়াল

1

@ কেট আপনি অতিরিক্ত যুক্তি হিসাবে দৈর্ঘ্য নিতে পারেন, যদি না পাওয়ার অন্য কোনও উপায় না থাকে।

— Zgarb

9

জাভাস্ক্রিপ্ট (ES6), 101 99 বাইট

2 অ্যারে হিসাবে ইনপুট নেয়। একটি স্ট্রিং প্রদান করে।

f=(a,b,j=0,s='')=>a.map((v,i)=>(s+=i*j?' ':s&&'][',s+=b[j]+v,j=++j%b.length))|j?f(a,b,j,s):`[${s}]`

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

দ্বিতীয় অ্যারেতে অন্য পয়েন্টার আপডেট করার সময় আমরা aপয়েন্টার দিয়ে প্রথম অ্যারেতে পুনরাবৃত্তি করি । অঙ্কগুলি আউটপুট স্ট্রিংয়ে যুক্ত হয় । একটি বিভাজক প্রতিটি সময় বা sertedোকানো হয় । পুনরাবৃত্তি শেষে ঠিক ফিরে না আসা পর্যন্ত আমরা এই প্রক্রিয়াটির পুনরাবৃত্তি করি।ijba[i] + b[j]si == 0j == 0jb

দ্রষ্টব্য: যখন |অপারেটর প্রয়োগ a.map(...)করা হয় তখন জোর করে হয় হয় হয় হয় NaN(যদি aএকাধিক উপাদান থাকে) বা বর্তমান মান j(যদি aএকটি উপাদান যুক্ত থাকে তবে) সুতরাং, a.map(...)|j == jসমস্ত ক্ষেত্রে এবং এখানে ব্যবহার করা নিরাপদ।

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

কোড স্নিপেট দেখান

f=(a,b,j=0,s='')=>a.map((v,i)=>(s+=i*j?' ':s&&'][',s+=b[j]+v,j=++j%b.length))|j?f(a,b,j,s):`[${s}]`

console.log(f([1], [4]));
console.log(f([1,2,-3,-4], [15]));
console.log(f([0,-4], [2,1,0,-3]));
console.log(f([0,3,2,2,8,4], [7,8,7,2]));
console.log(f([18,17,16], [-1,-2,-3,-4]));
console.log(f([18,17,16,15], [-1,-2,-3,-4]));
console.log(f([1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));
console.log(f([1,1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));
console.log(f([1,1,1,1,1,1,1], [6,5,6,5,6,5,6,2,1]));

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

— Arnauld
সূত্র

আমি নোটের জন্য উত্তরটিও +1 বোঝার চেষ্টা করিনি । আমি কপি করব এবং এটি প্রয়োজন হলে পেস্ট করতে

— রাখব

6

হাস্কেল, 84 79 বাইট

a#b=a%b where(c:d)%(e:f)|(x:y)<-d%f=(c+e:x):y;[]%[]=[[]];c%[]=[]:c%b;_%d=[]:a%d

আমার প্রথম সংস্করণটি আরও পঠনযোগ্য লেআউটে একই ছিল:

a#b=a%b where
 (c:d)%(e:f)|(x:y)<-d%f=(c+e:x):y
 []%[]=[[]]
 c%[]=[]:c%b
 _%d=[]:a%d

এবং এর (%)জন্য অতিরিক্ত যুক্তি দেওয়া এড়াতে স্থানীয় সংজ্ঞা ব্যবহার করা । আশ্চর্যজনকভাবে, এটি প্রায় একই সময়ে প্রদত্ত @ নিমির মতো একই সমাধান, যার কাছ থেকে আমি স্থানীয় সংজ্ঞাটির জন্য কেবল একটি লাইন ব্যবহার করার ধারণা নিয়েছি।ab

ব্যবহার:

*Main> [0,3,2,2,8,4] # [7,8,7,2]
[[7,11,9,4],[15,12],[7,5],[9,10,15,6]]

— খ্রিস্টান সিভর্স
সূত্র

ওহ, তালিকার প্রথম উপাদানটিতে যোগফলটি প্রিপেন্ড করার একটি দুর্দান্ত উপায়। আমার কষ্টকর থেকে অনেক কম !।

— নিমি

4

পিএইচপি, 126 120 বাইট

function($a,$b){do{$c[$j][]=$a[$i%$x=count($a)]+$b[$i%$y=count($b)];++$i%$x&&$i%$y?:$j++;}while($i%$x|$i%$y);return$c;};

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

বেনামে ফাংশন যা ফলাফলের অ্যারেগুলিকে দেয় returns

মূলত, আমরা আমাদের অ্যারে উভয়ের সামগ্রীর মধ্য দিয়ে লুপ করি, তাদের পুনরুক্তিটি অ্যারে দ্বারা "অনুলিপি" অনুকরণের জন্য দৈর্ঘ্য করে প্রসারিত করি। অ্যারে থেকে প্রতিটি মান গ্রহণ করে, আমরা সেগুলি যোগ করি এবং তাদেরকে একটি অ্যারেতে যুক্ত করি $c। আমরা যদি (চ্যালেঞ্জের পরিপ্রেক্ষিতে একটি বিভক্ত,) আমাদের ইনপুট অ্যারে এক শেষে পৌঁছানোর, আমরা একটি নতুন অ্যারের মধ্যে বরাদ্দ শুরু $c।

কারণ do whileলুপ কারণ আমাদের অবস্থা উপর ভিত্তি করে $iযা শুরু 0। শুরুতে যখন শর্তটি পরীক্ষা করা হয় সেখানে যদি আমরা একটি লুপ ব্যবহার করি তবে লুপটি চলবে না

আমরা একই সময়ে উভয় অ্যারের শেষের দিকে পৌঁছানোর পরে কেবলমাত্র সমষ্টিটি শেষ করি, যা এলসিএমকে বোঝায়।

— Xanderhall
সূত্র

তা করা উচিত নয় $b[$i%$y]? $x=count($a)প্রথম ব্যবহারে গিয়ে আপনি 3 বাইট সঞ্চয় করতে পারবেন $x; একই $y=count($b)এবং এক বাইট বিটওয়াইস বা whileশর্তে

— টাইটাস

তবে আমি মনে করি বেনাম ফাংশনগুলি স্নিপেট হিসাবে বিবেচিত হয় এবং তাই কোনও কার্যকর উত্তর নেই।

— তিতাস

@Titus বেনামী ফাংশন অনুযায়ী ডিফল্টরূপে অনুমতি দেওয়া হয় মেটা উপর ঐক্যমত্য ।

— Zgarb

টিটাসের পরামর্শের জন্য ধন্যবাদ, আমি কেবল এটিকে একসাথে ছুঁড়ে দিয়েছি কারণ আমি অন্যান্য পিএইচপি উত্তরগুলিকে পরাজিত করতে চেয়েছিলাম: পি

— জ্যান্সারহাল

4

হাস্কেল, 87 84 বাইট

a#b=a%b where[]%[]=[[]];(e:f)%(g:h)=f%h!(e+g);e%[]=[]:e%b;_%g=[]:a%g
(m:n)!l=(l:m):n

ব্যবহারের উদাহরণ: [0,3,2,2,8,4] # [7,8,7,2]-> [[7,11,9,4],[15,12],[7,5],[9,10,15,6]]।

সাধারণ পুনরাবৃত্তি। বেস কেস: উভয় তালিকা খালি। যদি তাদের মধ্যে একটিই শূন্য থাকে তবে একটি সম্পূর্ণ সংস্করণ দিয়ে পুনরায় চালু করুন এবং আউটপুটটিতে একটি নতুন ক্লাস্টার শুরু করুন। যদি কোনওটি খালি না থাকে তবে যোগফলটিকে মৌলিক উপাদান থেকে প্রিন্ট করুন।

এছাড়াও কটাক্ষপাত আছে @Christian Sievers 'উত্তর , যা প্রায় অভিন্ন এবং কয়েক সেকেন্ড আগে পোস্ট করা হয়েছে।

— nimi
সূত্র

তুমি কি নিশ্চিত? সঠিক সময় পাওয়ার কোনও উপায় আছে কি?

— ক্রিশ্চান সিভর্স

@ খ্রিস্টিয়ানসিভারস: আপনি সরাসরি সময়গুলি দেখতে পারবেন কিনা তা আমি জানি না। যখন আমাদের সম্পাদনার সময়গুলি কয়েক মিনিটের মধ্যে প্রদর্শিত হয়েছিল, আমি মনে করি আপনার চেয়ে আমার কয়েক সেকেন্ড আগে (প্রায় 20) গণনা করা হয়েছিল।

— নিমি

আপনি ঠিক বলেছেন: আমি এই পৃষ্ঠার এইচটিএমএল উত্স কোডে টাইমস্ট্যাম্প পেয়েছি

— খ্রিস্টান সিভর্স

সঠিক সময়টি দেখতে "2 দিন আগে" উত্তর দেওয়া সময়ের মধ্যে ঘুরে দেখুন। (ইঙ্গিত: এটি ইন্টারনেট জুড়ে একটি স্ট্যান্ডার্ড ইউআই, সুতরাং (ক) আপনি যদি সঠিক সময় চান, আপেক্ষিক সময়টিকে ঘুরে দেখেন এবং (খ) আপনি যদি কখনও এমন কিছু প্রয়োগ করেন যা আপেক্ষিক সময় দেখায়, দয়া করে হোভারের সঠিক সময়টি দেখান !)

— wchargin

2

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

@(a,b)mat2cell(sum([repmat(a,1,(L=lcm(A=numel(a),B=numel(b)))/A);repmat(b,1,L/B)]),1,diff(unique([0:A:L,0:B:L])))

এটিকে এটিকে প্রথম বন্ধনে রেখে কল করতে এবং (@ (ক, খ) ...) ([1 2 3 4], [6 4 5]) হিসাবে এই ফাংশনটি সরাসরি কল করতে পারে

— rahnema1
সূত্র

1

এখন টিআইও-নেক্সাস অক্টাভে সমর্থন করে। কোডটি পরীক্ষা করার জন্য

— লুইস মেন্ডো

@ লুইস মেন্ডো ধন্যবাদ, আকর্ষণীয় পরিষেবা

— rahnema1

2

সিজেম , 30 বাইট

{Sf*Laf+_s,f*:.+La/0=S2*a-Sa/}

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

তালিকার জুড়ি হিসাবে ইনপুট নেয়।

ব্যাখ্যা

ধারণাটি হ'ল ইনপুট অ্যারেগুলিতে কিছু সংকেত প্রবেশ করানো (সংক্ষিপ্ত স্ট্রিং আকারে) যা নির্দেশ করে যে কোথায় বিন্যস্ত অ্যারেটি শেষ হয় এবং যেখানে অ্যারেগুলিতে ব্রেকগুলি সন্নিবেশ করা প্রয়োজন। এইভাবে আমরা এলসিএম গণনা করা এড়াতে পারি।

Sf*    e# Riffle each list with spaces. These are just place holders, so that having
       e# an array-end marker between two elements doesn't misalign subsequent elements.
Laf+   e# Append an empty string to each list. This is the array-end marker.
_s,    e# Convert the pair of lists to a string and get its length. This is always
       e# greater than the number of elements in either input.
f*     e# Repeat either array that many times. This is definitely more than necessary
       e# to reach the LCM (since multiplying by the length of the other list always
       e# gives a common multiple).
:.+    e# Pairwise addition of the list elements. There are four cases:
       e# - Both elements are numbers, add them. This is the actual addition
       e#   we need for the problem.
       e# - Both elements are spaces. This is just a regular position between
       e#   list elements.
       e# - One is a space, one is empty: the result is a single space, and
       e#   this marks a position where one of the arrays ended, which means
       e#   we need to split here.
       e# - Both elements are empty. This happens at the LCM of both list lengths
       e#   and indicates where we need to stop the output.
La/0=  e# Split the input around empty strings and discard everything except
       e# the first chunk.
S2*a-  e# Remove the double-space strings, we no longer need them.
Sa/    e# Split the list around single spaces.

— মার্টিন ইন্ডার
সূত্র

2

জেলি , 21 20 18 বাইট

ṁ€L€æl/$S
J€ỊÇœṗÇḊ

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

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

ṁ€L€æl/$S  Helper link. Argument [X, Y] (arrays of integers).

       $   Combine the two links to the left into a monadic chain.
  L€       Length each; yield the lengths of X and Y.
    æl/    Reduce by least common multiple.
ṁ€         Mold each; cyclically repeat the elements of X and Y to extend them
           to length lcm(length(X), length(Y)).
        S  Compute the sum of the extended X and Y arrays.

J€ỊÇœṗÇḊ   Main link. Argument [A, B] (arrays of integers).

J€         Indices each; replace A and B by the arrays of there 1-based indices.
  Ị        Insignificant; map 1 to itself, all other indices to 0.
   Ç       Apply the helper link to the result.
           This yield a Boolean array with a 1 (or 2) at all indices where a new
           repetition of A or B (or both) begins.
      Ç    Apply the helper link to [A, B].
    œṗ     Partition; break the result to the right at truthy elements (1 or 2) in
           the result to the right.
       Ḋ   Dequeue; remove the first element of the partition (empty array).

— ডেনিস
সূত্র

2

পাইথন 3.5 - ( 146 137 134 130 + 12) = 142 বাইট

import math
def s(a,b):
 l,k,*r=map(len,[a,b])
 for i in range(l*k//math.gcd(l,k)):
  r+=a[i%l]+b[i%k],
  if i%k==k-1or i%l==l-1:print(r);r=[]

লুপের জন্য কীভাবে পুরো এক লাইনে রাখব তা আমি বুঝতে পারি না।

সম্পাদনা:

জগারব 9 টি বাইট সংরক্ষণের জন্য ধন্যবাদ !
3 টি বাইট সংরক্ষণের জন্য ভল্টাহ ধন্যবাদ !
ধন্যবাদ ম্যাথমন্ডনে ৫ টি বাইট সাশ্রয়!

— গুরুপদ মামাদপুর
সূত্র

এটি আমার জন্য একটি ত্রুটি দেয় । gcdফাংশন রয়েছে fractions, না math।

— জাগারব

@ জাগারব ভগ্নাংশের মডিউলে থাকা জিসিডি অবচিত করা হয়েছে , আপনি পরিবর্তনটি এখানে পরীক্ষা করতে পারেন । আমার ধারণা রেক্সটার পুরানো সংস্করণটি ব্যবহার করছে 3.4.3।

— গুরুপদ মামাদপুর

ঝরঝরে, আমি এই পরিবর্তন সম্পর্কে জানতাম না। আপনার ভাষাটি "পাইথন 3.5" হিসাবে চিহ্নিত করা উচিত, কারণ এটি 3.4 বা তার আগের কাজ করে না। এছাড়াও, আপনি বন্ধনীগুলি প্রায় ফেলে দিতে পারেন l*kএবং print(r);r=[]শেষ লাইনে থাকতে পারেন।

— Zgarb

আপনি কি নিশ্চিত যে আপনার বাইট গণনাটি সঠিক? আমি মনে করি কেবল 145 বাইট আছে

— ভোল্টাহ

1

আমি 142 বাইট পাচ্ছি আপনি কি উইন্ডোজ ব্যবহার করছেন? উইন্ডোজ সাধারণত নিউলাইনগুলিকে প্রতিটি 2 বাইট হিসাবে গণনা করে তবে এখানে প্রতিটি নিউলাইন একক বাইট হিসাবে গণনা করা হয়।

— mathmandan

2

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

a=input()
i,v,l=0,list(a),len
while 1:q=l(v[0])>l(v[1]);print map(sum,zip(*v)[i:]);i=l(v[q]);v[q]+=a[q];1/(i-l(v[q^1]))

স্ট্যান্ডিন থেকে ইনপুট নেয় কমা দ্বারা পৃথক দুটি tuples হিসাবে, ফলাফলগুলি ফলাফলকে stdout এ আউটপুট দেয়। ZeroDivisionErrorব্যতিক্রম উত্থাপন করে অবসান ঘটে , যেহেতু মনে হচ্ছে এটি অনুমোদিত হবে ।

উদাহরণস্বরূপ, যদি ইনপুট হয় (0, 3, 2, 2, 8, 4), (7, 8, 7, 2)তবে প্রোগ্রামটি মুদ্রণ করবে

[7, 11, 9, 4]
[15, 12]
[7, 5]
[9, 10, 15, 6]

stdout এবং stderr ব্যতিক্রম ট্রেসব্যাক।

— vaultah
সূত্র

আপনি কোনও ত্রুটি ফেলে প্রোগ্রামটি থেকে বেরিয়ে আসতে পারেন । তারপরে আপনি লুপটি একটি এক লাইনে আনতে সক্ষম হতে পারেন।

— Zgarb

2

জে , 34 32 বাইট

[:(<;.1~*)/[:+/*.&#$&>,:&(;2>#\)

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

ব্যাখ্যা

[:(<;.1~*)/[:+/*.&#$&>,:&(;2>#\)  Input: array A (LHS), array B (RHS)
                             #\   Length of each prefix of A and B
                           2>     Less than 2
                          ;       Link each with A and B
                      ,:&         Pair them
                  #               Length of A and B
               *.&                LCM of the lengths
                    &>            For each box
                   $              Reshape it to the LCM of the lengths
           [:+/                   Reduce by addition
[:        /                       Reduce by
        *                           Sign of RHS
   <;.1~                            Box each partition of LHS

— মাইল
সূত্র

1

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

এটি সম্ভবত সবচেয়ে মার্জিত পদ্ধতির নয়: মূলত ফাংশন ?থিমসগুলির সাহায্যে প্রয়োজনীয় দৈর্ঘ্যের একটি তালিকা তৈরি করে এবং %এই যোগফলটি আবার কাটাচ্ছে। !চূড়ান্ত ফাংশন যা এই দুটি একত্রিত করে।

l=length
a?b=take(lcm(l a)$l b)$zipWith(+)(cycle a)$cycle b
l%(i:ind)|l==[]=[]|1>0=take i l:(drop i l)%(map(+(-i))ind)
a!b=(a?b)%[k|k<-[1..],k`mod`l a<1||k`mod`l b<1]

— flawr
সূত্র

আপনি প্রতিস্থাপন করতে পারেন indদ্বারা kবা কিছু, এবং কিছু অপ্রয়োজনীয় প্রথম বন্ধনী চারপাশে আছে drop i lএবং map(+(-i))ind। %প্যাটার্ন ম্যাচিংয়ের সাথে দুটি ক্ষেত্রেও বিবেচনা করুন l।

— জাগারব

1

[পিএইচপি], 183 152 135 বাইট

function O($A,$B){while($f<2){$O[$k][]=$A[+$i]+$B[+$j];$f=0;isset($A[++$i])?:$i=!++$k|!++$f;isset($B[++$j])?:$j=!++$k|!++$f;}return$O;}

দুর্দান্ত সংস্করণ:

function O($A,$B)
{
    while($f<2) {
        $O[$k][]=$A[+$i]+$B[+$j];
        $f=0;
        isset($A[++$i])?:$i=!++$k|!++$f;
        isset($B[++$j])?:$j=!++$k|!++$f;
    }

    return$O;
}

আউটপুট:

array (size=4)
  0 => 
    array (size=4)
      0 => int 7
      1 => int 11
      2 => int 9
      3 => int 4
  1 => 
    array (size=2)
      0 => int 15
      1 => int 12
  2 => 
    array (size=2)
      0 => int 7
      1 => int 5
  3 => 
    array (size=4)
      0 => int 9
      1 => int 10
      2 => int 15
      3 => int 6

— Dexa
সূত্র

এমনকি এই টুইটগুলি ব্যবহার করে আমার সাথে আঁকুন: $i=$j=$k=0;আপনি যদি অতিরিক্ত অতিরিক্তকরণ +$i(-8 বাইট) এর অ্যারে সূচকগুলির জন্য ইত্যাদি ব্যবহার করেন তবে তা অপ্রয়োজনীয় । $i++;if(!isset($A[$i])){$i=0;$k++;}-> isset($A[++$i])?:$i=!++$k;(-9, দুবার) $i==0&&$j==0&&!isset()-> !$i&!$j&!isset()(-6)। return$O;কোন স্থান প্রয়োজন (-1)।

— তিতাস

@ টিটাস $i=$j=0;অংশটি সরাতে পারবেন না কারণ অ্যারে থেকে প্রথম মানগুলি সঠিক হবে না। আমি যুক্তিটিকে কিছুটা সংশোধন করেছি যাতে এই ক্ষেত্রে টের্নারি অপারেটরগুলি কীভাবে প্রয়োগ করা যায় তা নিশ্চিত নয়। ++$iপরামর্শের জন্য ধন্যবাদ ।

— ডেক্সা

ব্যবহার করে দেখুন unset($i);$A[+$i]। +নিক্ষেপ করা হবে nullপূর্ণসংখ্যা 0।

— তিতাস

if(!isset($A[++$i])){$i=0;++$k;++$f;}-> isset($A[++$i])?:$i=!++$k|!++$f;এখনও প্রতি পাঁচটি বাইট সাশ্রয় করে। $f<2পরিবর্তে আরও একটি সংরক্ষণ করুন $f!=2। এবং এর while($f=$f<3){...}পরিবর্তে আরও দু'টি while($f<2){$f=0;...}( $f

— তিতাস

@ টিটাস অনেক ধন্যবাদ, এখন এটি সংক্ষিপ্ত।

— ডেক্সা

1

পাওয়ারশেল , 147 145 বাইট

param($a,$b)$o=@{};do{$o[+$j]+=,($a[+$i%($x=$a.count)]+$b[$i++%($y=$b.count)]);if(!($i%$x-and$i%$y)){$j++}}until(($x,$y|?{!($i%$_)}).count-eq2)$o

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

( Golfing পরামর্শ স্বাগত জানাই। আমি সেখানে সম্ভবত অন্য 10 থেকে 15 বাইট যে এ থেকে চিপা করা যেতে পারে মনে। )

@(...)কমান্ড-লাইন আর্গুমেন্ট হিসাবে দুটি সুস্পষ্ট অ্যারে ( সিনট্যাক্স সহ) হিসাবে ইনপুট নেয় । ফলস্বরূপ অ্যারেগুলির একটি হ্যাশটেবল ফিরিয়ে দেয়, কারণ পাওয়ারশেলে বহুমাত্রিক অ্যারেগুলি অদ্ভুত হতে পারে এবং এটি আরও সুসংগত। সেট কিছু প্রাথমিক ভেরিয়েবল, তারপর প্রবেশ do/ untilশর্তসাপেক্ষ হচ্ছে দিয়ে আবার লুপ পর্যন্ত $iহয় অ্যারের গন্য এর LCM ।

প্রতিটি লুপ পুনরাবৃত্তি, আমরা সংশ্লিষ্ট $aএবং $bমানগুলি একসাথে ,(...)যুক্ত করি $o, উপযুক্ত স্থানে হ্যাশ টেবিলটিতে যুক্ত করার আগে এটি অ্যারে হিসাবে বিবেচনা করি $j। পাটিগণিত সংযোজন রোধ করার জন্য অ্যারের এনক্যাপসুলেশন প্রয়োজনীয় - এটি +=পরিবর্তে অ্যারে কনটেনটেশনকে ওভারলোড করতে বাধ্য করে । তারপরে, শর্তযুক্ত $xএবং $y(গণনা) নির্ধারণ করার জন্য আমরা কোনও অ্যারে প্রান্তে আছি কিনা - যদি তা হয় তবে আমরা বৃদ্ধি করি $j।

অবশেষে, আমরা $oপাইপলাইনে ছেড়ে যাই এবং আউটপুট অন্তর্ভুক্ত।
(এনবি: পাওয়ারশেল কীভাবে ডিফল্টর সাথে Write-Outputহ্যাশ টেবিলগুলি গণনা করে , এর ফলে এটি "পশ্চাদপসরণ" আউটপুট হিসাবে প্রবাহিত হয়; যেমন "0 তম" ফলস্বর অ্যারে আউটপুটটির "নীচে" থাকে। হ্যাশ নিজেই ভাল, এবং হবে ঠিক যেমন যদি আপনি উদাহরণস্বরূপ ব্যবহার করেন তবে এই কোডটি একটি রিটার্ন ভেরিয়েবলের মধ্যে সজ্জিত করুন ... এটি মুদ্রিত হওয়ার পরে কেবল অদ্ভুত লাগবে))

পৃথক (দুটি সেমিকোলন সংরক্ষণ করা) না দিয়ে অ্যারে সূচকগুলিতে than x এবং $ y স্থানান্তরিত করে 2 বাইট সংরক্ষণ করা।

— AdmBorkBork
সূত্র

1

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

a,b=input()
i=m=n=0;r=[]
while(not i)+m+n:r+=[[]]*(not m*n);r[-1]+=[a[m]+b[n]];i+=1;m=i%len(a);n=i%len(b)
print r

— orlp
সূত্র

গেল notগুলি হতে <1গুলি পরিবর্তে?

— Zgarb

1

পাইথন 3.5, 210 176 173 169 158 বাইট

def f(a,b):
 x=[];e=f=0              
 while 1:
  if e==len(a):         
   print(x);x=[];e=0;
   if f==len(b):break
  if f==len(b):print(x);x=[];f=0
 x+=a[e]+b[f],;e+=1;f+=1

ইনপুট হিসাবে দুটি তালিকা নেয় এবং সমস্ত তালিকা মুদ্রণ করে।

এটি আমার প্রথম উত্তর এবং আমি এখনও গল্ফ জানি না। আমি যে প্রাথমিক ধারণাটি ব্যবহার করেছি তা হ'ল প্রতিটি তালিকার জন্য দুটি কাউন্টার থাকা যা একটি বিভক্তিকে নির্দেশ করে এবং একটি বর্তমান তালিকা যেখানে যুক্ত করা মানগুলি যুক্ত করা হয়; বিভাজনের সম্মুখীন হওয়ার সাথে সাথে আমরা বর্তমান তালিকাটি মুদ্রণ করে একটি নতুন খালি তৈরি করব।

34 বাইট সংরক্ষণ করেছেন : ডেনিস এবং টিমমিডকে ধন্যবাদ
3 টি বাইট সংরক্ষিত : লেন (ক) এবং লেন (বি) এর জন্য সি এবং ডি ব্যবহার করছিল, তবে দেখা যাচ্ছে যে তারা কার্যকর হয়নি
4 টি বাইট সংরক্ষিত : অরপালকে ধন্যবাদ , অপ্রয়োজনীয় প্যারানথেসিস সরিয়ে দেওয়া
11 টি বাইট সংরক্ষণ করা হয়েছে : কয়েকটি ব্লক পুনরায় সাজানো হয়েছে এবং সেগুলি নীচে নামিয়ে দেওয়া হয়েছে

— officialaimm
সূত্র

1

হাই, এবং প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ এ আপনাকে স্বাগতম! প্রতিদ্বন্দ্বিতা মানে এখানে অন্য কিছু; আপনি এটি অপসারণ করা উচিত। আপনি হোয়াইটস্পেস বাদ দিয়ে বেশ কয়েকটি বাইট সংরক্ষণ করতে পারেন। উদাহরণস্বরূপ, 2 থেকে 5 লাইন হয়ে যেতে পারে x=[];c=len(a);d=len(b);e=f=0। এছাড়াও, trueহয়ে উঠতে পারে 1, x.append(a[e]+b[f])হয়ে যেতে পারে x+=a[e]+b[f],।

— ডেনিস

1

পিপিসিজিতে আপনাকে স্বাগতম! ডেনিসের নির্দিষ্ট টুইটগুলি ছাড়াও, আরও কিছু সাধারণ ইঙ্গিত ও কৌশল পেতে পাইথনে গল্ফিংয়ের টিপস দেখুন।

— অ্যাডমবর্কবার্ক

1

ifএবং whileবিবৃতিগুলির প্রথম বন্ধনী প্রয়োজন হয় না।

— orlp

1

রেকেট 373 বাইট

(let*((lg length)(fl flatten)(ml make-list)(t rest)(r reverse)(m modulo)(o cons)(ln(lg l))(jn(lg j))(c(lcm ln jn))(l2(fl(ml(/ c ln)l)))
(j2(fl(ml(/ c jn)j)))(ll(for/list((a l2)(b j2))(+ a b))))(let p((ll ll)(ol '())(tl '())(n 0))(cond[(empty? ll)(t(r(o(r tl)ol)))]
[(or(= 0(m n ln))(= 0(m n jn)))(p(t ll)(o(r tl)ol)(take ll 1)(+ 1 n))][(p(t ll)ol(o(first ll)tl)(+ 1 n))])))

Ungolfed:

(define(f l j)
  (let* ((ln (length l))
         (jn (length j))
         (c (lcm ln jn))
         (l2 (flatten (make-list (/ c ln) l)))
         (j2 (flatten (make-list (/ c jn) j)))
         (ll (for/list ((a l2)(b j2))
               (+ a b))))

    ; TO CUT LIST INTO PARTS: 
    (let loop ((ll ll)
               (ol '())
               (templ '())
               (n 0))
      (cond
        [(empty? ll) 
         (rest (reverse (cons (reverse templ) ol)))]
        [(or (= 0 (modulo n ln))
             (= 0 (modulo n jn)))
         (loop (rest ll)
               (cons (reverse templ) ol)
               (list (first ll))
               (add1 n))]
        [(loop (rest ll)
               ol
               (cons (first ll) templ)
               (add1 n))]))))

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

(f '[1]  '[4])
(f '[1 2 -3 -4] '[15])
(f '[0 3 2 2 8 4]  '[7 8 7 2])

আউটপুট:

'((5))
'((16) (17) (12) (11))
'((7 11 9 4) (15 12) (7 5) (9 10 15 6))

— rnso
সূত্র

1

ক্লোজার, ~~280~~ 206 বাইট

(fn[a b](let[A(count a)B(count b)Q quot](map #(map last %)(partition-by first(take-while #((% 0)2)(map-indexed(fn[i s][[(Q i A)(Q i B)(or(= i 0)(>(mod i A)0)(>(mod i B)0))]s])(map +(cycle a)(cycle b))))))))

আচ্ছা এটি আরও অনেক কিছু বোঝায়। উপাদান অনুসারে যোগফল তৈরি করা, অবস্থানগত মেটাডেটা যুক্ত করা, যখন আমরা এখনও পুনরাবৃত্তি করি নি এবং প্রতিটি পার্টিশনের যোগফলকে রেখেছি taking

(def f (fn[a b]
         (let[A(count a)B(count b)Q quot]
           (->> (map +(cycle a)(cycle b))
                (map-indexed (fn [i s][[(Q i A)(Q i B)(or(= i 0)(>(mod i A)0)(>(mod i B)0))]s]))
                (take-while #((% 0)2))
                (partition-by first)
                (map #(map last %))))))

আসল: আমি এটির উন্নতি করার প্রত্যাশা করছি তবে এটি আমার পক্ষে এখনকার সবচেয়ে দীর্ঘতম।

(fn[a b](let [C cycle o count c(take-while #(or(=(% 0)0)(>(% 1)0)(>(% 2)0))(map-indexed(fn[i[A B]][i(mod i(o a))(mod i(o b))(+ A B)])(map(fn[& v]v)(C a)(C b))))](map #(map last %)(partition-by first(map(fn[p c][p(last c)])(reductions + (map #(if(or(=(% 1)0)(=(% 2)0))1 0)c))c)))))

অবহেলিত এবং ভার্বোজ:

(def f (fn[a b]
         (let [c(->> (map (fn[& v]v) (cycle a) (cycle b))
                     (map-indexed (fn[i[A B]][i (mod i(count a)) (mod i(count b)) (+ A B)]))
                     (take-while #(or(=(% 0)0)(>(% 1)0)(>(% 2)0))))]
           (->> (map (fn[p c][p(last c)]) (reductions +(map #(if(or(=(% 1)0)(=(% 2)0))1 0)c)) c)
                (partition-by first)
                (map #(map last %))))))

সংগ্রহের একটি অসীম চক্র "মার্জিং" দিয়ে শুরু হয় aএবং b, সংগ্রহের মধ্যে প্রতিটি উপাদান সূচকে মেটাডেটা যুক্ত করে, উভয় ক্রমটি সূচক 0 থেকে আবার শুরু না হওয়া পর্যন্ত লাগে।

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

আমি মনে করি উল্লেখযোগ্য উন্নতির জন্য সম্পূর্ণ ভিন্ন পদ্ধতির প্রয়োজন।

— NikoNyrh
সূত্র

1

পিএইচপি, 150 121 119 বাইট

function($a,$b){while($i<2|$x|$y)$r[$k+=!($x=$i%count($a))|!$y=$i++%count($b)][]=$a[$x]+$b[$y];array_pop($r);return$r;}

বেনামে ফাংশন অ্যারে হিসাবে ইনপুট নেয়।

ভাঙ্গন

while($i<2|$x|$y)   // loop while either $a or $b has NO cut
    $r[
                // if either $a or $b has a cut, increment $k; post-increment $i
        $k+=!($x=$i%count($a))|!$y=$i++%count($b)
                // append current $a + current $b to $r[$k]
    ][]=$a[$x]+$b[$y];
array_pop($r);  // $r has one element too much; remove it
return$r;

— তিতাস
সূত্র

0

সি ++ 14, 206 বাইট

নামহীন জেনেরিক ল্যামডা, প্রয়োজন ইনপুট পাত্রে হিসাবে P, Qএবং আউটপুট ধারক Rমত হতে vector<vector<int>>।

[](auto P,auto Q,auto&R){R.clear();auto a=P.begin(),b=Q.begin(),x=P.end(),y=Q.end();auto A=a,B=b;do{R.emplace_back();while(a!=x&&b!=y)R.back().push_back(*a+++*b++);a=a==x?A:a;b=b==y?B:b;}while(a!=A||b!=B);}

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

#include<vector>
#include<iostream>

using namespace std;

auto f=
[](auto P,auto Q,auto&R){
 R.clear();               //just clear the output to be sure
 //a and b are the iterators, x and y is the end
 auto a=P.begin(),b=Q.begin(),x=P.end(),y=Q.end();
 //just some abbreviations for .begin()
 auto A=a,B=b;
 do{
  R.emplace_back();      //add new vector
  while(a!=x&&b!=y)      //while not at the end of one vector
   R.back().push_back(*a+++*b++);  //add the pointed elements and advance
  a=a==x?A:a;            //reset if at the end   
  b=b==y?B:b;
 }while(a!=A||b!=B);     //if both were resetted, then finish
}
;


int main(){
 vector<int> A = {0, 3, 2, 2, 8, 4};
 vector<int> B = {7, 8, 7, 2};
 vector<vector<int>> R;
 f(A,B,R);
 for (auto c:R){
  for (int x:c)
   cout << x << ", ";
  cout << endl;
 }
 cout << endl;
}

— কার্ল ন্যাপ
সূত্র

0

গণিত 112 বাইট

এটি সম্ভবত উন্নতি করা যেতে পারে। ধারণাটি হ'ল প্রতিটি ইনপুট অ্যারের দৈর্ঘ্যকে আমি মোডের মডেলের কাউন্টারের ট্র্যাক করতে ব্যবহৃত দ্বিতীয় এলিমেন্ট সহ 2 ডি অ্যারে তৈরি করব।

Split[Table[{#[[1,(m=Mod[i,d=Length/@#,1])[[1]]]]+#[[2,m[[2]]]],Min@m},{i,LCM@@d}],#2[[2]]>#1[[2]]&][[;;,;;,1]]&

ব্যবহার

%@{{0,3,2,2,8,4},{7,8,7,2}}

— কেলি লোদার
সূত্র

0

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

(a,b,g=(r,[n,...d]=a,[m,...e]=b,s=[])=>1/n?1/m?g(r,d,e,[...s,n+m]):g([...r,s],[n,...d]):1/m?g([...r,s],a,[m,...e]):[...r,s])=>g([])

সামান্য শৃঙ্খলাবদ্ধ:

(a,b,r=[],[n,...d]=a,[m,...e]=b,s=[])
=>1/n?1/m?f(a,b,r,d,e,[...s,n+m])
         :f(a,b,[...r,s],[n,...d],b,[])
     :1/m?f(a,b,[...r,s],a,[m,...e],[])
         :[...r,s]

যদি উভয় অ্যারে dএবং eসংখ্যা থাকে তবে প্রথম সংখ্যার যোগফল যুক্ত হয় sএবং বাকী উপাদানগুলি পুনরাবৃত্তভাবে প্রক্রিয়া করা হয়
যদি অ্যারেগুলির একটিতে সংখ্যা থাকে তবে অঙ্কগুলির অ্যারে sফলাফলের সাথে যুক্ত হয় rএবং অন্য অ্যারেটি তার প্রাথমিক অ্যারেটিতে পুনরায় সেট করা হয়
উভয় অ্যারে যদি খালি থাকে তবে কেবল সর্বশেষ অঙ্কগুলি যুক্ত করে ফলাফলটি ফিরিয়ে দিন।

দুঃখের বিষয় এই সমাধানটিতে @ আরনোল্ডসের নির্মম দক্ষতা নেই তবে কমপক্ষে আমি মনে করি এটি একটি সুন্দর সমাধান।

— নিল
সূত্র

অ্যারে সারিবদ্ধকরণ সংযোজন

ভূমিকা

কাজটি

বিধি এবং স্কোরিং

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

জাভাস্ক্রিপ্ট (ES6), 101 99 বাইট

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

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

হাস্কেল, 84 79 বাইট

পিএইচপি, 126 120 বাইট

হাস্কেল, 87 84 বাইট

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

সিজেম , 30 বাইট

ব্যাখ্যা

জেলি , 21 20 18 বাইট

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

পাইথন 3.5 - ( 146 137 134 130 + 12) = 142 বাইট

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

জে , 34 32 বাইট

ব্যাখ্যা

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

[পিএইচপি], 183 152 135 বাইট

পাওয়ারশেল , 147 145 বাইট

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

পাইথন 3.5, 210 176 173 169 158 বাইট

রেকেট 373 বাইট

পিএইচপি, 150 121 119 বাইট

সি ++ 14, 206 বাইট

গণিত 112 বাইট

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