Hintergrund

Das Delta eines Arrays von ganzen Zahlen ist das Array, das aus den Differenzen aufeinanderfolgender Elemente gebildet wird. Zum Beispiel [1, 2, 4, 7, 3, 9, 6]hat die folgenden Deltas: [1, 2, 3, -4, 6, -3].

Wir definieren nun die Deltas einer Ganzzahlmatrix als die Deltas jeder Zeile und jeder Spalte, die sie enthält.

Als Beispiel:

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]

Was uns die folgende Liste von Matrixdeltas gibt:

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

Und da wir nicht möchten, dass sie verschachtelt werden, reduzieren wir diese Liste:

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

Aufgabe

Ihre Aufgabe ist es, alle Deltas einer als Eingabe gegebenen Matrix zu summieren . Beachten Sie, dass die Matrix nur aus nicht negativen ganzen Zahlen besteht.

Regeln

• Es gelten alle Standardregeln.

• Sie können davon ausgehen, dass die Matrix mindestens zwei Werte in jeder Zeile und Spalte enthält, sodass die Mindestgröße 2x2 beträgt .

• Sie können die Matrix in jedem vernünftigen Format verwenden, solange Sie es angeben.

• Sie können nicht davon ausgehen, dass die Matrix quadratisch ist.

• Wenn es helfen , könnten Sie Ihre Byteanzahl reduzieren, Sie können optional die Anzahl der Zeilen nehmen und die Anzahl der Spalten als Eingabe als auch (Betrachten Sie C!).

• Das ist Code-Golf, also gewinnt der kürzeste Code (in Bytes) in jeder Sprache !

Testfälle

Eingabe => Ausgabe

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

Python 2 , 42 Bytes

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

Eine unbenannte Funktion, die eine Liste von Listen erstellt mund die resultierende Nummer zurückgibt.

Probieren Sie es online!

Wie?

Die Summe der Deltas einer Liste ist das letzte Element minus dem ersten, alles andere bricht einfach ab:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Das zip(*m)verwendet Unpacking ( *) von m, um die Zeilen von mals separate Argumente an zip(Interleave) zu übergeben und damit die Matrix zu transponieren. In Python 2 ergibt dies eine Liste (von Tupeln, aber das ist in Ordnung), so dass wir sie zu (mit) hinzufügen (verketten) m, alle unsere Zeilen und Spalten durchgehen r, den obigen Trick für jede ausführen und einfach die Ergebnisse aufaddieren können ( sum(...)).

R , 34 Bytes

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

Probieren Sie es online!

Anonyme Funktion. Ursprünglich verwendete apply(m,1,diff)ich die zeilenweisen Unterschiede (und 2nicht 1für Spalten), aber als ich Stewie Griffins Antwort ansah, versuchte ich es einfach diffund es funktionierte.

Oktave , 33 Bytes

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

Probieren Sie es online!

Erläuterung:

Dies ist eine anonyme Funktion, die xals Eingabe verwendet wird. Es nimmt den Unterschied zwischen allen Spalten und verkettet ihn mit dem Unterschied zwischen den Spalten der transponierten von x. Dieser Vektor wird dann in der zweiten Dimension summiert.

Gelee , 5 Bytes

;ZIẎS

Probieren Sie es online!

Es gibt auch einige Nur-ASCII-Versionen: ;ZIFS ;ZISS

JavaScript (ES6), 68 bis 67 Byte

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

Formatiert und kommentiert

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

Da die minimale Größe der Eingangsmatrix 2x2 ist, m.map(...)|m[0].map(...)wird garantiert dazu gezwungen 0. Deshalb ist es sicher, das Endergebnis mit zurückzugeben |s.

Testfälle

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

MATL , 7 Bytes

dG!dhss

Probieren Sie es online!

Erläuterung:

Angenommen, die Eingabe ist

[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

05AB1E , 6 Bytes

ø«€¥OO

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

J , 14 Bytes

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

Probieren Sie es online!

Erläuterung

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

Schale , 7 Bytes

ΣṁẊ-S+T

Probieren Sie es online!

-1 dank Mr. Xcoder weg meinen Fokus nimmt von der Sund ¤und in Richtung der m(die sollte war ṁ).
-1 dank Zgarb MissbrauchS .

Erläuterung:

ΣṁẊ-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

APL, 18-15 Bytes

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

Probieren Sie es online!

Haskell , 60 Bytes

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

Probieren Sie es online! Verwendet die kürzere Transponierte, die ich vor einiger Zeit gefunden habe.

Erläuterung

eist eine unendliche Liste von leeren Listen, die zum Transponieren verwendet werden. zist eine Abkürzung für die zipWithFunktion, da sie zweimal verwendet wird.

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

Brachylog , 13 Bytes

ursprünglich basierend auf @ sundar's design

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

Erläuterung

⟨≡      \⟩          #   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)

Die ⟨⟩Formatierung ist durcheinander, sorry

Probieren Sie es online!

Pyth, 7 Bytes

ss.+M+C

Probieren Sie es hier aus.

Meine allererste Antwort in einer Golfsprache! Vielen Dank an @EriktheOutgolfer für -1 Byte!

Erläuterung

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;

Brachylog , 22 16 Bytes

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

Probieren Sie es online!

(-6 Bytes, inspiriert von @ Kroppebs Vorschlägen.)

?⟨≡{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

Japt -x , 11 10 9 Bytes

cUy)®än x

Versuch es

Erläuterung

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

SOGL V0.12 , 9 Bytes

:⌡-≤H⌡-¹∑

Probieren Sie es hier aus! ( →hinzugefügt, da dies Eingaben auf dem Stapel nimmt)

Erläuterung:

:          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

Mathematica, 45 Bytes

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

Eingang

[{{13, 19, 478}, {0, 12, 4}, {45, 3, 6}, {1, 2, 3}}]

CJam , 19 Bytes

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

Die Eingabe ist eine Liste von Nummernlisten. Probieren Sie es online!

Erläuterung

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

MEIN, 9 Bytes

ωΔω⍉Δ ḟΣ↵

Probieren Sie es online!

Da ich Dennis im Chat nicht anpingen kann, um MEINEN zu ziehen (aufgrund einer Aussetzung), wird dies derzeit nicht funktionieren. ( ΔBisher nicht beim Subtrahieren angegeben) Dank an denjenigen, der Dennis zum Ziehen von MY!

Wie?

• ωΔInkremente des ersten Befehlszeilenarguments
• ω⍉ΔInkremente der Transponierung des ersten Befehlszeilenarguments
• in einer einzigen Liste
• ḟ, ebnen
• Σ, Summe
• ↵, Ausgabe

APL (Dyalog Classic) , 12 Byte

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

Probieren Sie es online!

Pyt , 11 Bytes

Đ⊤ʁ-⇹ʁ-áƑƩ~

Erläuterung:

          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