एपीएल के सम्मान में इस वर्ष 50 साल के एक इंटरेक्टिव टूल के रूप में प्रस्तुत किया गया

पृष्ठभूमि

केन [आइवरसन] ने अगस्त 1963 में मैकेनिकल लैंग्वेज स्ट्रक्चर्स, प्रिंसटन, एनजे पर एक वर्किंग कॉन्फ्रेंस में प्रोग्रामिंग लैंग्वेज में अपना पेपर फॉर्मेलिज्म पेश किया । संघर्षों की सूची प्रसिद्ध और जल्द ही प्रसिद्ध नामों से भरी हुई है, और कुछ भविष्य के ट्यूरिंग अवार्ड विजेता (बैकस, करी, डेज्स्ट्रा, फ्लॉयड, आइवरसन, नेवेल, पर्लिस, विल्केस)। यह पेपर उस प्रस्तुति के बाद होने वाली चर्चा को भी रिकॉर्ड करता है, जो केन और [एद्सर] दिज्क्स्ट्रा के बीच एक आदान-प्रदान के साथ समाप्त होती है , जिसमें केन का दिक्जस्ट्रा के प्रश्न का उत्तर एक-लाइनर था।

चुनौती

आप एक अधिक जटिल ऑपरेशन का प्रतिनिधित्व कैसे करेंगे, उदाहरण के लिए, मैट्रिक्स एम के सभी तत्वों का योग जो संबंधित पंक्ति और स्तंभ सूचक के योग के बराबर हैं?

किसी दिए गए पूर्णांक मैट्रिक्स में प्रत्येक तत्व की राशि की गणना करने के लिए एक स्निपेट या अभिव्यक्ति (पूर्ण कार्यक्रम या फ़ंक्शन की कोई आवश्यकता नहीं) लिखें जो इसके सूचक के योग के बराबर है। या, जैसा कि FryAmTheEggman डालता है यह: एक मैट्रिक्स दी एम तत्वों के साथ एक_ij प्रत्येक की राशि वापस कर एक_ij जहां एक_ij = i + j।

आप पहले से ही एक चर या स्मृति स्थान में होने वाले मैट्रिक्स को मान सकते हैं, या आप इसे एक तर्क या इनपुट के रूप में ले सकते हैं। आप 0 या 1 आधारित सूचकांकों का उपयोग कर सकते हैं।

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

0 खाली मैट्रिक्स के लिए

00 आधारित सूचकांकों के लिए या 21-आधारित के लिए

1 5 2
9 4 2
5 9 6

21 आधारित या 101 आधारित के लिए

11

3 -1 3 3
3 -1 3 1

61 आधारित या 31 आधारित के लिए

उपाख्यान

