Additionner les deltas de ma matrice

17

Contexte

Les deltas d'un tableau d'entiers sont le tableau formé en obtenant les différences d'éléments consécutifs. Par exemple, [1, 2, 4, 7, 3, 9, 6]a les deltas suivantes: [1, 2, 3, -4, 6, -3].

Nous allons maintenant définir les deltas d'une matrice d'entiers comme les deltas de chaque ligne et de chaque colonne qu'elle contient.

Par exemple:

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]

Ce qui nous donne la liste suivante de deltas matriciels:

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

Et comme nous ne voulons pas qu'ils soient imbriqués, nous aplatissons cette liste:

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

Tâche

Votre tâche consiste à additionner tous les deltas d'une matrice donnée en entrée. Notez que la matrice ne sera composée que d'entiers non négatifs.

Règles

  • Toutes les règles standard s'appliquent.

  • Vous pouvez supposer que la matrice contient au moins deux valeurs sur chaque ligne et colonne, la taille minimale sera donc 2x2 .

  • Vous pouvez prendre la matrice dans n'importe quel format raisonnable, tant que vous le spécifiez.

  • Vous ne pouvez pas supposer que la matrice est carrée.

  • Si cela peut vous aider à réduire votre nombre d'octets, vous pouvez également prendre en option le nombre de lignes et le nombre de colonnes (vous regarde C!).

  • Il s'agit de code-golf, donc le code le plus court (en octets), dans chaque langue, gagne!

Cas de test

Entrée => Sortie

