विकर्ण योग

Question

इनपुट के रूप में धनात्मक पूर्णांक का एक मैट्रिक्स लें, और मैट्रिक्स के माध्यम से विकर्ण रेखाओं पर तत्वों के व्यक्तिगत योग का उत्पादन करें।

आप केवल उन रेखाओं को गिनेंगे जो तिरछे नीचे और दाईं ओर जाती हैं। आपको उस विकर्ण से शुरू करना चाहिए जिसमें केवल नीचे-बाएँ तत्व होता है, फिर उसके ऊपर की लंबाई-दो विकर्ण (यदि यह मौजूद है) और इसलिए विकर्ण के माध्यम से जिसमें केवल शीर्ष-सही तत्व होता है, जैसा कि नीचे सचित्र है।

उदाहरण:

Input:
 8   14    5    1
10    5    5    8
 6    6    8   10
15   15    4   11

Output:
15, 21, 20, 32, 29, 13, 1
(Diagonals: {{15},{6,15},{10,6,4},{8,5,8,11},{14,5,10},{5,8},{1}})

Input:
1
Output:
1

Input: 
1 5
Output:
1, 5

Input:
4
1

Output: 
1, 4

Input:
17    4    5
24   16    5
 9   24   10
 1   14   22
 1   21   24
 4    4   17
24   25   17

Output:
24, 29, 22, 39, 47, 70, 43, 9, 5

इनपुट और आउटपुट प्रारूप हमेशा की तरह वैकल्पिक हैं।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम सबमिशन जीतता है।

Comments

सम्बंधित

— nimi

Answer 1

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

z=0:z
foldl1$(.(++z)).zipWith(+).(0:)

इसे ऑनलाइन आज़माएं! उपयोग: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]]।

संपादित करें: -3 बाइट्स के लिए अर्जन जोहान्सन को धन्यवाद!

Ungolfed:

z = 0:z
s#t = zipWith(+)(0:s)(t++z)
f m = foldl1 (#) m

zअसीम रूप से कई शून्य की एक सूची है। में fहम सूचियों की सूची से अधिक गुना mसमारोह के साथ दो सूचियों को संयोजित करके #। में #पहली सूची sअब तक संचित स्तंभ रकम शामिल है और दूसरी सूची tनई पंक्ति जो जोड़ा जाना चाहिए है। हम बदलाव sसामने और तत्व के लिहाज से जोड़ने के लिए एक शून्य जोड़कर सही करने के लिए एक तत्व sऔर tसाथ zipWith(+)। क्योंकि sमनमाने ढंग से बड़ा हो सकता है, हमें tजोड़कर पर्याप्त शून्य के साथ पैड करना होगा z।

Comments

यही कारण है कि छोटे कद के बिंदु से मुक्त है: foldl1$(.(++z)).zipWith(+).(0:)।

— अर्जन जोहान्सन

Answer 2

गणितज्ञ, ५३ ५४ बाइट्स

l=Length@#-1&;Tr@Diagonal[#,k]~Table~{k,-l@#,l@#&@@#}&

शुद्ध फ़ंक्शन इनपुट के रूप में एक 2D सरणी ले रहा है और एक सूची लौटा रहा है। (प्रविष्टियाँ पूर्णांक या सम संख्याएँ नहीं होती हैं।) मुख्य विकर्ण के ऊपर वें विकर्ण (या नीचे, यदि नकारात्मक है) को Diagonal[#,k]लौटाता है । इनपुट सरणी के आयामों के आधार पर आवश्यक विकर्णों की सीमा की गणना करता है। और प्रत्येक विकर्ण की प्रविष्टियाँ दर्ज करता है।kk{k,-l@#,l@#&@@#}Tr

Comments

एक ही बाइट काउंट पर वैकल्पिक, लेकिन शायद आप इसे और आगे बढ़ा सकते हैं? वे कोष्ठक बुरे लगते हैं। Tr@Diagonal[m,#]&/@Range@@({-1,1}(Dimensions[m=#]-1))&

— मार्टिन एंडर

Answer 3

MATL , 6 बाइट्स

T&XdXs

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

व्याख्या

T&Xd   % All diagonals of implicit input arranged as zero-padded columns
Xs     % Sum of each column. Implicitly display

Comments

बस जिज्ञासु: क्या आपको लगता s==sum(x(:))है कि MATLAB सम्मेलन से चिपके रहने के बजाय समग्र रूप से बेहतर होगा , जैसा कि MATL लगता है?

— स्टीवी ग्रिफिन

@StewieGriffin मैंने कभी-कभी उस बारे में सोचा है। मेरा शक sum(x)और ज्यादा था sum(x,1)। एक मैट्रिक्स के लिए x, तथ्य यह है कि sum(x)यदि मैट्रिक्स में 1 पंक्ति है, तो कभी-कभी अलग-अलग व्यवहार होता है। लेकिन अंत में मैंने मतलब के साथ जाने का फैसला किया, इसलिए दोनों भाषाएँ करीब हैं; और fun(x,1)सबसे आम मामलों के लिए कुछ कार्य जोड़ें

— लुइस मेंडो

Answer 4

जेली , 5 बाइट्स

0;+µ/

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

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

0;+µ/  Main link. Argument: M (matrix / array of rows)

   µ   Combine all links to the left into a chain (arity unknown at parse time) and
       begin a new monadic chain.
    /  Reduce M by that chain. This makes the chain dyadic.
       Let's call the arguments of the chain L and R (both flat arrays).
0;         Prepend a 0 to L.
  +        Perform element-wise addition of the result and R.
           When the chain is called for the n-th time, R has n less elements, so
           the last n elements of L won't have matching elements in R and will be
           left unaltered.

Comments

केवल पहला आर कम करने के लिए एक कम तत्व है; यह प्रत्येक पंक्ति में एक और तत्व से बढ़ता है।

— अर्जन जोहान्सन

यह सिर्फ चालाक है ... नहीं ŒD?

— एरिक द आउटलिफ़र

@EriktheOutgolfer एक बार फिर, ŒDअजीब आदेश ने इसे उपयोगी होने से रोक दिया।

— डेनिस

@Dennis तो मुझे लगता है कि मैं कुछ है कि बहुत अजीब आदेश नहीं है बनाने चाहते हैं ... ओह, शायद 3 monads सकता भेजे हो।

— एरिक आउटगॉल्फ

Answer 5

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

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

Comments

63-बाइट प्रकार:a=>a.map(r=>r.map(v=>s[i]=~~s[i++]+v,i=--y),s=[],y=a.length)&&s

— अरनौल

@Arnauld मैं सहमत हूं, उलटफेर एक बुरा कदम था। लेकिन लंबाई लेना बहुत लंबा है!

— नील

Answer 6

CJam , 22 21 बाइट्स

मार्टिन एंडर को 1 बाइट धन्यवाद दिया

{_,({0\f+}*ee::m<:.+}

बेनामी ब्लॉक स्टैक पर तर्क की अपेक्षा करता है और स्टैक पर परिणाम छोड़ता है।

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

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

_                   e# Duplicate the matrix
 ,(                 e# Get its length (# of rows) minus 1
   {0\f+}*          e# Prepend that many 0s to each row
          ee        e# Enumerate; map each row to [index, row]
            ::m<    e# Rotate each row left a number of spaces equal to its index
                :.+ e# Sum each column

Answer 7

05AB1E , 17 बाइट्स

Rvy¹gÅ0«NFÁ}})øO¨

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

व्याख्या

R                  # reverse input
 v                 # for each N,y (index, item)
  y¹gÅ0«           # pad y with as many zeroes as the number of rows in the input
        NFÁ}       # rotate each row N times right
            })     # wrap the result in a list
              øO   # sum the columns
                ¨  # remove the last element of the resulting list (the padded zeroes)

