Suma los deltas de mi matriz


17

Antecedentes

Los deltas de una matriz de enteros son la matriz formada al obtener las diferencias de elementos consecutivos. Por ejemplo, [1, 2, 4, 7, 3, 9, 6]tiene las siguientes deltas: [1, 2, 3, -4, 6, -3].

Ahora definiremos los deltas de una matriz de enteros como los deltas de cada fila y cada columna que contiene.

Como ejemplo:

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]

Lo que nos da la siguiente lista de deltas matriciales:

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

Y como no queremos que estén anidados, aplanamos esa lista:

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

Tarea

Su tarea es sumar todos los deltas de una matriz dada como entrada. Tenga en cuenta que la matriz solo consistirá en enteros no negativos.

Reglas

  • Se aplican todas las reglas estándar.

  • Puede suponer que la matriz contiene al menos dos valores en cada fila y columna, por lo que el tamaño mínimo será 2x2 .

  • Puede tomar la matriz en cualquier formato razonable, siempre que la especifique.

  • No puede suponer que la matriz es cuadrada.

  • Si puede ayudarlo a reducir su recuento de bytes, también puede tomar el número de filas y el número de columnas como entrada (¡Mirándolo C!).

  • Este es el código de golf, por lo que gana el código más corto (en bytes) en cada idioma .

Casos de prueba

Entrada => Salida

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

Respuestas:


12

Python 2 , 42 bytes

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

Una función sin nombre que toma una lista de listas my devuelve el número resultante.

Pruébalo en línea!

¿Cómo?

La suma de los deltas de una lista es el último elemento menos el primero, todo lo demás simplemente cancela:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Los zip(*m)usos desembalaje ( *) de mpasar a las filas de mcomo argumentos distintos zip(de intercalación) y por lo tanto transpone la matriz. En python 2, esto produce una lista (de tuplas, pero está bien), por lo que podemos agregar (concatenar) a (con) m, recorrer todas nuestras filas y columnas r, realizar el truco anterior para cada uno y simplemente sumar los resultados ( sum(...))



8

Octava , 33 bytes

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

Pruébalo en línea!

Explicación:

Esta es una función anónima que toma xcomo entrada. Toma la diferencia entre todas las columnas y la concatena con la diferencia entre las columnas de la transpuesta de x. Luego suma este vector a lo largo de la segunda dimensión.



5

JavaScript (ES6), 68 67 bytes

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

Formateado y comentado

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

Debido a que el tamaño mínimo de la matriz de entrada es 2x2, m.map(...)|m[0].map(...)se garantiza que se coaccionará 0. Por eso es seguro devolver el resultado final con|s .

Casos de prueba


5

MATL , 7 bytes

dG!dhss

Pruébalo en línea!

Explicación:

Supongamos que la entrada es

[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


4

J , 14 bytes

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

Pruébalo en línea!

Explicación

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

3

Casco , 7 bytes

ΣṁẊ-S+T

Pruébalo en línea!

-1 gracias al Sr. Xcoder tomando mi atención lejos de la Sy ¤, y hacia el m(que debería haber sido ).
-1 gracias al abuso de ZgarbS .

Explicación:

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

Sí, 8 bytes , usando .
Sr. Xcoder

8 bytes también, usando su enfoque en su lugar.
Sr. Xcoder

@ Mr.Xcoder wow se olvidó de eso
Erik the Outgolfer


3

Haskell , 60 bytes

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

Pruébalo en línea! Utiliza la transposición más corta que encontré hace un tiempo.

Explicación

ees una lista infinita de listas vacías y se utiliza para la transposición. zes una abreviatura de la zipWithfunción, porque se usa dos veces.

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

3

Brachylog , 13 bytes

Originalmente basado en el diseño @ sundar

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

Explicación

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

el ⟨⟩ están arruinando el formato, lo siento

Pruébalo en línea!


2

Pyth, 7 bytes

ss.+M+C

Pruébalo aquí

¡Mi primera respuesta en un idioma de golf! Gracias a @EriktheOutgolfer por -1 byte!

Explicación

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;

.tpuede ser Cpara -1.
Erik the Outgolfer

@EriktheOutgolfer Oh wow, gracias!

2

Brachylog , 22 16 bytes

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

Pruébalo en línea!

(-6 bytes inspirados en las sugerencias de @ 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

La suma de los deltas es igual al último elemento: el primero ⟨t-h⟩hace el truco. Resultando en {⟨t-h⟩ᵐ+}R&\↰₁;R+que es 5 bytes más corto. Pruébalo en línea!
Kroppeb

usando en ⟨≡{...}ᵐ\⟩+lugar de {...}R&\↰₁;R+guardar 2 bytes. Resultando en ¡ ⟨≡{⟨t-h⟩ᵐ+}ᵐ\⟩+ Pruébelo en línea!
Kroppeb

Cambiar la asignación de un mapa en un mapa doble y concatenar y somming en el y elimina 2 bytes adicionales ⟨≡⟨t-h⟩ᵐ²\⟩c+. Pruébalo en línea!
Kroppeb

@Kroppeb Es una mejora lo suficientemente diferente y lo suficientemente grande como para publicarla usted mismo como una nueva respuesta. Ver sus sugerencias me dio una idea para una solución de 16 bytes usando un método diferente ¡ ⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ Pruébelo en línea! , así que actualizaré esta respuesta con esa versión en su lugar.
sundar - Restablece a Mónica el

2

Japt -x , 11 10 9 bytes

cUy)®än x

Intentalo


Explicación

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

1

SOGL V0.12 , 9 bytes

:⌡-≤H⌡-¹∑

Pruébalo aquí! ( agregado porque esto toma entrada en la pila)

Explicación:

:          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

1
agregado porque esto toma entrada en la pila . He querido preguntar esto durante mucho tiempo: ¿la entrada se envía automáticamente a la pila? Si no lo es, y espera que la entrada ya esté presente en la pila, ¿no debería agregar también su conteo de bytes? No estoy seguro de cómo se manejan estas situaciones. ¿O es como una función?
Sr. Xcoder

@ Mr.Xcoder hmm ... pensé que estaba permitido por las entradas predeterminadas, pero supongo que solo hay esto para las funciones ... Por otra parte, podría llamar a esto una función sin nombre utilizada como esta (en SOGL la definición de una "función" es functionNameSingleChar\n)
dzaima

Oh esta bien. Es perfectamente válido entonces.
Sr. Xcoder

1

Mathematica, 45 bytes

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

Entrada

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


¿Sería más corto restar el primero del último para cada matriz en {#,Transpose@#}(como mi respuesta de Python)?
Jonathan Allan

Total[Differences/@{#,Thread@#},3]&
alephalpha

1

CJam , 19 bytes

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

La entrada es una lista de listas de números. Pruébalo en línea!

Explicación

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

44
Esta respuesta necesita más dos puntos. Hay 2fewdos puntos
Esolanging Fruit

0

MI, 9 bytes

ωΔω⍉Δ ḟΣ↵

Pruébalo en línea!

Como no puedo hacer ping a Dennis en el chat para extraer MY (debido a una suspensión), actualmente no funcionará. (Δ anteriormente no vecificaba al restar) ¡ Gracias a quien consiguió que Dennis tirara de MI!

¿Cómo?

  • ωΔ, incrementos del primer argumento de línea de comando
  • ω⍉Δ, incrementos de la transposición del primer argumento de línea de comando
  • , en una sola lista
  • aplanar
  • Σsuma
  • , salida


0

Pyt , 11 bytes

Đ⊤ʁ-⇹ʁ-áƑƩ~

Explicación:

          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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.