पृष्ठभूमि

पूर्णांक के एक सरणी का डेल्टा निरंतर तत्वों के अंतर को प्राप्त करके बनाई गई सरणी है। उदाहरण के लिए, [1, 2, 4, 7, 3, 9, 6]निम्नलिखित डेल्टा हैं [1, 2, 3, -4, 6, -3]:।

अब हम पूर्णांक के एक मैट्रिक्स के डेल्टा को परिभाषित करेंगे क्योंकि इसमें प्रत्येक पंक्ति और प्रत्येक स्तंभ के डेल्टा होते हैं।

उदाहरण के तौर पे:

Row deltas:

1 2 3 4 │ => [1, 1, 1]
4 5 6 7 │ => [1, 1, 1]
7 1 8 2 │ => [-6, 7, -6]

Column deltas (the matrix' columns have been rotated into rows for simplicity):

1 4 7 │ => [3, 3] 
2 5 1 │ => [3, -4]
3 6 8 │ => [3, 2]
4 7 2 │ => [3, -5]

जो हमें मैट्रिक्स डेल्टास की निम्नलिखित सूची देता है:

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

और जैसा कि हम उन्हें नेस्टेड नहीं करना चाहते हैं, हम उस सूची को समतल करते हैं:

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

कार्य

आपका कार्य इनपुट के रूप में दिए गए मैट्रिक्स के सभी डेल्टास को योग करना है । ध्यान दें कि मैट्रिक्स में केवल गैर-नकारात्मक पूर्णांक शामिल होंगे।

नियम

सभी मानक नियम लागू होते हैं।
आप मान सकते हैं कि मैट्रिक्स में प्रत्येक पंक्ति और स्तंभ पर कम से कम दो मान हैं, इसलिए न्यूनतम आकार 2x2 होगा ।
जब तक आप इसे निर्दिष्ट करते हैं, तब तक आप मैट्रिक्स को किसी भी उचित प्रारूप में ले सकते हैं।
आप यह नहीं मान सकते हैं कि मैट्रिक्स चौकोर है।
यदि यह मदद कर सकता है आप अपने बाइट गिनती कम है, तो आप कर सकते हैं वैकल्पिक पंक्तियों की संख्या और इनपुट के रूप में स्तंभों की संख्या के साथ-साथ ले (आप सी को देखते हुए!)।
यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में सबसे कम कोड (बाइट्स में) जीतता है!

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

इनपुट => आउटपुट

[[१, २], [१, २]] => २
[[[,,, १], [४, १, ३], [५, ५, ५]] =>-९
[[१, २, ३], [४, ५, ६], [,,,, ९]] => २४
[[९, ९, ९, ९, ९], [९, ९, ९, ९, ९]] => ०
[[१, ३, १४], [५६,, ९, २०], [९९, ९९, ९९]] => २५६
[[१, २, ३, ४], [४, ५, ६, [], [,, १,,, २]] => ९
[[13, 19, 478], [0, 12, 4], [45, 3, 6], [1, 2, 3]] => -72

— मिस्टर एक्सकोडर
स्रोत

12

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

lambda m:sum(r[-1]-r[0]for r in m+zip(*m))

एक अनाम फ़ंक्शन सूची की सूची ले रहा है m, और परिणामी संख्या वापस कर रहा है।

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

कैसे?

किसी सूची के डेल्टास का योग सबसे पहला तत्व है, बाकी सब बस रद्द करता है:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

का zip(*m)उपयोग करता है unpacking ( *) अलग तर्कों mकी पंक्तियों को पास mकरने के लिए zip(इंटरलेव) और इसलिए मैट्रिक्स को स्थानांतरित करता है। अजगर 2 में यह एक सूची बनाता है (टुपल्स की, लेकिन यह ठीक है), इसलिए हम इसे (साथ में) जोड़ सकते हैं m, हमारी सभी पंक्तियों और स्तंभों के माध्यम से कदम उठा सकते हैं, rप्रत्येक के लिए उपरोक्त चाल को निष्पादित कर सकते हैं और बस परिणाम जोड़ सकते हैं। ( sum(...))।

— जोनाथन एलन
स्रोत

8

आर , 34 बाइट्स

function(m)sum(diff(m),diff(t(m)))

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

अनाम फ़ंक्शन। मूल रूप से, मुझे apply(m,1,diff)रॉविज़ डिफरेंस (और कॉलम के 2बजाय 1) मिलता था, लेकिन स्टीवी ग्रिफिन के जवाब को देखते हुए मैंने इसे बस के साथ आजमाया diffऔर यह काम कर गया।

— ग्यूसेप
स्रोत

8

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

@(x)sum([diff(x)(:);diff(x')(:)])

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

स्पष्टीकरण:

यह एक अनाम फ़ंक्शन है जो xइनपुट के रूप में ले रहा है । यह सभी स्तंभों के बीच का अंतर लेता है, और इसे ट्रांसपोज़्ड के स्तंभों के बीच अंतर के साथ समेटता है x। इसके बाद इस वेक्टर को दूसरे आयाम के साथ जोड़ दिया जाता है।

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

5

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

;ZIẎS

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

कुछ ASCII- केवल संस्करण भी हैं: ;ZIFS ;ZISS

— आउटगोल्फ को एरिक करें
स्रोत

5

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

m=>m.map(r=>s+=[...l=r].pop()-r[0],s=0)|m[0].map(v=>s+=l.pop()-v)|s

प्रारूपित और टिप्पणी की गई

m =>                              // given a matrix m
  m.map(r =>                      // for each row r of m
    s += [...l = r].pop() - r[0], //   add to s: last value of r - first value of r
    s = 0                         //   starting with s = 0
  ) |                             //
  m[0].map(v =>                   // for each value v in the first row of m:
    s += l.pop() - v              //   add to s: last value of last row of m - v
  ) |                             //
  s                               // return s

क्योंकि इनपुट मैट्रिक्स का न्यूनतम आकार 2x2 है, m.map(...)|m[0].map(...)इसके लिए बाध्य होने की गारंटी है 0। इसलिए अंतिम परिणाम के साथ वापस आना सुरक्षित है |s।

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

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

let f =

m=>m.map(r=>s+=[...l=r].pop()-r[0],s=0)|m[0].map(v=>s+=l.pop()-v)|s

console.log(f( [[1, 2], [1, 2]]                                   )) // => 2
console.log(f( [[8, 7, 1], [4, 1, 3], [5, 5, 5]]                  )) // => -9
console.log(f( [[1, 2, 3], [4, 5, 6], [7, 8, 9]]                  )) // => 24
console.log(f( [[9, 9, 9, 9, 9], [9, 9, 9, 9, 9]]                 )) // => 0
console.log(f( [[1, 3, 14], [56, 89, 20], [99, 99, 99]]           )) // => 256
console.log(f( [[1, 2, 3, 4], [4, 5, 6, 7], [7, 1, 8, 2]]         )) // => 9
console.log(f( [[13, 19, 478], [0, 12, 4], [45, 3, 6], [1, 2, 3]] )) // => -72

स्निपेट का विस्तार करें

— Arnauld
स्रोत

5

MATL , 7 बाइट्स

dG!dhss

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

स्पष्टीकरण:

मान लीजिए इनपुट है

[8 7 1; 4 1 3; 5 5 5]

d        % Difference between rows of input
         % Stack:
         % [-4 -6  2; 1  4  2]
 G       % Grab the input again. Stack:
         % [-4 -6  2; 1  4  2]
         % [8 7 1; 4 1 3; 5 5 5]]
  !      % Transpose the bottom element. Stack:
         % [-4 -6  2; 1  4  2]
         % [8 4 5; 7 1 5; 1 3 5]
   d     % Difference between rows. Stack:
         % [-4 -6  2; 1  4  2]
         % [-1 -3  0; -6  2  0]
    h    % Concatenate horizontally. Stack:
         % [-4 -6  2 -1 -3  0; 1  4  2 -6  2  0]
     ss  % Sum each column, then sum all column sums. Stack:
         % -9

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

4

05AB1E , 6 बाइट्स

ø«€¥OO

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

4

जे , 14 बाइट्स

+/@,&({:-{.)|:

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

व्याख्या

+/@,&({:-{.)|:  Input: matrix M
            |:  Transpose
     (     )    Operate on M and M'
      {:          Tail
        -         Minus
         {.       Head
   ,&           Join
+/@             Reduce by addition

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

3

भूसी , 7 बाइट्स

ΣṁẊ-S+T

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

-1 एक्सकोडर की बदौलत मेरा ध्यान Sऔर (जो होना चाहिए था ) की ¤ओर से मेरा ध्यान mगया ṁ।
-1 ज़र्ब को गाली देते हुए धन्यवाद S।

स्पष्टीकरण:

ΣṁẊ-S+T 3-function composition
    S   (x -> y -> z) (f) -> (x -> y) (g) -> x (x) (implicit): f x g x
     +    f: [x] (x) -> [x] (y) -> [x]: concatenate two lists
      T   g: [[x]] (x) -> [[x]]: transpose x
 ṁ      (x -> [y]) (f) -> [x] (x) -> [y]: map f on x and concatenate
  Ẋ       f: (x -> y -> z) (f) -> [x] (x) -> [z]: map f on splat overlapping pairs of x
   -        f: TNum (x) -> TNum (y) -> TNum: y - x
Σ       [TNum] (x) -> TNum: sum x

— आउटगोल्फ को एरिक करें
स्रोत

हां, 8 बाइट्स का उपयोग करके ṁ।

— मिस्टर एक्सकोडर

8 बाइट्स भी, बजाय अपने दृष्टिकोण का उपयोग कर।

— मिस्टर एक्सकोडर

@ Mr.Xcoder वाह इसके बारे में भूल गया

— एरिक आउटगोल्फ सेफ़

3

एपीएल, 18 15 बाइट्स

{-+/∊2-/¨⍵(⍉⍵)}

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

— जाकारी
स्रोत

13 बाइट्स -+/∘∊(2-⍨/⍉⍪⊢)

— यूरिल

@ एरियल जो केवल वर्ग मैट्रिसेस के लिए काम करता है

— ngn

3

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

e=[]:e
z=zipWith
f s=sum$(z(-)=<<tail)=<<(s++foldr(z(:))e s)

इसे ऑनलाइन आज़माएं! कुछ समय पहले मिले छोटे ट्रांज़ोज़ का उपयोग करता है ।

व्याख्या

eखाली सूचियों की एक अनंत सूची है और जिसका उपयोग ट्रांसपोज़िंग के लिए किया जाता है। फ़ंक्शन के zलिए एक शॉर्टहैंड है zipWith, क्योंकि यह दो बार उपयोग किया जाता है।

f s=                                        -- input s is a list of lists
                            foldr(z(:))e s  -- transpose s
                         s++                -- append the result to the original list s
                     =<<(                 ) -- map the following function over the list and concatenate the results
        (z(-)=<<tail)                       -- compute the delta of each list by element-wise subtracting its tail
    sum$                                    -- compute the sum of the resulting list

— Laikoni
स्रोत

3

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

मौखिक रूप से @ sundar के डिजाइन पर आधारित है

⟨≡⟨t-h⟩ᵐ²\⟩c+

व्याख्या

⟨≡      \⟩          #   Take the original matrix and it's transpose 
      ᵐ             #       and execute the following on both
       ²            #           map for each row (this is now a double map "ᵐ²")
  ⟨t h⟩             #               take head and tail
   -                #               and subtract them from each other (sum of deltas in a row)
         c+         #       and add all the values 
                    #           (we have two arrays of arrays so we concat them and sum them)

⟨⟩स्वरूपण अप खिलवाड़ कर रहे हैं, खेद

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

— Kroppeb
स्रोत

2

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

ss.+M+C

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

गोल्फ की भाषा में मेरा पहला उत्तर! @EriktheOutgolfer के लिए धन्यवाद-1 बाइट !

व्याख्या

ss.+M+C    ~ This is a full program with implicit input (used twice, in fact)

      C    ~ Matrix transpose. Push all the columns;
     +     ~ Concatenate with the rows;
  .+M      ~ For each list;
  .+       ~ Get the deltas;
 s         ~ Flatten the list of deltas;
s          ~ Get the sum;
           ~ Print Implicitly;

— मिस्टर एक्सकोडर
स्रोत

.tC-1 के लिए हो सकता है।

— आउटगॉल्फ

@EriktheOutgolfer ओह वाह, धन्यवाद!

2

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

⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ

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

(-6 बाइट्स @ क्रॉपेब के सुझावों से प्रेरित हैं।)

?⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ.       Full code (? and . are implicit input and output)
?⟨≡{       }ᵐ\⟩          Apply this on both the input and its transpose:
    s₂ᶠ                  Get pairs of successive rows, [[row1, row2], [row2, row3], ...]
       c                 Flatten that: [row1, row2, row2, row3, row3, row4, ...]
        +ᵐ               Sum the elements within each row [sum1, sum2, sum2, sum3, ...]
          -              Get the difference between even-indexed elements (starting index 0)
                         and odd-indexed elements, i.e. sum1+sum2+sum3+... - (sum2+sum3+sum4+...)
                         This gets the negative of the usual difference i.e. a-b instead of b-a
                         for each pair of rows
               +         Add the results for the input and its transpose
                ṅ        Negate that to get the sign correct
                 .       That is the output

— sundar - मोनिका को बहाल करना
स्रोत

डेल्टास का योग अंतिम तत्व के बराबर होता है-पहला ⟨t-h⟩ट्रिक करता है। जिसके परिणामस्वरूप {⟨t-h⟩ᵐ+}R&\↰₁;R+5 बाइट्स छोटी होती हैं। इसे ऑनलाइन आज़माएं!

— क्राप्पेब

2 बाइट्स सहेजने के ⟨≡{...}ᵐ\⟩+बजाय का उपयोग करना {...}R&\↰₁;R+। ⟨≡{⟨t-h⟩ᵐ+}ᵐ\⟩+ यह ऑनलाइन कोशिश

— क्रोप्पेब

मानचित्र के मानचित्रण को एक दोहरे मानचित्र में बदलना और उस पर एक अतिरिक्त 2 बाइट्स को हटा देना और अलग करना ⟨≡⟨t-h⟩ᵐ²\⟩c+। इसे ऑनलाइन आज़माएं!

— क्रॉपेब

@Kroppeb यह एक सुधार के लिए पर्याप्त पर्याप्त और बड़ा है, कि आपको इसे स्वयं एक नए उत्तर के रूप में पोस्ट करना चाहिए। आपके सुझावों को देखकर मुझे एक अलग विधि का उपयोग करके 16-बाइट समाधान के लिए एक विचार दिया गया था ⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ इसे ऑनलाइन आज़माएं! , इसलिए मैं इस उत्तर को उस संस्करण के साथ अपडेट करूंगा।

— सूंदर -

2

जाप `-x` , ११ १० ९ बाइट्स

cUy)®än x

कोशिश करो

व्याख्या

c             :Concatenate
 U            :  Input array
  y           :  Transpose
   )          :End concatenation
    ®         :Map
     än       :  Deltas
        x     :  Reduce by addition
              :Implicitly reduce by addition and output

— झबरा
स्रोत

1

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

:⌡-≤H⌡-¹∑

यह कोशिश करो! (→ जोड़ा गया क्योंकि यह स्टैक पर इनपुट लेता है)

स्पष्टीकरण:

:          duplicate ToS
 ⌡         for each do
  -          get deltas
   ≤       get the duplicate ontop
    H      rotate it anti-clockwise
     ⌡     for each do
      -      get deltas
       ¹   wrap all of that in an array
        ∑  sum

— dzaima
स्रोत

1

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

— मिस्टर एक्सकोडर

@ Mr.Xcoder हम्म .. मैंने सोचा कि डिफ़ॉल्ट आदानों द्वारा अनुमति दी गई थी, लेकिन मैं वहाँ केवल अनुमान लगा इस के लिए काम करता है .. तो फिर, मैं कर सकता है के रूप में इस्तेमाल इस एक अनाम फ़ंक्शन को कॉल इस (एक "समारोह" रों SOGL में परिभाषा है functionNameSingleChar\n)

— द्विजिमा

ओह ठीक है। यह तब पूरी तरह से मान्य है।

— मिस्टर एक्सकोडर

1

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

Tr@Flatten[Differences/@#&/@{#,Transpose@#}]&

इनपुट

[{{१३, १ ९, ४ 47}}, {०, १२, ४}, {४५, ३, ६}, {१, २, ३}}]

— J42161217
स्रोत

क्या यह {#,Transpose@#}मेरे सरणी (जैसे मेरे पायथन उत्तर) के प्रत्येक सरणी के लिए अंतिम से पहले को घटाने के लिए छोटा होगा ?

— जोनाथन एलन

Total[Differences/@{#,Thread@#},3]&

— एलेफल्फा

1

CJam , 19 बाइट्स

0q~_z+2few:::-:+:+-

इनपुट संख्याओं की सूची की एक सूची है। इसे ऑनलाइन आज़माएं!

व्याख्या

0       e# Push 0
q~      e# Evaluated input. 
_       e# Duplicate
z       e# Zip (transpose)
+       e# Concatenate. This gives a lists of lists of numbers, where the
        e# inner lists are the original rows and the columns
2few    e# Replace each inner list of numbers by a list of overlapping
        e# slices of size 2. We not have three-level list nesting
:::-    e# Compute difference for each of those size-two slices. We now
        e# have the deltas for each row and column
:+      e# Concatenate all second-level lists (de-nest one level)
:+      e# Sum all values
-       e# Subtract from 0, to change sign. Implicitly display

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

4

इस उत्तर को अधिक कॉलोनों की आवश्यकता है। हैं 2fewकोलन।

— फल

0

MY, 9 बाइट्स

ωΔω⍉Δ ḟΣ↵

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

चूंकि मैं डेनिस को एमईआई (एक निलंबन के कारण) खींचने के लिए पिंग नहीं कर सकता, यह वर्तमान में काम नहीं करेगा। (Δ पहले घटाना नहीं था जब घटाना) जिस पर धन्यवाद करने के लिए डेनिस MY खींच लिया!

कैसे?

ωΔ, पहली कमांड लाइन तर्क की वृद्धि
ω⍉Δ, पहली कमांड लाइन तर्क के पारगमन में वृद्धि
एक सूची में
ḟ, चपटा
Σ, योग
↵, आउटपुट

— जाकारी
स्रोत

0

APL (Dyalog Classic) , 12 बाइट्स

(+/⊢⌿,⊣/)⌽-⊖

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

— NGN
स्रोत

0

पाइट , 11 बाइट्स

Đ⊤ʁ-⇹ʁ-áƑƩ~

स्पष्टीकरण:

          Implicit input (as a matrix)
Đ         Duplicate the matrix
⊤         Transpose the matrix
ʁ-        Get row deltas of transposed matrix
⇹         Swap top two elements on the stack
ʁ-        Get row deltas of original matrix
á         Push the stack into an array
Ƒ         Flatten the array
Ʃ         Sum the array
~         Flip the sign (because the deltas are negative, as subtraction was performed to obtain them)
          Implicit output

— mudkip201
स्रोत

मेरे मैट्रिक्स के डेल्टास

पृष्ठभूमि

कार्य

नियम

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

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

कैसे?

आर , 34 बाइट्स

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

स्पष्टीकरण:

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

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

प्रारूपित और टिप्पणी की गई

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

MATL , 7 बाइट्स

स्पष्टीकरण:

05AB1E , 6 बाइट्स

जे , 14 बाइट्स

व्याख्या

भूसी , 7 बाइट्स

एपीएल, 18 15 बाइट्स

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

व्याख्या

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

व्याख्या

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

व्याख्या

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

जाप -x , ११ १० ९ बाइट्स

व्याख्या

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

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

CJam , 19 बाइट्स

व्याख्या

MY, 9 बाइट्स

कैसे?

APL (Dyalog Classic) , 12 बाइट्स

पाइट , 11 बाइट्स

जाप `-x` , ११ १० ९ बाइट्स