Latar Belakang

Delta array integer adalah array yang dibentuk dengan mendapatkan perbedaan elemen berurutan. Misalnya, [1, 2, 4, 7, 3, 9, 6]memiliki delta berikut: [1, 2, 3, -4, 6, -3].

Kami sekarang akan mendefinisikan delta dari matriks bilangan bulat sebagai delta dari setiap baris dan setiap kolom yang dikandungnya.

Sebagai contoh:

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]

Yang memberi kami daftar delta matriks berikut:

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

Dan karena kami tidak ingin mereka disarangkan, kami meratakan daftar itu:

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

Tugas

Tugas Anda adalah untuk menjumlahkan semua delta dari matriks yang diberikan sebagai input. Perhatikan bahwa matriks hanya akan terdiri dari bilangan bulat non-negatif.

Aturan

• Semua aturan standar berlaku.

• Anda dapat mengasumsikan matriks berisi setidaknya dua nilai pada setiap baris dan kolom, sehingga ukuran minimum akan 2x2 .

• Anda dapat mengambil matriks dalam format yang masuk akal, selama Anda menentukannya.

• Anda mungkin tidak berasumsi bahwa matriksnya adalah persegi.

• Jika mungkin membantu Anda mengurangi jumlah byte Anda, Anda dapat juga mengambil jumlah baris dan jumlah kolom sebagai input (Melihat Anda C!).

• Ini adalah kode-golf, jadi kode terpendek (dalam byte), dalam setiap bahasa menang!

Uji Kasus

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))

Fungsi yang tidak disebutkan namanya mengambil daftar daftar m,, dan mengembalikan nomor yang dihasilkan.

Cobalah online!

Bagaimana?

Jumlah dari delta daftar adalah elemen terakhir minus yang pertama, yang lainnya hanya membatalkan:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

The zip(*m)penggunaan membongkar ( *) dari mmelewati deretan msebagai argumen terpisah untuk zip(interleave) dan karenanya transposes matriks. Dalam python 2 ini menghasilkan daftar (dari tupel, tapi tidak apa-apa), jadi kita dapat menambahkan (menyatukan) ke (dengan) m, menelusuri semua baris dan kolom kita r, melakukan trik di atas untuk masing-masing dan hanya menambahkan hasilnya ( sum(...)).

R , 34 byte

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

Cobalah online!

Fungsi anonim. Awalnya, saya digunakan apply(m,1,diff)untuk mendapatkan perbedaan baris (dan 2bukannya 1untuk kolom) tetapi melihat jawaban Stewie Griffin, saya mencobanya dengan adil diffdan berhasil.

Oktaf , 33 byte

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

Cobalah online!

Penjelasan:

Ini adalah fungsi anonim xsebagai input. Dibutuhkan perbedaan antara semua kolom, dan menyatukannya dengan perbedaan antara kolom yang ditranskripsikan x. Ini kemudian menjumlahkan vektor ini sepanjang dimensi kedua.

Jelly , 5 byte

;ZIẎS

Cobalah online!

Ada juga beberapa versi ASCII saja: ;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

Diformat dan dikomentari

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

Karena ukuran minimum dari matriks input adalah 2x2, m.map(...)|m[0].map(...)dijamin akan dipaksa 0. Itu sebabnya aman untuk mengembalikan hasil akhir |s.

Uji kasus

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

Cobalah online!

Penjelasan:

Misalkan inputnya adalah

[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

Menggunakan penyandian 05AB1E . Cobalah online!

J , 14 byte

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

Cobalah online!

Penjelasan

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

Sekam , 7 byte

ΣṁẊ-S+T

Cobalah online!

-1 berkat Mr. Xcoder mengambil fokus saya jauh dari Sdan ¤dan menuju m(yang seharusnya sudah ṁ).
-1 berkat Zgarb menyalahgunakanS .

Penjelasan:

ΣṁẊ-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-/¨⍵(⍉⍵)}

Cobalah online!

Haskell , 60 byte

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

Cobalah online! Menggunakan transpos pendek yang saya temukan beberapa waktu lalu.

Penjelasan

eadalah daftar kosong yang tak terbatas dan digunakan untuk transposing. zadalah singkatan untuk zipWithfungsi, karena digunakan dua kali.

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

berdasarkan aslinya dari desain @ sundar

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

Penjelasan

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

yang ⟨⟩sedang mengacaukan format, maaf

Cobalah online!

Pyth, 7 byte

ss.+M+C

Coba di sini.

Jawaban pertama saya dalam bahasa golf! Terima kasih kepada @EriktheOutgolfer untuk -1 byte!

Penjelasan

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+ᵐ-}ᵐ\⟩+ṅ

Cobalah online!

(-6 byte terinspirasi oleh saran @ 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

Cobalah

Penjelasan

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⌡-¹∑

Coba Di Sini! ( →ditambahkan karena ini membutuhkan input dari stack)

Penjelasan:

:          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@#}]&

Memasukkan

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

CJam , 19 byte

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

Input adalah daftar daftar angka. Cobalah online!

Penjelasan

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

ωΔω⍉Δ ḟΣ↵

Cobalah online!

Karena saya tidak dapat mem-ping Dennis dalam obrolan untuk menarik MY (karena penangguhan), saat ini tidak akan berfungsi. (Δ sebelumnya tidak memverifikasi saat mengurangkan) Terima kasih kepada siapa pun yang membuat Dennis menarik MY!

Bagaimana?

• ωΔ, penambahan argumen baris perintah pertama
• ω⍉Δ, penambahan transpos argumen baris perintah pertama
• , dalam satu daftar
• ḟ, ratakan
• Σ, jumlah
• ↵, keluaran

APL (Dyalog Classic) , 12 byte

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

Cobalah online!

Pyt , 11 byte

Đ⊤ʁ-⇹ʁ-áƑƩ~

Penjelasan:

          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