अपने साथ एक सरणी जोड़ें

22

आपकी चुनौती आज एक सरणी लेना है, इसे विखंडू में विभाजित करें और उन विखंडू को जोड़ें।

यहां बताया गया है कि यह कैसे काम करता है: आपके कार्यक्रम या फ़ंक्शन को एक पूर्णांक aऔर एक चंक आकार दिया जाएगा L। सरणी को आकार के सरणियों में विभाजित किया जाना चाहिए L, यदि सरणी की लंबाई विभाज्य नहीं है, Lतब तक सरणी को 0 से जोड़ा जाना चाहिए ताकि यह समान रूप से विभाज्य हो। एक बार सरणी को चैंकाने के बाद, सभी विखंडनों को तत्व-वार एक साथ जोड़ा जाना है। परिणामी सरणी तब आउटपुट है।

आप मान सकते हैं Lकि 0 से अधिक है, और aयह गैर-रिक्त है। आप यह अनुमान नहीं लगा सकते हैं कि aसामग्री सकारात्मक है।

यहाँ एक उदाहरण है:

[1,2,3,4,5,6,7,8], 3 => [1,2,3]+[4,5,6]+[7,8,0] =>  [1+4+7,2+5+8,3+6+0] => [12,15,9]

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

Array                           Length   Output
[1]                             1        [1]
[1]                             3        [1,0,0]
[0]                             3        [0,0,0]
[1,2]                           3        [1,2,0]
[1,2]                           1        [3]
[-1,1]                          2        [-1,1]
[-7,4,-12,1,5,-3,12,0,14,-2]    4        [12,-1,0,1]
[1,2,3,4,5,6,7,8,9]             3        [12,15,18]

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

code-golf  array-manipulation 
— पावेल
स्रोत
क्या यह एक धोखा नहीं है?
— सर्गियोल
1
@sergiol अगर आपको एक प्रश्न मिल सकता है कि यह एक डुप्लिकेट है, तो मैं स्वयं इस पोस्ट को हटा दूंगा। हालाँकि, जहाँ तक मैं बता सकता हूँ कि यह कोई धोखा नहीं है।
— पावेल १

जवाबों:

10

MATL , 4 बाइट्स

e!Xs

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

MATL कोड का पहला बिट मैंने लिखा है! aएक पंक्ति वेक्टर (अल्पविराम से अलग) और lएक संख्या के रूप में , दो इनपुट लेता है । होने के लिए काम करता है

e          # reshape `a` into `l` rows (auto pads with 0)
 !         # transpose
  Xs       # sum down the columns
— ग्यूसेप
स्रोत
5

जावा 7, 86 बाइट्स

कोई फैंसी सिलवट या मैट्रिस नहीं, बस एक अच्छा राजभाषा 'फैशन forलूप :)

int[]o(int[]a,int l){int i=0,o[]=new int[l];for(;i<a.length;)o[i%l]+=a[i++];return o;}

Ideone पर इसे आज़माएं

लाइन:

int[]o(int[]a,int l){
    int i=0,
        o[]=new int[l];
    for(;i<a.length;)
        o[i%l]+=a[i++];
    return o;
}
— Geobits
स्रोत
2
और अच्छे राजभाषा के साथ जावा 7 (8 के बजाय) का फैशन। ;)
— केविन क्रूज़सेन
5

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

a=>n=>a.map((v,i)=>o[i%n]+=v,o=Array(n).fill(0))&&o

करी सिंटैक्स में इनपुट लेता है f([1,2])(3):।

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

कोड स्निपेट दिखाएं

— जस्टिन मेरिनर
स्रोत
(a,n,o=[])=>a.map((v,i)=>o[i%n]=~~o[i%n]+v)&&o
— ओकी
1
@ ओकी दो बाइट्स छोटे:, a=>n=>a.map((v,i)=>o[i%=n]=~~o[i]+v,o=[])&&oलेकिन यह आवश्यक शून्य-गद्दी को नहीं जोड़ता है।
— जस्टिन मैरिनर
f=अपने चरित्र की गिनती का हिस्सा होना चाहिए।
— लक्स-एक्स
1
@ nl-x बेनामी कार्यों को डिफ़ॉल्ट रूप से अनुमति दी जाती है, इसलिए जब तक मैं अपने कोड में फ़ंक्शन नाम का उपयोग नहीं कर रहा हूं, तब तक f=इसकी आवश्यकता नहीं है। इसके बारे में मेटा पर एक पोस्ट Heres ।
— जस्टिन मेरिनर
1
@ nl-x: नहीं, ऐसा नहीं होना चाहिए; एक फ़ंक्शन को केवल तभी नाम दिया जाना चाहिए जब वह पुनरावर्ती (या, शायद, एक क्वीन) हो। यदि यह नहीं है तो एक अनाम फ़ंक्शन पूरी तरह से मान्य है। देखें यहाँ ।
— झबरा
5

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

