स्तम्भ-वार सुम

Question

संख्या की गैर-रिक्त पंक्तियों की एक गैर-रिक्त सूची को देखते हुए, कॉलम वार राशि की गणना करें , जो एक अन्य सूची है जिसमें सबसे लंबी इनपुट पंक्ति की लंबाई है। आउटपुट सूची की पहली प्रविष्टि इनपुट पंक्तियों के सभी पहले एंट्रेस का योग है, दूसरा एक सभी दूसरे तत्वों का योग है (यदि उपलब्ध है) आदि मुझे लगता है कि निम्नलिखित उदाहरण इसे बेहतर तरीके से समझाएंगे:

Input:      {[1,2,3,4],[1],[5,2,3],[6,1]}
Computation: [1,2,3,4]
              + . . .
             [1]. . .
              + + + .
             [5,2,3].
              + + . .
             [6,1]. .
              = = = =
    Output: [13,5,6,4]

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

{[0]}                         -> 0
{[1],[1,1,1,1]}               -> [2,1,1,1]
{[1],[1,2],[1,2,3],[1,2,3,4]} -> [4,6,6,4]
{[1,6,2,-6],[-1,2,3,5]}       -> [0,8,5,-1]

Comments

क्या सरणियों में केवल पूर्णांक होंगे?

— ETHproductions

मैंने अभी तक इसके बारे में नहीं सोचा था लेकिन मुझे लगता है कि आप ऐसा मान सकते हैं। क्या उसके खिलाफ कुछ बोल रहा है?

— दोष

मुझे ऐसा नहीं लगता। आपके सभी परीक्षण मामले केवल पूर्णांक का उपयोग करते हैं, और मुझे पूरा यकीन है कि यह किसी भी मौजूदा उत्तर को अमान्य नहीं करेगा (और कुछ उत्तरों के लिए बाइट्स भी बचा सकता है)।

— ETHproductions

वैसे मुझे लगता है कि यह धारणा पूरी तरह से स्वीकार्य है। यह चुनौती को भी नहीं बदलता है।

— मल्हार

Answer 1

जेली , 1 बाइट

S

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

योग परमाणु Sएक शॉर्टहैंड है +/, जो इसके अलावा कमी करता है।

त्वरित /बाहरी आयाम के साथ कम हो जाता है, इसलिए यह इनपुट के तत्वों के लिए अपने लिंक को कॉल करता है। यहाँ, तत्व पंक्तियाँ हैं।

इसके अलावा परमाणु +सदिश करता है, इसलिए दो पंक्ति वैक्टर जोड़ने से तत्व-दर-तत्व जोड़ होता है। जब तर्कों की लंबाई अलग-अलग होती है, तो लंबे तर्क वाले तत्वों के छोटे में कोई प्रतिपक्ष नहीं होता है।

सभी सभी, तर्क के रूप में एक अनियमित मैट्रिक्स के साथ, Sकॉलम-वार राशि की गणना करते हैं, छोटी पंक्तियों में लापता प्रविष्टियों को छोड़ देते हैं।

Comments

हुह, मुझे उम्मीद है कि रोली-वार राशि होने के लिए, जिस तरह से ऑटोवेरिसिएशन सामान्य रूप से जेली में काम करता है। मैं इसे पंक्ति-वार राशि लेता हूँ S€, तब?

एक 2D सरणी के लिए, हाँ। /वेक्टर नहीं करता है; यह बस अपने तर्क के सभी तत्वों के लिए संगत राग लागू करता है।

— डेनिस

Answer 2

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

lambda x:map(lambda*y:sum(filter(None,y)),*x)

2 बाइट बंद करने के लिए @vaultah को धन्यवाद!

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

Answer 3

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

{roundrobin(|$_)».sum}

Answer 4

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

Total@*PadRight

Answer 5

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

import Data.List
map sum.transpose

इसे ऑनलाइन आज़माएं! उपयोग:

Prelude Data.List> map sum.transpose $ [[1,2,3,4],[1],[5,2,3],[6,1]]
[13,5,6,4]

Comments

पुस्तकालयों को जानने के लिए अच्छा है, मैं हमेशा डरता हूं importक्योंकि यह पहले से ही बहुत सारे बाइट्स खाता है: डी

— दोष

Answer 6

सीजाम , 7 5 बाइट्स

डेनिस के लिए धन्यवाद 2 बाइट्स!

{:.+}

ऐसा अनाम ब्लॉक है कि इस तरह के रूप में सूची, की एक सूची लेता है परिभाषित करता है [[1 2 3 4] [1] [5 2 3] [6 1]], एक सूची से, और यह जगह [13 5 6 4]।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

{   }   e# Define block
 :      e# Fold over the following dyadic function
  .+    e# Vectorized addition

Answer 7

MATL , 3 बाइट्स

oXs

( MATL नहीं जानता कि "बैल" का बहुवचन "बैलों" है ... )

