Lý lịch

Các đồng bằng của một mảng các số nguyên là mảng được hình thành bằng cách nhận được sự khác biệt của các phần tử liên tiếp. Ví dụ: [1, 2, 4, 7, 3, 9, 6]có các đồng bằng sau : [1, 2, 3, -4, 6, -3].

Bây giờ chúng ta sẽ định nghĩa các deltas của một ma trận các số nguyên là các deltas của mỗi hàng và mỗi cột chứa nó.

Ví dụ:

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]

Cung cấp cho chúng tôi danh sách các ma trận sau:

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

Và vì chúng tôi không muốn chúng được lồng vào nhau, chúng tôi sẽ san phẳng danh sách đó:

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

Bài tập

Nhiệm vụ của bạn là tổng hợp tất cả các vùng đồng bằng của một ma trận được đưa ra làm đầu vào. Lưu ý rằng ma trận sẽ chỉ bao gồm các số nguyên không âm.

Quy tắc

• Tất cả các quy tắc tiêu chuẩn được áp dụng.

• Bạn có thể giả sử ma trận chứa ít nhất hai giá trị trên mỗi hàng và cột, vì vậy kích thước tối thiểu sẽ là 2x2 .

• Bạn có thể lấy ma trận ở bất kỳ định dạng hợp lý nào, miễn là bạn chỉ định nó.

• Bạn có thể không cho rằng ma trận là hình vuông.

• Nếu nó có thể giúp bạn giảm số byte của bạn, bạn có thể tùy ý lấy số lượng hàng và số lượng cột làm đầu vào (Nhìn vào bạn C!).

• Đây là mã golf, vì vậy mã ngắn nhất (tính bằng byte), trong mỗi ngôn ngữ sẽ thắng!

Các trường hợp thử nghiệm

Đầu vào => Đầu ra

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

Một hàm không tên lấy danh sách các danh sách mvà trả về số kết quả.

Hãy thử trực tuyến!

Làm sao?

Tổng số deltas của danh sách là phần tử cuối cùng trừ phần đầu tiên, mọi thứ khác chỉ cần hủy:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Việc zip(*m)sử dụng giải nén ( *) của mđể chuyển các hàng mdưới dạng đối số riêng biệt sang zip(xen kẽ) và do đó hoán chuyển ma trận. Trong python 2, điều này mang lại một danh sách (các bộ dữ liệu, nhưng điều đó tốt), vì vậy chúng ta có thể thêm (nối) nó với (với) m, bước qua tất cả các hàng và cột của chúng tôi r, thực hiện thủ thuật trên cho mỗi và chỉ cần thêm kết quả ( sum(...)).

R , 34 byte

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

Hãy thử trực tuyến!

Chức năng ẩn danh. Ban đầu, tôi thường sử dụng apply(m,1,diff)các khác biệt theo hàng (và 2thay vì 1cho các cột) nhưng nhìn vào câu trả lời của Stewie Griffin, tôi đã thử nó chỉ diffvà nó hoạt động.

Octave , 33 byte

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

Hãy thử trực tuyến!

Giải trình:

Đây là một chức năng ẩn danh lấy xlàm đầu vào. Nó lấy sự khác biệt giữa tất cả các cột và nối nó với sự khác biệt giữa các cột được hoán vị x. Sau đó, nó tính tổng vector này dọc theo chiều thứ hai.

Thạch , 5 byte

;ZIẎS

Hãy thử trực tuyến!

Có một vài phiên bản chỉ 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

Định dạng và nhận xét

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

Bởi vì kích thước tối thiểu của ma trận đầu vào là 2x2, m.map(...)|m[0].map(...)được đảm bảo sẽ bị ép buộc 0. Đó là lý do tại sao nó an toàn để trả về kết quả cuối cùng với |s.

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến!

Giải trình:

Giả sử đầu vào là

[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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

J , 14 byte

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

Hãy thử trực tuyến!

Giải trình

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

Husk , 7 byte

ΣṁẊ-S+T

Hãy thử trực tuyến!

-1 nhờ ông Xcoder dùng tập trung của tôi ra khỏi Svà ¤và hướng tới m(mà nên đã ṁ).
-1 nhờ lạm dụng ZgarbS .

Giải trình:

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

Hãy thử trực tuyến!

Haskell , 60 byte

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

Hãy thử trực tuyến! Sử dụng chuyển vị ngắn hơn tôi tìm thấy một thời gian trước đây.

Giải trình

elà một danh sách vô hạn các danh sách trống và được sử dụng để chuyển vị. zlà một tốc ký cho zipWithhàm, bởi vì nó được sử dụng hai lần.

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

dựa trên thiết kế của @ sundar

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

Giải trình

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

các ⟨⟩ đang rối tung lên định dạng, xin lỗi

Hãy thử trực tuyến!

Bình thường, 7 byte

ss.+M+C

Hãy thử nó ở đây.

Câu trả lời đầu tiên của tôi trong một ngôn ngữ chơi golf! Cảm ơn @EriktheOutgolfer cho -1 byte!

Giải trình

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

Hãy thử trực tuyến!

(-6 byte lấy cảm hứng từ đề xuất của @ 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

Thử nó

Giải trình

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

Hãy thử nó ở đây! ( →được thêm vào vì điều này mất đầu vào trên ngăn xếp)

Giải trình:

:          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

Toán học, 45 byte

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

Đầu vào

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

Camam , 19 byte

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

Đầu vào là một danh sách các danh sách các số. Hãy thử trực tuyến!

Giải trình

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

TÔI, 9 byte

ωΔω⍉Δ ḟΣ↵

Hãy thử trực tuyến!

Vì tôi không thể ping Dennis trong trò chuyện để kéo MY (do bị đình chỉ), nên hiện tại nó sẽ không hoạt động. (Δ trước đây không vecify khi trừ) Nhờ ai đó đã giúp Dennis kéo MY!

Làm sao?

• ωΔ, gia số của đối số dòng lệnh đầu tiên
• ω⍉Δ, gia tăng chuyển vị của đối số dòng lệnh đầu tiên
• , trong một danh sách
• ḟ, làm phẳng
• Σ, Tổng
• ↵, đầu ra

APL (Dyalog Classic) , 12 byte

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

Hãy thử trực tuyến!

Pyt , 11 byte

Đ⊤ʁ-⇹ʁ-áƑƩ~

Giải trình:

          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