मैथेमेटिका में इसके लिए लगभग एक बेसिन था

Total@Partition[##,#2,1,0]&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

प्रयोग

Total@Partition[##,#2,1,0]&[{-7, 4, -12, 1, 5, -3, 12, 0, 14, -2}, 4]

{12, -1, 0, 1}

व्याख्या

Total@Partition[##,#2,1,0]&

      Partition[##,#2,1,0]   (* Partition the first input into sublists of length
                                second input, using offset second input, and
                                right-pad zeroes for incomplete partitions *)
Total@                       (* Add all *)
— जंगहवान मिन
स्रोत
आपका लिंक काम नहीं कर रहा है।
— शैगी
1
@ आपको कोड को मैन्युअल रूप से कॉपी और पेस्ट करना होगा। वोल्फ्राम सैंडबॉक्स पहले से भरे इनपुट का समर्थन नहीं करता है।
— जंगहवान मिन सिप
4

मैथेमेटिका, 58 बाइट्स

Total@Partition[PadRight[#,(s=Length@#)+Mod[-s,#2]],{#2}]&

इनपुट

[{1}, 3]

उत्पादन

{1,0,0}

— J42161217
स्रोत
के लिए यह काम करता है [1], 3 आप इसे यहाँ परीक्षण कर सकते हैं sandbox.open.wolframcloud.com कोड के अंत में इनपुट जोड़ने और shift + दबाकर दर्ज
— J42161217
4

पर्ल 6 , 36 बाइट्स

{[Z+] flat(@^a,0 xx$^b*2).rotor($b)}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with 2 placeholder parameters ｢@a｣, ｢$b｣
  [Z+]
    flat(
      @^a,         # declare and use the first parameter
      0 xx $^b * 2 # 0 list repeated 2 * the second parameter
    )
    .rotor($b)     # split into chunks that are the size of the second param
}
[1,2], 3

( [1,2], (0,0,0,0,0,0) ) # @^a,0 xx$^b*2
(1,2,0,0,0,0,0,0)        # flat(…)
( (1,2,0), (0,0,0) )     # .rotor($b) # (drops partial lists)
(1,2,0)                  # [Z+]
— ब्रैड गिल्बर्ट b2gills
स्रोत
3

एपीएल (डायलॉग) , 22 बाइट्स

lबाएं तर्क और aएक सही तर्क के रूप में लेता है।

{+⌿s⍴⍵↑⍨×/s←⍺,⍨⌈⍺÷⍨≢⍵}

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

{… } अनाम फ़ंक्शन जहां ⍺बाएं तर्क ( l) और ⍵सही तर्क ( a) है।

 ≢⍵ की टैली (लंबाई) a

 ⍺÷⍨ से विभाजित l

 ⌈ छत (राउंड अप)

 ⍺,⍨ संलग्न l

 s← में दुकान s(के लिए रों hape)

 ×/ उस का उत्पाद (अर्थात कितने पूर्णांक आवश्यक हैं)

 ⍵↑⍨ उस से कई पूर्णांक लें a(शून्य के साथ पैडिंग)

 s⍴ r आकृति को आकार देना s(पंक्तियों, स्तंभों)

 +⌿ स्तंभों को गाया जाता है

— एडम
स्रोत
3

पर्ल 6 , 40 बाइट्स

{[Z+] (|@^a,|(0 xx*)).rotor($^l)[0..@a]}

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

यदि आपको संख्या 42 पसंद है, तो आप a के *लिए स्वैप कर सकते हैं ∞। यह 42 बाइट्स बना देगा:

स्पष्टीकरण :

{[Z+] (|@^a,|(0 xx*)).rotor($^l)[0..@a]} The whole function
{                                      } Anonymous block
      (    ,        )                    List with 2 elements
        @^a                              The first argument (it is a list)
             (0 xx*)                     Infinite list of zeroes
       |    |                            Flatten both of the lists into the larger list.
                    .rotor($^l)          Split the list into a list of lists, each (the second argument) long.
                               [0..@a]   Only the first (1 + length of the first argument) of them.
 [Z+]                                    Add the corresponding elements up.

अंतिम "ऐड अप" के पीछे का जादू यह है कि ऑपरेटर "ज़िप के साथ कम करें +" है। वैसे, यह टूट जाएगा अगर हमने इसे केवल एक सूची के साथ एक सूची में उपयोग किया, लेकिन ऐसा कभी नहीं होता है यदि मूल सूची गैर-रिक्त थी (दूसरी-से-अंतिम पंक्ति के कारण)। यह भी ध्यान रखें कि हम केवल नहीं ले रही है अंत @aहै, लेकिन @a * $lआइटम नहीं है। सौभाग्य से हमने केवल शून्य जोड़े जो अंतिम परिणाम को प्रभावित नहीं करेंगे।

— Ramillies
स्रोत
3

पायथ , 8 बाइट्स

m+F%Q>vz

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

अजगर , 10 बाइट्स

sMCc.[EZQQ

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

व्याख्या

स्पष्टीकरण # 1

m+F%Q>vz   Full program. Q means input.

m          Map over the implicit range [0, input_1), with a variable d.
     >vz  All the elements of input_2 after d; input_2[d:] in Python.
   %Q     Every Qth element of ^.
 +F       Sum. Implicitly output the result.

व्याख्या # २

sMCc। [EZQQ पूर्ण कार्यक्रम

    [ई सही बार की प्रतियां के साथ, सही करने के लिए दूसरा इनपुट पैड ...
       Z ... शून्य (0), के सबसे पास के कई ...
        क्यू ... पहला इनपुट।
   पहले इनपुट के बराबर लंबाई के विखंडू में सी क्यू चोप।
  C मैट्रिक्स का स्थानांतरण। नेस्टेड सूची के सभी कॉलम प्राप्त करें।
sM प्रत्येक।
             आउटपुट (संक्षेप में)।
— श्री Xcoder
स्रोत
इस तरह से कुछ के बारे में कैसे:sM.TcEQ
— Jakube
@Jakube गलत है, क्योंकि आपको पहले शून्य के साथ पैड करना है। यह लीकी का प्रारंभिक प्रयास था, लेकिन इसके लिए असफल होगा [1], 3, जो [1]इसके बदले देगा [1, 0, 0]।
— मिस्टर एक्सकोडर
माफ कीजिएगा यह मेरी गलती है।
— जकाबे
3

जे , 15 12 बाइट्स

]{.+/@(]\~-)

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

व्याख्या

]{.+/@(]\~-)  Input: array A (LHS), chunk size L (RHS)
          -   Negate L
       ]\~    Take each non-overlapping sublist of size L in A
   +/@        Reduce the columns by addition
]             Get L
 {.           Take that many, filling with 0's
— मील की दूरी पर
स्रोत
किसी भी कारण से हम बक्से के साथ दूर नहीं कर सकते हैं? के बारे में क्या [:+/-@[[\]:?
— जोनाह
@ जोनाह यदि चंक का आकार इनपुट सरणी की लंबाई से बड़ा है, तो यह शून्य-गद्देदार नहीं होगा।
— मील
अच्छा संपादन - अब बहुत क्लीनर।
— जोनाह
3

05AB1E , 8 बाइट्स

ô0ζO²Å0+

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

ô0ζO²Å0+   Full program
ô          Push <1st input> split into a list of <2nd input> pieces
 0ζ        Zip sublists with 0 as a filler
   O       Sum each sublist
           --- from here, the program handles outputs shorter 
               than the required length
    ²Å0    Push a list of zeros of length <2nd input>
       +   Sum the result with that list
— scottinet
स्रोत
3

05AB1E , 8 बाइट्स

Å0+¹ô0ζO

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

Å0       # Push an arrary of all 0s with length l
  +      # Add that to the array
   ¹ô    # Split into chunks of length l
     0ζ  # Zip, padding with 0s
       O # Sum each chunk
— रिले
स्रोत
लगभग मेरे अपने समाधान के समान: codegolf.stackexchange.com/a/143186/73296
— scottinet
@scottinet मुझे वह याद आ गया होगा। वे काफी अलग हैं कि मैं अपना छोड़ दूंगा और तुम्हारा उत्थान करूंगा :)
— रिले
मैं वास्तव में बुरा नहीं मानता, बस यही कहना चाहता था :)
— स्कूटनीट
@scottinet यह दिलचस्प है कि आप संचालन को पुनर्व्यवस्थित कर सकते हैं और एक ही बाइट की गिनती के साथ बाहर आ सकते हैं और लगभग समान बाइट्स का उपयोग किया जाता है ( ¹बनाम ²)
— रिले
2

SOGL V0.12 , 14 बाइट्स

l⁵%⁵κ{0+}nI⌡∑¹

यह कोशिश करो! या सभी परीक्षण मामलों की कोशिश करो। यह एक अनाम फ़ंक्शन के रूप में लिखा chunk length; arrayगया है और स्टैक पर अपेक्षा करता है।

स्पष्टीकरण:

padding zeroes
l          get the array's length
 ⁵%        modulo the chunk length
   ⁵κ      chunk length - result of above
     {  }  that many times
      0+     append a 0 to the array

adding the array together
n      split into the chunks
 I     rotate clockwise
  ⌡    for each
   ∑     sum
    ¹  wrap the results in an array
— dzaima
स्रोत
इसमें क्या है इसके Fलिए प्रयास करें यहां पर आपने जो कोड लिंक किया है?
— पावेल १
@ फंक्शंस का नाम। जेएस f=a=>a+2के समान ही f=भाग की गणना नहीं की गई है - एसओजीएल F\nमें गणना नहीं की गई है।
— दिजिमा
2

05AB1E , 12 बाइट्स

gs÷*+Å0¹+ôøO

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

व्याख्या

gs÷*+Å0¹+ôøO
g            # Get the length of the first input (the array)
 s           # Push the second input on top of the result
  ÷          # integer divide the two values
   *         # Multiply with the second input (the length)...
    +        # and add the second input to the result
     Å0      # Create a list of zeros with that length
       ¹+    # Add it to the first input
         ô   # And finally split it into chunks of the input length...
          ø  # ...transpose it...
           O # and sum each resulting subarray
             # Implicit print
— Datboi
स्रोत
2

आर , 62 57 बाइट्स

-523 बाइट उपयोगकर्ता 2390246 के लिए धन्यवाद

function(a,l)rowSums(matrix(c(a,rep(0,l-sum(a|1)%%l)),l))

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

अपडेट किया गया क्योंकि अब इसे खाली मामले को संभालना नहीं है।

aशून्य के साथ पैड , lपंक्तियों के एक मैट्रिक्स का निर्माण करता है, और पंक्ति रकम को गणना और वापस करता है।

— ग्यूसेप
स्रोत
— user2390246
@ user2390246 बेशक! मेरे पास एक पुराने संस्करण में था जब हमें खाली मामले को संभालना था लेकिन यह मेरा "प्राथमिक" था और मैंने फिर से कोशिश करने के लिए नहीं सोचा।
— ग्यूसेप
2

जाप , 7 बाइट्स

यार, मैं बहुत देर तक गलत जप विधि से लड़ता रहा और [1], 3परीक्षण के मामले के लिए उचित मात्रा में बाइट्स में काम करने की कोशिश करता रहा !

VÆëVX x

कोशिश करो

व्याख्या

सरणी Uऔर पूर्णांक का निहित इनपुट V।

VÆ

से पूर्णांकों की एक सरणी उत्पन्न 0करने के लिए V-1और के साथ एक समारोह के माध्यम से प्रत्येक पारित Xवर्तमान तत्व जा रहा है।

ëVX

सूचकांक में शुरुआत के प्रत्येक Vतत्व को पकड़ो ।UX

x

इसके अलावा उस एरे को कम करें।

— झबरा
स्रोत
2

सी, (जीसीसी) 101 86 बाइट्स

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

f(int*a,int l,int s,int*m){if(s){int i=l;while(i&&s){m[l-i--]+=*a++;s--;}f(a,l,s,m);}}

प्रयोग

int main() {
   int l = 3;
   int a[8] = {1,2,3,4,5,6,7,8};
   int *m = (int *)malloc(sizeof(int) * l);
   f(a, l, 8, m);
   for (int i=0; i<3; i++) {
    printf("%d, ",m[i]);
   }
}

ध्यान दें कि आपको सरणी (ओं) की लंबाई और ढेर (एम) पर एक नया गतिशील सरणी पास करना होगा।

— Asleepace
स्रोत
— जोनाथन फ्रेच
1

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

param($a,$l)1..$l|%{$y=--$_;($o=0)..$l|%{$o+=$a[$y+$_*$l]};$o}

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

हम इनपुट $aरीरे और एन्थ लेते हैं $l। से फिर पाश 1करने के लिए $l। प्रत्येक पुनरावृत्ति को हम सहायक $yको वर्तमान संख्या से कम होने के लिए सेट करते हैं (इसका कारण है पॉवरशेल 0-इंडेक्स लेकिन $lएंथ 1-इंडेक्सिंग में है)। फिर हम अपना $output 0फिर से ऊपर और पाश पर सेट करते हैं $l। प्रत्येक आंतरिक पुनरावृत्ति हम बस $oउचित रूप से अनुक्रमित $array तत्व में जमा हो रहे हैं । यह इस तथ्य का लाभ उठाता है कि सरणी रिटर्न के अंत में अनुक्रमण करता है $nullऔर 0 + $null = 0।

एक बार आंतरिक लूप हो जाने के बाद, हम आउटपुट करते हैं $oऔर अगले चंक पर जाते हैं। विभिन्न आउटपुट को पाइपलाइन पर छोड़ दिया जाता है और आउटपुट के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने पर होता है।

— AdmBorkBork
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.