इनपुट न्यूमेरिकल रो वैक्टर का एक सेल ऐरे है, उसी फॉर्मेट में जैसे चैलेंज टेक्स्ट में:

{[1,2,3,4],[1],[5,2,3],[6,1]}

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

     % Implicit input
o    % Convert cell array to a matrix, right-padding with zeros each row
Xs   % Sum of each column
     % Implicit display

Comments

कोशिकाओं का उपयोग करने के लिए बहुत ही चतुर =)

— दोष

Answer 8

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

सहेजे गए 3 बाइट्स, ETHproductions के लिए धन्यवाद

a=>a.map(b=>b.map((v,i)=>r[i]=~~r[i]+v),r=[])&&r

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

let f =

a=>a.map(b=>b.map((v,i)=>r[i]=~~r[i]+v),r=[])&&r

console.log(f([[1,2,3,4],[1],[5,2,3],[6,1]])); // -> [13,5,6,4]
console.log(f([[0]]));                         // -> [0]
console.log(f([[1],[1,1,1,1]]));               // -> [2,1,1,1]
console.log(f([[1],[1,2],[1,2,3],[1,2,3,4]])); // -> [4,6,6,4]
console.log(f([[1,6,2,-6],[-1,2,3,5]]));       // -> [0,8,5,-1]

Comments

इसमें क्या गलत था reduce? a=>a.reduce((l,r)=>r.map((e,i)=>e+(l[i]||0)))केवल 45 बाइट्स है।

— नील

@ नील अंतिम संसाधित सरणी के आकार के अंतिम परिणाम के आकार को सीमित नहीं करेगा?

— अरनौलड

आह, परीक्षण के मामले मेरी त्रुटि को पकड़ने में विफल रहे, धन्यवाद!

— नील

Answer 9

आश्चर्य है , 11 बाइट्स

@->#sum '#0

स्थानांतरण और मानचित्र के साथ राशि समारोह। उपयोग:

(@->#sum '#0)[[1 2 3 4];[1];[5 2 3];[6 1]]

Answer 10

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

अनाम जेनेरिक लंबा के रूप में:

[](auto C,auto&r){r.clear();int i=0,b=1;while(b--){r.push_back(0);for(auto c:C)r.back()+=i<c.size()?c[b=1,i]:0;++i;}r.pop_back();}

आवश्यक है Cकी तरह बनना vector<vector<int>>और वापसी मान rकी तरह बनना vector<int>(के अनुसार ठीक होना चाहिए मेटा )।

असंगठित और उपयोग:

#include<vector>
#include<iostream>

auto f=
[](auto C, auto&r){
 r.clear();         //clearing r just to be sure
 int i=0,b=1;       //i is the position in the row, b is a boolean
 while(b--){        //while something was added
  r.push_back(0);   //add zero
  for(auto c:C)     //for each container
   r.back() += i<c.size() ?   //add to the last element 
    c[b=1,i] : 0;             //set b and get the element or zero 
  ++i;              
 }
 r.pop_back();      //remove last unnecessary zero
}
;

using namespace std;

int main(){
 vector<vector<int> > C = { {1,2,3,4}, {1}, {5,2,3}, {6,1} };
 vector<int> r; 
 f(C,r);
 for (int i: r)
  cout << i << ", ";
 cout << endl;
}

Answer 11

पायथ - 4 बाइट्स

sM.T

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 12

हास्केल, 61 41 40 बाइट्स

धन्यवाद @Likoni -20 बाइट्स के लिए, @nimi -1 बाइट के लिए!

f[]=[]
f l=sum[h|h:_<-l]:f[t:u|_:t:u<-l]

स्पष्टीकरण: यह सूची के पहले तत्वों का सिर्फ एक पुनरावर्ती योग है, हर मध्यवर्ती चरण में खाली सूचियों को छोड़ने से निपटने के लिए:

    sum[h|h:_<-l]                    -- sums up all the first elemetns of the list
                    [t:u|_:t:u<-l]   -- removes the first element of all the list, and removes empty lists
                   f                 -- applies f to the remaining list
                 :                   -- prepends the sum to the rest

Comments

सूची बोध का उपयोग करना कुछ बाइट्स बचाता है: आप के (sum$sum.(take 1)<$>l)साथ sum[h|h:_<-l]और (f$filter(/=[])$drop 1<$>l)साथ बदल सकते हैं f[t|_:t<-l,t>[]]।

— लैकोनी

वाह बहुत-बहुत धन्यवाद! मैं पैटर्न मिलान की संभावना के बारे में भूलता रहता हूँ [h|h:_<-l]!

— दोष

पुनरावर्ती कॉल में एक बाइट को बचाया जा सकता है f[t:u|_:t:u<-l]:।

— नीमी

Answer 13

जे, 5 बाइट्स

+/@:>

इनपुट को सूचियों की बॉक्सिंग सूची के रूप में लेता है।

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

   1 ; 1 1 1 1
+-+-------+
|1|1 1 1 1|
+-+-------+
   (+/@:>) 1 ; 1 1 1 1
2 1 1 1
   1 ; 1 2 ; 1 2 3 ; 1 2 3 4
+-+---+-----+-------+
|1|1 2|1 2 3|1 2 3 4|
+-+---+-----+-------+
   (+/@:>) 1 ; 1 2 ; 1 2 3 ; 1 2 3 4
4 6 6 4

Answer 14

Dyalog एपीएल , 3 बाइट्स

+⌿↑

+⌿ योग स्तंभ-वार

↑ मिश्रित (सूची की सूची, मैट्रिक्स में खड़ी, शून्य के साथ पैडिंग) तर्क

TryAPL ऑनलाइन!

Comments

पृथ्वी पर यह 10 बाइट्स कैसे होती है?

— जकार्इ

@ZacharyT 12:30 AM पर टेम्पलेट का उपयोग करते समय यही होता है।

— प्रवेश

Answer 15

Pyke, 4 बाइट्स

.,ms

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

Answer 16

जावा 8, 124 बाइट्स

यह एक लंबोदर अभिव्यक्ति है Function< int[ ][ ], int[ ] >

i->{int L=0,t,r[];for(int[]a:i)L=(t=a.length)>L?t:L;r=new int[L];for(;0>L--;)for(int[]a:i)r[L]+=a.length>L?a[L]:0;return r;}

यह इनपुट से सबसे बड़ी सरणी लंबाई लेता है, उस आकार का एक नया सरणी बनाता है, और फिर प्रत्येक कॉलम के एम्स को सरणी में लिखता है।

Answer 17

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

@(a){g=1:max(s=cellfun(@numel,a))<=s';f=g'+0;f(g')=[a{:}];sum(f')}{4}

Answer 18

आर, 105 97 बाइट्स

a=c();l=length;for(i in 1:l(w)){length(w[[i]])=max(sapply(w,l));a=rbind(a,w[[i]])};colSums(a,n=T)

यह इनपुट के रूप में किसी listवस्तु को ले जाता wहै:

w=list(c(1,2,3,4),c(1),c(1,2))

यह कॉलम-वार राशि का उत्पादन करता है: [1] 3 4 3 4

यह समाधान मेरे लिए काफी लंबा है। आर जब आप अलग अलग लंबाई के बाँध वैक्टर करने की कोशिश करने के लिए रीसायकल ख़ासियत है। उदाहरण के लिए :

a=c(1,2,3,4)
b=c(1,2)

cbind(a,b)

     a b
[1,] 1 1
[2,] 2 2
[3,] 3 1
[4,] 4 2

b एक बार फिर से फिट होने के लिए उपयोग किया जाता है, यही कारण है कि मैं एक सूची के साथ शुरू करता हूं।

कार्यक्रम सूची के सभी तत्वों की लंबाई को सबसे लंबे समय तक समायोजित करता है, तत्वों को बांधता है और कॉलम-वार योग की गणना करता है। लंबाई समायोजित करने से उत्पादन होता है NA, जिसे अनदेखा कर दिया जाता है sum।

-8 बाइट्स @Jarko डबेलडैम को धन्यवाद!

Comments

colSums(a,na.rm=T)कुछ बाइट्स बचाता है।

— JAD

और तुम भी बदल सकते हैं na.rm=Tमें n=T।

— JAD

Answer 19

PHP, 63 बाइट्स

<?foreach($_GETas$a)foreach($a as$i=>$x)$r[$i]+=$x;print_r($r);

इनपुट की सूची के रूप में GET मापदंडों के साथ ब्राउज़र में कॉल करें।

उदाहरण:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(ऐरे नामों की उपेक्षा की जाती है, इसलिए आप उन्हें किसी भी तरह से नाम दे सकते हैं जो आप चाहते हैं।)

परीक्षण के लिए इस फ़ंक्शन का प्रयास करें:

function s($a){foreach($a as$b)foreach($b as$i=>$x)$r[$i]+=$x;return$r;}

या http_build_query($array,a)दिए गए सरणी को GET मापदंडों में बदलने के लिए उपयोग करें।

Answer 20

क्लोजर, 70 बाइट्स

#(for[i(range(apply max(map count %)))](apply +(for[v %](get v i 0))))

एक मूल नेस्टेड लूप।

Answer 21

जाप, 5 बाइट्स

Uz mx

इसे ऑनलाइन टेस्ट करें!

Uइनपुट सरणी है, और zसरणियों पर सरणी को 90 डिग्री से दक्षिणावर्त घुमाता है। इसलिए,

[
 [1,2,3,4],
 [1      ],
 [5,2,3  ],
 [6,1    ]
]

हो जाता है

[
 [6,5,1,1],
 [1,2,  2],
 [  3,  3],
 [      4]
]

(रिक्ति केवल प्रदर्शन उद्देश्यों के लिए जोड़ी गई है।)

mxतब mयोग द्वारा एप्स ( x), जो वांछित परिणाम देता है [13,5,6,4]:।