Answer 8

जे , 7 बाइट्स

+//.@|.

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

यह बहुत आसान है:

+//.@|.
+/        sum
  /.      on oblique lines
    @|.   on the reversed array

ओब्लिक उलट रेखाएं सरणी के विकर्ण हैं, इसलिए यह विकर्णों का योग है।

Answer 9

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

lambda M:reduce(lambda x,y:map(sum,zip([0]+x,y+[0]*len(x))),M)

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

Answer 10

जेली , 8 बाइट्स

ŒDS€ṙZL$

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

कोड के आधे का उपयोग परिणामों को सही क्रम में रखने के लिए किया जाता है।

कैसे?

ŒDS€ṙZL$ - Main link: list of lists of numbers
ŒD       - diagonals (starts with the diagonal containing the top left element,
         -            then the next diagonal to the right, and so on wrapping around)
  S€     - sum €each
       $ - last two links as a monad
     Z   - transpose the matrix
      L  - length (width of the matrix)
    ṙ    - rotate the results left by that amount

Answer 11

पर्ल 5, 47 बाइट्स

map{$j=--$.;map{@a[$j++]+=$_}split}<>
print"@a"

Answer 12

आर, 45 बाइट्स

इनपुट के रूप में मैट्रिक्स-क्लास ऑब्जेक्ट ले रहे हैं:

function(x)sapply(split(x,col(x)-row(x)),sum)

इस उत्तर में बताए गए विचार का उपयोग करना ।

Comments

मेरा मानना ​​है कि इस चुनौती में नियम आपको कॉल से छुटकारा पाने की अनुमति देते हैं unname, लेकिन यह एक भयानक समाधान है!

— ग्यूसेप

Answer 13

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

उदाहरण के लिए, मान लेना एक मैट्रिक्स है:

A = [17 4 5;24 16 5; 9 24 10; 1 14 22; 1 21 24; 4 4 17;24 25 17];

तो हमारे पास हैं:

[m,n]=size(A);
a=[zeros(m,m-1),A]';
for i=1:m+n-1
trace(a(i:end,:))
end