[[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
code-golf  math  integer  matrix 
— M. Xcoder
source

Réponses:

12

Python 2 , 42 octets

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

Une fonction sans nom en prenant une liste de listes, met retournant le nombre résultant.

Essayez-le en ligne!

Comment?

La somme des deltas d'une liste est le dernier élément moins le premier, tout le reste annule simplement:
(r [n] -r [n-1]) + (r [n-1] -r [n-2]) + ... + (r [2] -r [1]) = r [n] -r [1]

Le zip(*m)utilise unpacking ( *) mpour passer les lignes de mcomme arguments séparés à zip(entrelacer) et donc transposer la matrice. En python 2, cela donne une liste (de tuples, mais ça va), nous pouvons donc l'ajouter (concaténer) à (avec) m, parcourir toutes nos lignes et colonnes r, effectuer l'astuce ci-dessus pour chacune et simplement additionner les résultats ( sum(...)).

— Jonathan Allan
source
8

Octave , 33 octets

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

Essayez-le en ligne!

Explication:

Il s'agit d'une fonction anonyme prenant xen entrée. Il prend la différence entre toutes les colonnes, et la concatène avec la différence entre les colonnes de la transposée de x. Il additionne ensuite ce vecteur le long de la deuxième dimension.

— Stewie Griffin
source
5

JavaScript (ES6), 68 67 octets

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

Formaté et commenté

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

Étant donné que la taille minimale de la matrice d'entrée est 2x2, il m.map(...)|m[0].map(...)est garanti d'être contraint à0 . C'est pourquoi il est sûr de retourner le résultat final avec |s.

Cas de test

Afficher l'extrait de code

— Arnauld
source
5

MATL , 7 octets

dG!dhss

Essayez-le en ligne!

Explication:

Supposons que l'entrée soit 

[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
— Stewie Griffin
source
4

J , 14 octets

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

Essayez-le en ligne!

Explication

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

Husk , 7 octets

ΣṁẊ-S+T

Essayez-le en ligne!

-1 grâce à M. Xcoder prendre mon attention loin de la Set ¤et vers la m(qui aurait dû être ṁ).
-1 grâce à Zgarb abusant S.

Explication:

ΣṁẊ-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
— Erik le Outgolfer
source
Oui, 8 octets , en utilisant ṁ.
— M. Xcoder du
8 octets également, en utilisant votre approche à la place.
— M. Xcoder du
@ Mr.Xcoder wow a oublié cela
— Erik the Outgolfer
3

Haskell , 60 octets

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

Essayez-le en ligne! Utilise la transposition plus courte que j'ai trouvée il y a quelque temps.

Explication

eest une liste infinie de listes vides et utilisée pour la transposition. zest un raccourci pour la zipWithfonction, car il est utilisé deux fois.

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
— Laikoni
source
3

Brachylog , 13 octets

basé sur la conception originale de @ sundar

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

Explication

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

le ⟨⟩formatage est foireux, désolé

Essayez-le en ligne!

— Kroppeb
source
2

Pyth, 7 octets

ss.+M+C

Essayez-le ici.

Ma toute première réponse dans une langue de golf! Merci à @EriktheOutgolfer pour -1 octet!

Explication

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;
— M. Xcoder
source
.tpeut être Cpour -1.
— Erik the Outgolfer du
@EriktheOutgolfer Oh wow, merci!
2

Brachylog , 22 16 octets

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

Essayez-le en ligne!

(-6 octets inspirés des suggestions 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
— Sundar - Rétablir Monica
source
La somme des deltas est égale au dernier élément - le premier ⟨t-h⟩fait l'affaire. Résultat dans {⟨t-h⟩ᵐ+}R&\↰₁;R+lequel est 5 octets plus court. Essayez-le en ligne!
— Kroppeb
en utilisant ⟨≡{...}ᵐ\⟩+au lieu d' {...}R&\↰₁;R+enregistrer 2 octets. Résultat: ⟨≡{⟨t-h⟩ᵐ+}ᵐ\⟩+ Essayez-le en ligne!
— Kroppeb
La modification du mappage d'une carte dans une double carte et la concaténation et la sommation au et supprime 2 octets supplémentaires ⟨≡⟨t-h⟩ᵐ²\⟩c+. Essayez-le en ligne!
— Kroppeb
@Kroppeb C'est assez différent et assez grand pour une amélioration, que vous devez l'afficher vous-même comme une nouvelle réponse. Voir vos suggestions m'a donné une idée d'une solution de 16 octets en utilisant une méthode différente ⟨≡{s₂ᶠc+ᵐ-}ᵐ\⟩+ṅ Essayez-le en ligne! , je vais donc mettre à jour cette réponse avec cette version à la place.
— sundar
2

Japt -x , 11 10 9 octets

cUy)®än x

Essayez-le

Explication

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

SOGL V0.12 , 9 octets

:⌡-≤H⌡-¹∑

Essayez-le ici! ( →ajouté car cela prend une entrée sur la pile)

Explication:

:          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
— dzaima
source
1
→ajouté parce que cela prend une entrée sur la pile - je voulais poser cette question depuis longtemps: l'entrée est-elle automatiquement poussée dans la pile? Si ce n'est pas le cas et s'attend à ce que l'entrée soit déjà présente dans la pile, ne devriez-vous pas ajouter également →votre nombre d'octets? Je ne sais pas comment ces situations sont gérées. Ou est-ce comme une fonction?
— M. Xcoder du
@ Mr.Xcoder hmm .. Je pensais que cela était autorisé par les entrées par défaut, mais je suppose qu'il n'y a que cela pour les fonctions .. Là encore, je pourrais appeler cela une fonction sans nom utilisée comme ceci (dans SOGL, la définition d'une "fonction" est functionNameSingleChar\n)
— dzaima
Oh d'accord. Il est alors parfaitement valable.
— M. Xcoder, du
1

Mathematica, 45 octets

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

Contribution

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

— J42161217
source
Serait-il plus court de soustraire le premier du dernier pour chaque tableau {#,Transpose@#}(comme ma réponse Python)?
— Jonathan Allan
Total[Differences/@{#,Thread@#},3]&
— alephalpha
1

CJam , 19 octets

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

L'entrée est une liste de listes de nombres. Essayez-le en ligne!

Explication

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
— Luis Mendo
source
4
Cette réponse a besoin de plus de deux points. Il y a des 2fewdeux points.
— Esolanging Fruit
0

MY, 9 octets

ωΔω⍉Δ ḟΣ↵

Essayez-le en ligne!

Comme je ne peux pas envoyer de ping à Dennis dans le chat pour tirer MY (en raison d'une suspension), cela ne fonctionnera pas actuellement. ( Δauparavant, il ne vérifiait pas lors de la soustraction) Merci à celui qui a amené Dennis à tirer MA!

Comment?

  • ωΔ, incréments du premier argument de ligne de commande
  • ω⍉Δ, incréments de la transposition du premier argument de ligne de commande
  • , dans une seule liste
  • ḟaplatir
  • Σ, somme
  • ↵, production
— Zacharý
source
0

Pyt , 11 octets

Đ⊤ʁ-⇹ʁ-áƑƩ~

Explication:

          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
— mudkip201
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.