परिचय

दो गैर-खाली पूर्णांक सरणियों पर विचार करें, A = [0 3 2 2 8 4] और B = [7 8 7 2] कहें । प्रदर्शन करने के लिए संरेखण इसके अलावा उन पर, हम निम्न कार्य करें:

कुल लंबाई lcm (लंबाई (A), लंबाई (B)) के लिए प्रत्येक सरणी को पर्याप्त बार दोहराएं । यहाँ lcm सबसे आम बहु के लिए खड़ा है।
```
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
स्रोत

C के पास किसी सरणी की लंबाई जानने का कोई तरीका नहीं है - क्या मैं किसी तर्क के रूप में सरणी की लंबाई का अनुरोध कर सकता हूं, या इसे सरणी की शुरुआत में संग्रहीत किया है?

— बिल्ली

1

@cat आप अतिरिक्त तर्कों के रूप में लंबाई ले सकते हैं, अगर उन्हें प्राप्त करने का कोई अन्य तरीका नहीं है।

— जर्गर्ब

9

जावास्क्रिप्ट (ईएस 6), 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एक पॉइंटर के साथ पहले एरे पर पुनरावृति iकरते हैं । Sums को आउटपुट स्ट्रिंग में जोड़ा जाता है । हर बार एक विभाजक डाला जाता है या । हम इस प्रक्रिया को तब तक दोहराते हैं जब तक कि एक पुनरावृत्ति के अंत में इसकी शुरुआत नहीं हो जाती ।jba[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

और के (%)लिए अतिरिक्त तर्क देने से बचने के लिए एक स्थानीय परिभाषा का उपयोग करना । आश्चर्यजनक रूप से, यह लगभग उसी समय दिया गया समाधान है, जब @ nimi के रूप में लगभग उसी समय दिया गया था, जिससे मैंने स्थानीय परिभाषा के लिए केवल एक पंक्ति का उपयोग करने का विचार लिया था।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

PHP, 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;};

यहाँ कोशिश करो!

बेनामी फ़ंक्शन जो सरणियों के परिणामस्वरूप सरणी लौटाता है।

अनिवार्य रूप से, हम अपने दोनों सरणियों की सामग्री के माध्यम से लूप करते हैं, हमारे 'इटरेटर' को 'कॉपी' करने के लिए सरणी की लंबाई से मोडिंग करते हैं। सरणियों से प्रत्येक मान लेते हुए, हम उन्हें जोड़ते हैं और उन्हें एक सरणी में जोड़ते हैं $c। यदि हम अपने इनपुट सरणियों (चुनौती के संदर्भ में एक विभाजन) के अंत तक पहुंचते हैं, तो हम एक नए सरणी में असाइन करना शुरू करते हैं $c।

के लिए कारण do whileपाश क्योंकि हमारे स्थिति के आधार पर किया जाता है $i, जिस पर शुरू होता है, 0। यदि हम एक लूप का उपयोग करते हैं जहां स्थिति की शुरुआत में जाँच की जाती है, तो लूप नहीं चलेगा

एक बार में हम दोनों सरणियों के अंत तक पहुंचने के बाद हम समन समाप्त करते हैं, जो LCM होगा।

— Xanderhall
स्रोत

कि नहीं होना चाहिए $b[$i%$y]? $x=count($a)के पहले उपयोग पर जाकर आप 3 बाइट्स बचा सकते हैं $x; उसी के लिए $y=count($b)और एक बाइट के साथ बिटवाइज़ या whileकंडीशन में

— टाइटस

लेकिन मुझे लगता है कि अनाम कार्यों को स्निपेट माना जाता है और इसलिए कोई मान्य उत्तर नहीं हैं।

— टाइटस

@ मेटा पर अनाम सहमति के अनुसार डिफ़ॉल्ट रूप से अनाम कार्यों को अनुमति दी जाती है ।

— 18

सुझाव के लिए धन्यवाद @Titus, मैं सिर्फ थोड़े इसे एक साथ फेंक दिया, क्योंकि मैं दूसरे PHP के जवाबों को हरा देना चाहता था: P

— Xanderhall

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
स्रोत

क्या आपको यकीन है? क्या सटीक समय पाने का कोई तरीका है?

— क्रिश्चियन सेवर्स

@ChristianSievers: मैं नहीं जानता कि क्या आप सीधे समय देख सकते हैं। जब हमारे संपादन का समय मिनटों में दिखाया गया था, तो मुझे याद है कि तुम्हारा कुछ सेकंड (लगभग 20) पहले मेरा था।

— नीमी

आप सही कह रहे हैं: मुझे इस पृष्ठ के html स्रोत कोड में टाइमस्टैम्प मिला

— क्रिश्चियन सेवर्स

सटीक समय देखने के लिए "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

अब TIO-Nexus ऑक्टेव को सपोर्ट करता है। यहाँ कोड का परीक्षण करने

— लुइस मेंडू

@LuisMendo धन्यवाद, दिलचस्प सेवा

— rahnema1

2

सीजेएम , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सूचियों की एक जोड़ी के रूप में इनपुट लेता है।

व्याख्या

विचार कुछ मार्करों को इनपुट सरणियों (लघु तारों के रूप में) में सम्मिलित करने का है जो इंगित करता है कि संरेखित सरणी कहां समाप्त होती है, और जहां हमें सरणियों में ब्रेक सम्मिलित करने की आवश्यकता होती है। इस तरह हम LCM की गणना करने से बच सकते हैं।

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 बाइट्स बचाने के लिए धन्यवाद zgarb !
3 बाइट बचाने के लिए धन्यवाद तिजोरी !
धन्यवाद mathmandan 5 बाइट्स बचत!

— गुरुपाद ममदापुर
स्रोत

यह मेरे लिए एक त्रुटि देता है । gcdसमारोह में है fractions, नहीं math।

— झगरब

@Zbb फ्रैक्चर मॉड्यूल में gcd को हटा दिया गया है , आप यहाँ परिवर्तन की जाँच कर सकते हैं । मुझे लगता है कि रेक्सटर पुराने संस्करण का उपयोग कर रहा है 3.4.3।

— गुरुपद ममदापुर

नीट, मैं इस बदलाव के बारे में नहीं जानता था। आपको भाषा को "Python 3.5" के रूप में चिह्नित करना चाहिए, हालांकि यह 3.4 या इससे पहले काम नहीं करता है। इसके अलावा, आप कोष्ठक को चारों ओर छोड़ सकते हैं l*kऔर print(r);r=[]अंतिम पंक्ति पर हो सकते हैं।

— जगरब

क्या आप सुनिश्चित हैं कि आपकी बाइट गिनती सही है? मुझे लगता है कि केवल 145 बाइट्स हैं।

— वल्लाह

1

मुझे 142 बाइट्स मिल रही हैं। क्या आप विंडोज का उपयोग कर रहे हैं? विंडोज आमतौर पर नई बाइट्स को 2 बाइट्स के रूप में गिनता है, लेकिन यहां प्रत्येक न्यूलाइन को सिंगल बाइट के रूप में गिना जाता है।

— मैथमैनंदन

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

स्टड से इनपुट को दो ट्यूपल के रूप में कॉमा द्वारा अलग किया जाता है, आउटपुट स्टडआउट के लिए सूचियों को उत्पन्न करता है। 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
स्रोत

आप एक त्रुटि को फेंक कर कार्यक्रम से बाहर निकल सकते हैं । तब आप लूप को एक लाइन में लाने में सक्षम हो सकते हैं।

— जगरब

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

[PHP], १ PHP३ १५२ १३५ बाइट्स

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;अभी भी प्रत्येक को 5 बाइट्स बचाता है। के $f<2बजाय के साथ एक और बचाओ $f!=2। और while($f=$f<3){...}इसके बजाय एक और दो के साथ while($f<2){$f=0;...}(आरंभ करता है $fऔर 1 तक रीसेट करता है जब तक कि यह दो बार वृद्धि न हो)

— टाइटस

@ टिट्स बहुत बहुत धन्यवाद, अब यह छोटा है।

— डेका

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

इसे ऑनलाइन आज़माएं!

( गोल्फ सुझाव का स्वागत करते हैं। मुझे लगता है कि संभवतः 10 से 15 बाइट्स हैं जो इससे बाहर निचोड़ा जा सकता है। )

@(...)कमांड लाइन तर्क के रूप में इनपुट को दो स्पष्ट सरणियों ( सिंटैक्स के साथ ) के रूप में लेता है। परिणामी सरणियों का हैशटेबल लौटाता है, क्योंकि PowerShell में बहुआयामी सरणियाँ अजीब हो सकती हैं, और यह अधिक सुसंगत है। कुछ प्रारंभिक चर सेट करता है, फिर एक do/ untilपाश में फिर से प्रवेश करता है , सशर्त तब तक $iहोता है जब तक कि सरणी मायने नहीं रखता ।

प्रत्येक लूप पुनरावृत्ति, हम संबंधित $aऔर $bमूल्यों को एक साथ ,(...)जोड़ते हैं, इसे $oउचित स्थान पर हैशटेबल में जोड़ने से पहले एक सरणी के रूप में मानते हैं $j। अंकगणित जोड़ को रोकने के लिए सरणी एनकैप्सुलेशन आवश्यक है - यह +=इसके बजाय सरणी समाकलन को अधिभार करने के लिए मजबूर करता है। फिर, एक सशर्त $xऔर $y(मायने रखता है) यह निर्धारित करने के लिए कि क्या हम एक सरणी किनारे पर हैं - यदि हां, तो हम वेतन वृद्धि करते हैं $j।

अंत में, हम $oपाइपलाइन पर छोड़ देते हैं और आउटपुट निहित है।
(NB: कैसे PowerShell डिफ़ॉल्ट रूप से हैशटैब की गणना करता है Write-Output, इस कारण आउटपुट "बैकवर्ड" हो जाता है, जैसा कि, "0 वां" परिणामी सरणी आउटपुट के "नीचे" पर है। हैश ही ठीक है, और होगा यदि आप उदाहरण के लिए ठीक उपयोग करते हैं, तो रिटर्न कोड में इस कोड को इनकैप्सुलेट किया जाता है ... यह मुद्रित होने पर बस अजीब लगता है।)

सहेजे गए 2 बाइट्स को $ x और $ y को ऐरे इंडेक्सिंग में अलग-अलग करने के बजाय (दो अर्धविरामों को बचाकर) ले जाएं।

— 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रों बजाय?

— जर्बर्ब डे

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

PPCG में आपका स्वागत है! डेनिस के विशिष्ट ट्वीक्स के अलावा, कुछ और सामान्य संकेत और ट्रिक प्राप्त करने के लिए पायथन में गोल्फ के लिए टिप्स देखें ।

— AdmBorkBork

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))))))))

खैर यह एक बहुत अधिक समझ में आता है। तत्व-वार राशि उत्पन्न करना, स्थिति संबंधी मेटाडेटा जोड़ना, जबकि हम अभी तक दोहराए नहीं गए हैं और प्रत्येक विभाजन पर योग मान डालते हैं।

(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

PHP, 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

जावास्क्रिप्ट (ईएस 6), 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और दूसरा सरणी अपने प्रारंभिक सरणी पर रीसेट हो जाता है
यदि दोनों सरणियाँ खाली हैं, तो अंतिम परिणाम जोड़कर दिए गए परिणाम को वापस कर दें।

अफसोस की बात यह है कि इस समाधान में @ अरनुल्ड की निर्मम दक्षता नहीं है, लेकिन कम से कम मुझे लगता है कि यह एक सुंदर समाधान है।

— नील
स्रोत

ऐरे अलाइनमेंट एडिशन

परिचय

काम

नियम और स्कोरिंग

परीक्षण के मामलों

जावास्क्रिप्ट (ईएस 6), 101 99 बाइट्स

यह काम किस प्रकार करता है

परीक्षण के मामलों

हास्केल, 84 79 बाइट्स

PHP, 126 120 बाइट्स

हास्केल, 87 84 बाइट्स

ऑक्टेव, 113 बाइट्स

सीजेएम , 30 बाइट्स

व्याख्या

जेली , 21 20 18 बाइट्स

यह काम किस प्रकार करता है

पायथन 3.5 - ( 146 137 134 130 + 12) = 142 बाइट्स

अजगर 2, 119 बाइट्स

जे , 34 32 बाइट्स

व्याख्या

हास्केल, 166 बाइट्स

[PHP], १ PHP३ १५२ १३५ बाइट्स

पॉवरशेल , 147 145 बाइट्स

पायथन 2, 113 बाइट्स

पायथन 3.5, 210 176 173 169 158 बाइट्स

रैकेट 373 बाइट्स

PHP, 150 121 119 बाइट्स

सी ++ 14, 206 बाइट्स

गणितज्ञ 112 बाइट्स

जावास्क्रिप्ट (ईएस 6), 131 बाइट्स