ध्यान दें कि मैट्रिक्स को स्थानांतरित करना विकर्ण रकम के आदेश को उलट देता है, जिसने लूप के लिए समग्र दो बाइट्स को बचाया।

आउटपुट:

ans =  24
ans =  29
ans =  22
ans =  39
ans =  47
ans =  70
ans =  43
ans =  9
ans =  5

Comments

[m,n]=size(A);for i=1:m+n-1,trace([zeros(m-1,m);A'](i:end,:)),end6 बाइट्स बचाता है। ऑक्टेव डायरेक्ट इंडेक्सिंग और इनलाइन असाइनमेंट कर सकते हैं। दुर्भाग्य से, यह सोचते हैं कि काम करने की जगह कोड चलाने से पहले में एक चर अस्तित्व की अनुमति नहीं है तो मुझे लगता है कि आप का उपयोग करना चाहिए inputकी तरह, इस लाने यह 75 बाइट्स का बैक अप। हालांकि अच्छा दृष्टिकोण, इसलिए +1 मुझसे :) और PPCG में आपका स्वागत है! =)

— स्टिव ग्रिफ़िन

इसके अलावा, 4 बाइट बचाने के zeros(m-1,m)लिए लिखा जा सकता है ~e(m-1,m):) नीट हुह?

— स्टीवी ग्रिफिन

Answer 14

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

x=input()
f=lambda k:[x[i+k][i]for i in range(len(x)-k)]
a=map(f,range(4)[::-1])
x=zip(*x)
print(map(sum,a+map(f,range(1,4))))

fकेवल निचले त्रिकोणीय अनुभाग पर काम करता है, इसलिए मैं इसे स्थानांतरित करता हूं और उस तरह से ऊपरी त्रिकोणीय अनुभाग प्राप्त करता हूं। न जाने क्यों fफ़ंक्शन नकारात्मक मानों के लिए काम नहीं करता है (मैं fछोटा हो गया क्योंकि नकारात्मक हिस्सा पाने के लिए काम नहीं किया गया)।

Comments

मुझे अंतिम परीक्षण मामले के लिए एक त्रुटि मिलती है। tio.run/nexus/…

— डेनिस

Answer 15

सी, 148 बाइट्स

ऑनलाइन प्रयास करें

s;g(int i,int j,int**m,int x){for(s=0;x;x--)s+=m[i++][j++];printf(" %d",s);}
k;f(int n,int**m){for(k=n;--k;)g(k,0,m,n-k);for(;k<n;k++)g(0,k,m,n-k);}

Answer 16

PHP, 81 बाइट्स

2 D सरणी के रूप में इनपुट लें

<?foreach($_GET as$k=>$v)foreach($v as$x=>$y)$r[$x-$k]+=$y;ksort($r);print_r($r);

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

Answer 17

अवाक, 67 बाइट्स

{for(f=0;f++<NF;)s[NF-NR+f]+=$f}END{i=0;while(i++<NR*2)print s[i]}

Ungolfed:

{
    for (f = 0; f++ < NF;)
        s[NF-NR+f] += $f
}
END {
    i = 0
    while (i++ < NR*2)
        print s[i]
}

Awk पर खाली स्थान के विभाजन $nहै nवें क्षेत्र (1 अनुक्रमित); NFलाइन पर फ़ील्ड्स NRकी संख्या है, वर्तमान पंक्ति की संख्या है। अपरिभाषित चर 0 हैं और पहले उपयोग पर बनाए गए हैं।

Answer 18

PHP, 86 बाइट्स

दो वेरिएंट में एक मेमोरी फ्रेंडली सॉल्यूशन:

<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=0,$d=$c;$d--;)$s+=$a[$i+$d][$d];
<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=$d=0;$d<$c;)$s+=$a[$i+$d][$d++];

स्क्रिप्ट मापदंडों से इनपुट लेता है, सीमांकक के रूप में अंडरस्कोर का उपयोग करता है;
डिफ़ॉल्ट सेटिंग्स का उपयोग करें (डिफ़ॉल्ट php.ini नहीं) या उन्हें ऑनलाइन आज़माएं

Answer 19

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

#(apply map +(map(fn[i c](concat(repeat(-(count %)i 1)0)c(repeat i 0)))(range)%))

काफी क्रिया, क्योंकि यह पैड को शून्य के साथ सूचीबद्ध करता है ताकि हम कॉलम-वार राशि की गणना कर सकें।

Answer 20

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

Plus@@@Table[Diagonal[Partition[#1,#2[[1]]],k],{k,-#2[[2]]+1,#2[[1]]-1}]&

यह किसी भी 2D- सरणी mxn (न केवल nxn) के लिए काम करता है
इस तरह (अंतिम परीक्षण मामले) कोड के अंत में सरणी इनपुट

[{17,4,5,24,16,5,9,24,10,1,14,22,1,21,24,4,4,17,24,25,17},{3,7}]

{24, 29, 22, 39, 47, 70, 43, 9, 5}

इनपुट के रूप में [{ए, बी, सी, डी ...}, {एम, एन}]