आइवरसन का उत्तर ++ / ( M =' s ⨢ ⍳ ¹ //) // M था , जो कि न तो Iverson संकेतन में मान्य है जैसा कि A प्रोग्रामिंग लैंग्वेज में परिभाषित किया गया है , और न ही आखिरकार APL बन गया है। इवर्सन अंकन में, यह हो गया होता + / ( एम = ⍳ ¹ ( μ ( एम )) ⨢ ⍳ ¹ ( ν ( एम ))) / एम । एपीएल के पहले संस्करणों में यह था +/(,M=(⍳1↑⍴M)∘.+⍳1↓⍴M)/,M।

— एडम
स्रोत

जिसमें केन का डेज्क्स्ट्रा के सवाल का जवाब वन-लाइनर था। लेकिन तब वह वन-लाइनर गलत था?

— लुइस मेन्डो

क्या मुझे इसे आउटपुट करने या प्रिंट आउट करने की आवश्यकता है, या क्या मैं सिर्फ एक स्निपेट के रूप में अभिव्यक्ति लिख सकता हूं?

— लीक नून

2

@LuisMendo नहीं, इवरसन सक्रिय रूप से भाषा डिजाइन कर रहा था, और उस पुनरावृत्ति में, उसका एक-लाइनर सही था। "एपीएल" पुस्तक के प्रकाशन के साथ मशहूर हो गया एक पी rogramming एल anguage , लेकिन प्रकाशन के समय में, दूसरा अभिव्यक्ति की जरूरत थी। इनमें से किसी भी सूचना को मशीन-निष्पादन योग्य होने के लिए लागू नहीं किया गया था।

— 15

@LeakyNun गणना करने के लिए एक स्निपेट या अभिव्यक्ति लिखें

— Adám

@ Adám धन्यवाद यह अब और अधिक समझ में आता है

— लुइस मेंडो

9

एपीएल, 13 12 बाइट्स

1 बाइट @ jimmy23013 के लिए धन्यवाद।

1 अनुक्रमित।

सरणी को चर में संग्रहीत किया जाता है m।

+ /, मीटर × मीटर = + / ¨⍳⍴m
+ / Εm∩¨ + / ¨⍳⍴m

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

J में उत्तर के आधार पर , जो एपीएल पर आधारित भाषा है।

TryAPL में, कुंजी में: +/m`em`c`1+/`1`i`rm

सरणी के साथ: +/m`em`c`1+/`1`i`rm `[ 2 4 `r 3 `21 3 3 3 `21 3 1

व्याख्या

+/∊m∩¨+/¨⍳⍴m
           m    temp ← variable
          ⍴     temp ← shape of temp
         ⍳      temp ← a 2D array where each element is
                       the corresponding index. for the
                       example, this gives:
                       ┌───┬───┬───┬───┐
                       │1 1│1 2│1 3│1 4│
                       ├───┼───┼───┼───┤
                       │2 1│2 2│2 3│2 4│
                       └───┴───┴───┴───┘
      +/¨       each element in temp ← its sum
   m∩¨          temp ← intersect each element in temp with the variable
+/              temp ← sum of temp

— लीक नन
स्रोत

अंत में, मैं इस एक का इंतजार कर रहा था।

— एडम जूल 19'16

मुझे यकीन नहीं है "में कुंजी करने के लिए" एक अच्छा विचार है। यह केवल TryAPL और RIDE पर लागू होता है, लेकिन मुख्य उत्पाद पर नहीं। कम से कम आप समझा सकते हैं कि `"एपीएल कुंजी" का मतलब है।

— एडम जूल 19'16

1

+/∊m∩¨+/¨⍳⍴m।

— jimmy23013

@ jimmy23013 यह वास्तव में अच्छा है!

— आरा

9

MATL , 15 14 10 बाइट्स

3#fbb+y=*s

इनपुट में पंक्तियों को अलग किया गया है ;। उदाहरण के लिए [1 5 2; 9 4 2; 5 9 6]:। 1-आधारित अनुक्रमण का उपयोग किया जाता है।

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

व्याख्या

मैं [3 -1 3 3; 3 -1 3 1]स्पष्टीकरण में इनपुट के साथ उदाहरण का उपयोग करूंगा ।

3#f    % Three-output find: for all nonzero values of implicit input matrix, pushes
       % three column vectors with row indices, column indices, and values
       %   Stack contains: [1;2;1;2;1;2;1;2], [1;1;2;2;3;3;4;4], [3;3;-1;-1;3;3;3;1]
bb     % Bubble up twice: move vectors of row and column indices to top
       %   Stack contains: [3;3;-1;-1;3;3;3;1], [1;2;1;2;1;2;1;2], [1;1;2;2;3;3;4;4]
+      % Element-wise sum of top two arrays
       %   Stack contains: [3;3;-1;-1;3;3;3;1], [2;3;3;4;4;5;5;6]
y      % Duplicate the vector of nonzero values onto the top of the stack
       %   Stack contains: [3;3;-1;-1;3;3;3;1], [2;3;3;4;4;5;5;6], [3;3;-1;-1;3;3;3;1] 
=      % Element-wise equality test of top two arrays
       %   Stack contains: [3;3;-1;-1;3;3;3;1], [0;1;0;0;0;0;0;0]
*      % Element-wise multiply of top two arrays
       %   Stack contains: [0;3;0;0;0;0;0;0]
s      % Sum of array
       %   Stack contains: 3

— लुइस मेंडो
स्रोत

6

जावास्क्रिप्ट, 49 46 बाइट्स

a.map((b,i)=>b.map((c,j)=>r+=c==i+j&&c),r=0)|r

संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए हैं जो इंगित करते हैं कि स्निपेट की अनुमति है।

— नील
स्रोत

5

रेटिना , 46 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

\d+
$*
M!`(?<=(\S* |.*¶)*)(?<-1>1)+\b(?(1)1)
1

मैट्रिक्स का प्रतिनिधित्व करने के लिए इनपुट स्पेस और लाइनफ़ीड विभाजकों का उपयोग करता है। संकेत 0-आधारित हैं।

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

व्याख्या

काफी हद तक रेटिना के लिए चुनौती नहीं बनी, लेकिन यह आश्चर्यजनक रूप से अच्छा कर रहा है ... :)

