sfondo

Il delta di una matrice di numeri interi è la matrice formata ottenendo le differenze di elementi consecutivi. Ad esempio, [1, 2, 4, 7, 3, 9, 6]ha le seguenti delta: [1, 2, 3, -4, 6, -3].

Definiremo ora i delta di una matrice di numeri interi come i delta di ogni riga e di ogni colonna che contiene.

Come esempio:

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]

Il che ci dà il seguente elenco di delta di matrici:

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

E poiché non vogliamo che vengano nidificati, appiattiamo tale elenco:

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

Compito

Il tuo compito è quello di sommare tutti i delta di una matrice fornita come input. Si noti che la matrice sarà composta solo da numeri interi non negativi.

Regole

• Si applicano tutte le regole standard.

• Puoi supporre che la matrice contenga almeno due valori su ogni riga e colonna, quindi la dimensione minima sarà 2x2 .

• Puoi prendere la matrice in qualsiasi formato ragionevole, purché lo specifichi.

• Non puoi presumere che la matrice sia quadrata.

• Se potrebbe aiutare a ridurre il numero di byte, si può opzionalmente prendere il numero di righe e il numero di colonne come input così (Guardando a voi C!).

• Questo è code-golf, quindi vince il codice più breve (in byte), in ogni lingua !

Casi test

Input => Output

[[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 byte

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

Una funzione senza nome che prende un elenco di elenchi me restituisce il numero risultante.

Provalo online!

Come?

La somma dei delta di un elenco è l'ultimo elemento meno il primo, tutto il resto si annulla:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Gli zip(*m)usi spacchettamento ( *) di mpassare le file di mcome argomenti separati da zip(interleave) e quindi traspone la matrice. In Python 2 questo produce un elenco (di tuple, ma va bene), quindi possiamo aggiungerlo (concatenarlo) a (con) m, scorrere tutte le nostre righe e colonne r, eseguire il trucco sopra per ciascuno e aggiungere solo i risultati ( sum(...)).

R , 34 byte

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

Provalo online!

Funzione anonima. Inizialmente, avevo l'abitudine apply(m,1,diff)di ottenere le differenze di riga (e 2anziché le 1colonne), ma guardando la risposta di Stewie Griffin l' ho provato solo diffe ha funzionato.

Ottava , 33 byte

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

Provalo online!

Spiegazione:

Questa è una funzione anonima che accetta xcome input. Prende la differenza tra tutte le colonne e la concatena con la differenza tra le colonne della trasposta di x. Quindi somma questo vettore lungo la seconda dimensione.

Gelatina , 5 byte

;ZIẎS

Provalo online!

Esistono anche un paio di versioni solo ASCII: ;ZIFS ;ZISS

JavaScript (ES6), 68 67 byte

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

Formattato e commentato

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

Poiché la dimensione minima della matrice di input è 2x2, m.map(...)|m[0].map(...)è garantita la forzatura 0. Ecco perché è sicuro restituire il risultato finale con |s.

Casi test

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 byte

dG!dhss

Provalo online!

Spiegazione:

Supponiamo che sia l'input

[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 byte

ø«€¥OO

Utilizza la codifica 05AB1E . Provalo online!

J , 14 byte

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

Provalo online!

Spiegazione

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

Buccia , 7 byte

ΣṁẊ-S+T

Provalo online!

-1 grazie a Mr. Xcoder prendendo la mia attenzione lontano dal Se ¤e verso la m(che dovrebbe essere rimasto ṁ).
-1 grazie a Zgarb che abusaS .

Spiegazione:

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

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

Provalo online!

Haskell , 60 byte

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

Provalo online!Utilizza la trasposizione più breve ho trovato qualche tempo fa.

Spiegazione

eè un elenco infinito di elenchi vuoti e utilizzati per la trasposizione. zè una scorciatoia per la zipWithfunzione, perché viene utilizzata due volte.

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 byte

basato originariamente sul design di @sundar

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

Spiegazione

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

il ⟨⟩ sono problemi di formattazione, mi dispiace

Provalo online!

Pyth, 7 byte

ss.+M+C

Provalo qui.

La mia prima risposta in assoluto in una lingua da golf! Grazie a @EriktheOutgolfer per -1 byte!

Spiegazione

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 byte

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

Provalo online!

(-6 byte ispirati ai suggerimenti di @ Kroppeb.)

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

cUy)®än x

Provalo

Spiegazione

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 byte

:⌡-≤H⌡-¹∑

Provalo qui! (→ aggiunto perché richiede input nello stack)

Spiegazione:

:          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 byte

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

Ingresso

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

CJam , 19 byte

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

L'input è un elenco di elenchi di numeri. Provalo online!

Spiegazione

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

MY, 9 byte

ωΔω⍉Δ ḟΣ↵

Provalo online!

Dal momento che non posso eseguire il ping di Dennis in chat per estrarre MY (a causa di una sospensione), al momento non funzionerà. (Δ precedenza non vecificava durante la sottrazione) Grazie a chiunque abbia ottenuto Dennis per tirare il MIO!

Come?

• ωΔ, incrementi del primo argomento della riga di comando
• ω⍉Δ, incrementi della trasposizione del primo argomento della riga di comando
• , in un unico elenco
• ḟ, appiattire
• Σ, somma
• ↵, produzione

APL (Dyalog Classic) , 12 byte

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

Provalo online!

Pyt , 11 byte

Đ⊤ʁ-⇹ʁ-áƑƩ~

Spiegazione:

          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