배경

정수 배열의 델타 는 연속 요소의 차이를 가져 와서 형성된 배열입니다. 예를 들어 [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 입니다.

• 매트릭스를 지정하는 한 적절한 형식으로 매트릭스를 사용할 수 있습니다.

• 당신은 하지 않을 수 있습니다 매트릭스가 정사각형이라고 가정합니다.

• 당신이 당신의 바이트 수를 줄일 수있는 경우에, 당신은 할 수있다 선택적으로 행 수와 열 수를 입력으로 취할 있습니다 (C를 바라보십시오!).

• 이것은 코드 골프이므로 각 언어 에서 가장 짧은 코드 (바이트)가 이깁니다!

테스트 사례

입력 => 출력

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

파이썬 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)압축 풀기 ( *)를 사용 m하여 행을 m별도의 인수로 전달 zip(인터리빙)하여 행렬을 전치합니다. 파이썬 2에서는 (튜플의 목록을 만들지 만 괜찮습니다), (with)에 추가 (연결)하고 m모든 행과 열을 단계별로 r수행하고 각각에 대해 위의 트릭을 수행하고 결과를 추가 할 수 있습니다 ( sum(...)).

R , 34 바이트

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

온라인으로 사용해보십시오!

익명의 기능. 원래, 나는 열 대신 apply(m,1,diff)diffs ( 열 2대신 1)를 사용했지만 Stewie Griffin의 답변을 보면서 그냥 시도해 보았습니다 diff.

옥타브 , 33 바이트

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

온라인으로 사용해보십시오!

설명:

이것은 x입력으로 사용 되는 익명 함수 입니다. 모든 열의 차이를 가져와의 옮긴 열의 차이와 연결합니다 x. 그런 다음이 벡터를 두 번째 차원을 따라 합칩니다.

젤리 , 5 바이트

;ZIẎS

온라인으로 사용해보십시오!

ASCII 전용 버전도 있습니다. ;ZIFS ;ZISS

자바 스크립트 (ES6), 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

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

05AB1E , 6 바이트

ø«€¥OO

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

J , 14 바이트

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

온라인으로 사용해보십시오!

설명

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

껍질 , 7 바이트

ΣṁẊ-S+T

온라인으로 사용해보십시오!

Xcoder 씨 가 (그리고 있어야했던 ) Sand ¤and쪽으로 향하는 내 초점을 빼앗아 주셔서 감사합니다 . Zgarb 학대 덕분에 -1mṁ
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

APL, 18 15 바이트

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

온라인으로 사용해보십시오!

하스켈 , 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

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

는 ⟨⟩죄송합니다, 서식 엉망된다

온라인으로 사용해보십시오!

Pyth, 7 바이트

ss.+M+C

여기에서 시도하십시오.

골프 언어로 내 첫 답변! -1 바이트를위한 @EriktheOutgolfer 에게 감사합니다 !

설명

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 바이트

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

온라인으로 사용해보십시오!

(@Kroppeb의 제안에서 영감을 얻은 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

apt -x , 11 10 9 바이트

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

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

Mathematica, 45 바이트

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

입력

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

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

내, 9 바이트

ωΔω⍉Δ ḟΣ↵

온라인으로 사용해보십시오!

채팅에서 Dennis를 핑 (Pink)하여 내 (정지로 인해)를 끌 수 없기 때문에 현재는 작동하지 않습니다. (Δ 이전에는 빼기 전에 징계하지 않았다) Dennis가 MY을 뽑아 준 사람에게 감사합니다!

어떻게?

• ωΔ, 첫 번째 명령 행 인수 증분
• ω⍉Δ, 첫 번째 명령 행 인수의 조옮김 증분
• 단일 목록에서
• ḟ평평하게하다
• Σ, 합계
• ↵출력

APL (Dyalog Classic) , 12 바이트

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

온라인으로 사용해보십시오!

Pyt , 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