चरण 1: प्रतिस्थापन

\d+
$*

यह केवल स्ट्रिंग में सभी पूर्णांक को एक अंक के 1रूप में उपयोग करते हुए एक संख्या के रूप में विस्तारित करता है । जैसे नकारात्मक संख्या -3बस चीजों की तरह हो जाएगा -111।

स्टेज 2: मैच

M!`(?<=(\S* |.*¶)*)(?<-1>1)+\b(?(1)1)

!विकल्प के कारण , यह दिए गए रेगेक्स के सभी मैचों को प्रिंट करता है। कहा रेगेक्स बैलेंसिंग ग्रुप्स का उपयोग करता है ताकि यह जांचा जा सके कि वर्तमान संख्या उसके सूचकांकों के योग के समान है या नहीं।

ऐसा करने के लिए, हम पहले लुकटाइम के साथ सूचकांकों का योग निर्धारित करते हैं (?<=(\S* |.*¶)*)। यह प्रत्येक संख्या के लिए एक ही पंक्ति को वर्तमान लाइन के सामने जोड़ता है (माध्यम से \S* ) साथ ही साथ प्रत्येक पंक्ति के लिए एक को वर्तमान एक ( .*¶समूह) के सामने एक समूह में जोड़ता है 1। इसलिए, परिणामस्वरूप हमें सूचकांकों का शून्य-आधारित योग प्राप्त होता है।

फिर हम इस स्टैक से कैप्चर को हटाते हुए पूरे अगले नंबर का मिलान करने का प्रयास करते हैं (?<-1>1)+\b। और फिर हम मैच को विफल बनाते हैं यदि समानता सुनिश्चित करने के लिए किसी भी कब्जा समूह के 1साथ छोड़ दिया जाता है (?(1)1)।

ध्यान दें कि ऋणात्मक संख्याओं का मिलान कभी नहीं किया जाता है, क्योंकि खोजकर्ता s -की सूची के सामने अतीत को प्राप्त नहीं कर सकते हैं 1और (?<-1>1)+इसका मिलान भी नहीं कर सकते हैं।

इससे हमें उन सभी एकात्मक संख्याओं की सूची मिलती है जो उनके सूचकांकों के योग के बराबर होती हैं।

स्टेज 3: मैच

हम एक अन्य मैच चरण के साथ समाप्त होते हैं, लेकिन !विकल्प के बिना , यह सिर्फ मैचों की संख्या को गिनता है, जो दोनों पिछले परिणाम से सभी एकात्मक संख्याओं को जोड़ते हैं और उस राशि को दशमलव में वापस परिवर्तित करते हैं।

— मार्टिन एंडर
स्रोत

क्या आप इनपुट के रूप में यूनेरी का उपयोग कर सकते हैं?

— लीक नून

@LeakyNun पता नहीं, मैं थोड़े से बचने की कोशिश कर रहा हूं। ऐसा लगता है कि बहुत ज्यादा हैकिंग हो रही है, खासकर जब से रेटिना को रूपांतरण से कोई परेशानी नहीं है।

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

4

जेली, 15 14 10 बाइट्स

अदनान को 4 बाइट्स धन्यवाद।

1 अनुक्रमित।

L € R € + "LR $ = 
R × LFS L € R € +" LR $ = × ³FS
जम्मू € + "जे = × ⁸FS

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

एक बार में सभी टेस्टकेस का सत्यापन करें। (ज़रा - सा संशोधित।)

— लीक नन
स्रोत

मुझे यकीन नहीं है कि यह काम करता है, लेकिन क्या आप इसके J€बजाय कर सकते हैं L€R€?

— अदनान

1

हे भगवान, तुम एक प्रतिभाशाली हो।

— लीक नून

4

अजगर 2 - 60 57 बाइट्स

यह एक कोड स्निपेट है, इसलिए यदि मैं वास्तव में मूल्य लौटाता हूं तो यह कुछ अधिक बाइट्स होगा, मुझे लगता है। e=enumerate;sum(i*(x+y==i)for x,r in e(a)for y,i in e(r))

Leaky Num :-) की मदद के लिए धन्यवाद

त्वरित स्पष्टीकरण। aएक सरणी धारण संख्या है। बस इंडेक्स के माध्यम से पुनरावृत्त करें और उन सभी मूल्यों को जोड़ दें जहां मूल्य सूचकांक के योग के बराबर है।

— जेरेमी
स्रोत

e=enumerate;sum(i*(x+y==i)for x,r in e(a)for y,i in e(r))

— लीक नून

ओह यह काम नहीं किया। तो अब इसके 57 बाइट्स: (मैंने एक त्वरित स्पष्टीकरण जोड़ा

— जेरेमी

आप उस लिंक को शामिल करना चाह सकते हैं जो मैंने अभी आपको दिया है।

— लीक नन

4

आर, 24 बाइट्स

sum(M[M==row(M)+col(M)])

1 के आधार पर।
परीक्षण के मामलों:

> M<-matrix(nrow=0,ncol=0)
> M
<0 x 0 matrix>
> sum(M[M==row(M)+col(M)])
[1] 0
> M<-matrix(2,nrow=1,ncol=1)
> M
     [,1]
[1,]    2
> sum(M[M==row(M)+col(M)])
[1] 2
> M<-matrix(c(1,9,5,5,4,9,2,2,6),nrow=3)
> M
     [,1] [,2] [,3]
[1,]    1    5    2
[2,]    9    4    2
[3,]    5    9    6
> sum(M[M==row(M)+col(M)])
[1] 10
> M<-matrix(c(0,0,4,-2,3,4,3,4,0,1,1,-2,4,4,2,-1),nrow=4)
> M
     [,1] [,2] [,3] [,4]
[1,]    0    3    0    4
[2,]    0    4    1    4
[3,]    4    3    1    2
[4,]   -2    4   -2   -1
> sum(M[M==row(M)+col(M)])
[1] 11
> M<-matrix(c(3,3,-1,-1,3,3,3,1),nrow=2)
> M
     [,1] [,2] [,3] [,4]
[1,]    3   -1    3    3
[2,]    3   -1    3    1
> sum(M[M==row(M)+col(M)])
[1] 3

— plannapus
स्रोत

3

जे, 15 बाइट्स

+/,M*M=+/&i./$M

शून्य-आधारित अनुक्रमण का उपयोग करता है और मानता है कि मैट्रिक्स पहले से ही चर में संग्रहीत है एम ।

व्याख्या

+/,M*M=+/&i./$M
             $a  Get the shape of M
            /    Insert between the shape
         &i.     Create a range from 0 to each end exclusive
       +/        Forms a table which is the sum of each row and column index
     M=          1 if the element is equal to its index sum else 0
   M*            Multiply by their values
  ,              Flatten
+/               Reduce using addition to get the sum

— मील की दूरी पर
स्रोत

3

अब तक न केवल सबसे कम; एक आइवरसन भाषा में इसे करने के लिए +1।

— 13

3

CJam, 23 21 20 बाइट्स

3 बाइट बचाने के लिए पीटर टेलर का धन्यवाद।

ee{~_@f-_,,.=.*~}%1b

मैट्रिक्स को स्टैक पर होने की उम्मीद है और इसके बजाय योग छोड़ देता है। दोनों ही मामलों में संकेत शून्य-आधारित हैं।

इसका परीक्षण यहां करें।

— मार्टिन एंडर
स्रोत

आप एक जोड़े _,,को भीतर के बजाय eeऔर .भीतर के पाश के लिए बचा सकते हैं :ee{~_,,@f+1$.=.*~}%1b

— पीटर टेलर

@PeterTaylor आह नी, शुक्रिया :)

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

वास्तव में, बीच-बीच में एक तरह की मीटिंग करके एक और बात है:ee{~_@f-_,,.=.*~}%1b

— पीटर टेलर

3

k4, 24 बाइट्स

माना जाता है कि मैट्रिक्स में संग्रहीत है m।

+//7h$m*m=(!#m)+/:\:!#*m

यह उन पहेलियों में से एक है जहां एपीएल (और जे) से डिजाइनिंग में शामिल सरलीकरण वास्तव में चोट पहुंचाता है-के के !एपीएल के बराबर है, ⍳लेकिन केवल वैक्टर पर काम करता है, इसलिए मुझे खुद ही सूचक मैट्रिक्स को इकट्ठा करना होगा; आंतरिक उत्पाद एपीएल में एक चरित्र है लेकिन कश्मीर में पांच; और मैंने खाली मैट्रिक्स को ठीक से संभालने के लिए तीन वर्ण खो दिए क्योंकि k में दृढ़ता से टाइप किए गए मैट्रिसेस नहीं हैं।

— हारून डेविस
स्रोत

2

दूसरी ओर, आपके पास एक शक्तिशाली भाषा है जो बहुत अधिक सुसंगत है, और सीखने के लिए बहुत कम आदिम हैं।

— एडम जूल

2

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

0 अनुक्रमित।

ss.e.e*ZqZ+kYb

परीक्षण सूट।

— लीक नन
स्रोत

2

PowerShell v2 +, 43 बाइट्स

%{$j=0;$_|%{$o+=$_*($_-eq$i+$j++)};$i++};$o

स्निपेट के रूप में। इसका उपयोग मैट्रिक्स को स्पष्ट रूप से पाइप करने के लिए है (नीचे दिए गए उदाहरण देखें)। मान लेता है कि $i, और $oशुरू में या तो शून्य या शून्य हैं (मैंने नीचे दिए उदाहरणों में उन्हें स्पष्ट रूप से इस तरह सेट किया है), और 0-सूचकांक का उपयोग करता है।

मैट्रिक्स की प्रत्येक पंक्ति पर एक फॉर्च लूप करता है। हम सेट $jकरते हैं 0, और फिर पंक्ति के प्रत्येक तत्व को दूसरे लूप में जाते हैं $_|%{...}। प्रत्येक आंतरिक लूप, हम $oवर्तमान तत्व द्वारा एक बूलियन से गुणा करते हैं ($_-eq$i+$j++), जिसका अर्थ है कि यदि बूलियन है $TRUE, तो यह 1अन्यथा होगा 0। फिर हम आंतरिक लूप, वेतन वृद्धि से बाहर निकलते हैं $iऔर अगली पंक्ति शुरू करते हैं। अंत में, हम अंत $oमें पाइपलाइन पर छोड़ देते हैं ।

उदाहरण

PS C:\Tools\Scripts\golfing> $o=0;$i=0;$j=0;@(@(3,-1,3,3),@(3,-1,3,1))|%{$j=0;$_|%{$o+=$_*($_-eq$i+$j++)};$i++};$o
6

PS C:\Tools\Scripts\golfing> $o=0;$i=0;$j=0;@(@(0,3,0,4),@(0,4,1,4),@(4,3,1,2),@(-2,4,-2,-1))|%{$j=0;$_|%{$o+=$_*($_-eq$i+$j++)};$i++};$o
11

— AdmBorkBork
स्रोत

2

रूबी, 63 बाइट्स

Z के साथ संख्या के दो आयामी सरणी के रूप में:

s=0;z.each_index{|i|z[i].each_index{|j|s+=i+j if z[i][j]==i+j}}

बहुत रोमांचक नहीं है।

यदि z एक्स और वाई के साथ एक चपटा हुआ सरणी है, जिसमें सरणियों के आकार होते हैं, जैसे:

x=z.size
y=z[0].size
z=z.flatten

तब हमारे पास यह राक्षसीता है - शायद यह फैंसी उत्पादों और ज़िप के साथ अधिक रूबी-ईश है, लेकिन वास्तव में बड़ा है:

(1..x).to_a.product((1..y).to_a).zip(z).inject(0){|s,n|s+(n[0][0]+n[0][1]==n[1]+2?n[1]:0)}

— डेविड लजंग मैडिसन स्टेलर
स्रोत

शायद एक कट्टरपंथी सरणी या एन्यूमरेटर विधि है जो इसे छोटा कर देगी, मैंने इसे अभी तक नहीं पाया है, लेकिन मैं इसे देखना पसंद करूंगा।

— डेविड लजंग मैडिसन स्टेलर

2

दरअसल, 21 बाइट्स

ñ`i╗ñ"i╜+@;(=*"£Mi`MΣ

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

मुझे आलसी होने से रोकने के लिए लीक नन का धन्यवाद और अंत में यह लिखना।

यह 0-अनुक्रमित मैट्रिस का उपयोग करता है, और एक नेस्टेड सूची के रूप में इनपुट लेता है।

स्पष्टीकरण:

ñ`i╗ñ"i╜+@;(=*"£Mi`MΣ
ñ                      enumerate input
 `i╗ñ"i╜+@;(=*"£Mi`M   for each (i, row) pair:
  i╗                     flatten, store i in register 0
    ñ                    enumerate the row
     "i╜+@;(=*"£M        for each (j, val) pair:
      i╜+                  flatten, add i to j
         @;(               make an extra copy of val, bring i+j back to top
            =              compare equality of i+j and val
             *             multiply (0 if not equal, val if they are)
                 i       flatten the resulting list
                    Σ  sum the values

— मै जाऊं
स्रोत

एक ही बाइट-काउंट, बिना फंक्शन डेलिमिटर या रजिस्टर के

— लीके नन

2

मतलाब / ऑक्टेव, 48 बाइट्स

1 अनुक्रमित।

पहला परीक्षण मामला नहीं संभालेंगे क्योंकि [1:0]किसी कारण से आकार 1x0 है

sum(sum(M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0)))

ऑक्टेव 3 में परीक्षण किया गया।

पूरा कार्यक्रम:

M = [2]
sum(sum(M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0)))
M = [1 5 2; 9 4 2; 5 9 6]
sum(sum(M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0)))
M = [ 0 3  0  4; 0 4  1  4; 4 3  1  2;-2 4 -2 -1]
sum(sum(M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0)))
M = [ 3 -1 3 3; 3 -1 3 1]
sum(sum(M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0)))

— spambot
स्रोत

PPCG में आपका स्वागत है! ऑक्टेव में आप कर सकते हैं sum((M.*(M-[1:size(M,1)]'-[1:size(M,2)]==0))(:))। इसके अलावा, मुझे लगता है कि आप बाइट काउंट को कम करने के लिए ==0शुरुआती और प्रारंभिक बदलाव कर सकते हैं ~। अंत में, ध्यान दें कि आपको सभी परीक्षण मामलों को संभालने की आवश्यकता है या फिर प्रश्न को हटा दिया

— लुइस मेन्डो

1

लुआ, 70 बाइट्स

1 अनुक्रमित।

s=0 for i=1,#a do for j=1,#a[i]do s=i+j==a[i][j]and s+i+j or s end end

बोनस: यह ragged arrays के लिए काम करता है!

इनपुट में संग्रहीत a, आउटपुट में संग्रहीत s।

पूरा कार्यक्रम:

function Dijkstras_Challenge(a)
    s=0 for i=1,#a do for j=1,#a[i]do s=i+j==a[i][j]and s+i+j or s end end
    print(s)
end

Dijkstras_Challenge({})
Dijkstras_Challenge({{2}})
Dijkstras_Challenge({{1,5,2},{9,4,2},{5,9,6}})
Dijkstras_Challenge({{0,3,0,4},{0,4,1,4},{4,3,1,2},{-2,4,-2,-1}})
Dijkstras_Challenge({{3,-1,3,3},{3,-1,3,1}})

— लीक नन
स्रोत

1

PHP, 59 बाइट्स

foreach($a as$y=>$r)foreach($r as$x=>$v)$s+=($v==$x+$y)*$v;

सरणी $ एक परिभाषित की उम्मीद है; खाली या 2-आयामी होना चाहिए, 0-अनुक्रमित। 1-इंडेक्स व्यवहार के लिए अंतिम से पहले
$ s (पहले 0 या अपरिभाषित - 0 बराबर NULL)
सम्मिलित करने के लिए राशि की गणना करता है+2)

जन्मदिन मुबारक हो एपीएल!

कार्य और परीक्षण सूट

function f0($a) { foreach($a as$y=>$r)foreach($r as$x=>$v)$s+=($v==$x+$y)*$v;return $s|0; }
function f1($a) { foreach($a as$y=>$r)foreach($r as$x=>$v)$s+=($v==$x+$y+2)*$v;return $s|0;}
$samples = [
    [], 0, 0,
    [[2]], 0, 2,
    [[1,5,2],[9,4,2],[5,9,6]], 2, 10,
    [[0,3,0,4],[0,4,1,4],[4,3,1,2],[-2,4,-2,-1]],11,11,
    [[3,-1,3,3],[3,-1,3,1]],6,3
];
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',cmp($e,$y)?'N':'Y',"</td></tr>";$h='';}
while($samples)
{
    $a=array_shift($samples);
    test($a,'B0:'.array_shift($samples),'B0:'.f0($a));
    test($a,'B1:'.array_shift($samples),'B1:'.f1($a));
}

— टाइटस
स्रोत

1

ब्रेकीलॉग , 15 बाइट्स

{iiʰI-ʰ=∧Ihh}ᶠ+

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

              +    The output is the sum of
{           }ᶠ     all possible results of
 i                 taking a row from the input with its index,
  i                taking an element with its index
   ʰ               from that row,
    I    Ihh       and outputting the element
       =∧          so long as the index of the row is equal to
     -ʰ            the value of the element minus its index within the row.

— असंबंधित स्ट्रिंग
स्रोत

1

वोल्फ्राम भाषा (गणितज्ञ) , 42 बाइट्स

ArrayRules/*Cases[p_~_~v_/;Tr@p==v:>v]/*Tr

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

1 अनुक्रमित।

ArrayRules                                  (*Convert into a list of (position->value) Rules*)
          /*Cases[p_~_~v_/;Tr@p==v          (*select those where sum(position)==value*)
                                  :>v]/*Tr  (*and find the sum of those values*)

— attinat
स्रोत

दीजकस्ट्रा की चुनौती

एपीएल के सम्मान में इस वर्ष 50 साल के एक इंटरेक्टिव टूल के रूप में प्रस्तुत किया गया

पृष्ठभूमि

चुनौती

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

उपाख्यान

एपीएल, 13 12 बाइट्स

व्याख्या

MATL , 15 14 10 बाइट्स

व्याख्या

जावास्क्रिप्ट, 49 46 बाइट्स

रेटिना , 46 बाइट्स

व्याख्या

जेली, 15 14 10 बाइट्स

अजगर 2 - 60 57 बाइट्स

आर, 24 बाइट्स

जे, 15 बाइट्स

व्याख्या

CJam, 23 21 20 बाइट्स

k4, 24 बाइट्स

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

PowerShell v2 +, 43 बाइट्स

उदाहरण

रूबी, 63 बाइट्स

दरअसल, 21 बाइट्स

मतलाब / ऑक्टेव, 48 बाइट्स

लुआ, 70 बाइट्स

पूरा कार्यक्रम:

PHP, 59 बाइट्स

ब्रेकीलॉग , 15 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 42 बाइट्स