Somma della prima riga e colonna, quindi della seconda riga e colonna ... e così via

31

Prendi come input una matrice / matrice numerica non vuota contenente numeri interi positivi. Restituisci, in questo ordine, le somme della prima riga e colonna, quindi della seconda riga e colonna e continua fino a quando non ci sono più righe o colonne.

Supponiamo che l'input sia:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

Quindi l'output dovrebbe essere:

45, 33, 16, 17

Perché: 2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17.

Casi test:

I casi di test sono nel seguente formato:

Input
---
Output


5
---
5
..........

1  4
----
5
..........

7
2
---
9
..........

 8    3    7   10    3    7   10    1
10    7    5    8    4    3    3    1
 1    6    4    1    3    6   10    1
 2    3    8    2    8    3    4    1
---
62   40   33   18
..........

30    39    48     1    10    19    28
38    47     7     9    18    27    29
46     6     8    17    26    35    37
 5    14    16    25    34    36    45
13    15    24    33    42    44     4
21    23    32    41    43     3    12
22    31    40    49     2    11    20
---
320  226   235   263   135    26    20
..........

7   10    1
4    4    2
6    3    4
1    4   10
5    7    6
---
34   20   20

Come matrici:

[[5]]
[[1,4]]
[[7],[2]]
[[8,3,7,10,3,7,10,1],[10,7,5,8,4,3,3,1],[1,6,4,1,3,6,10,1],[2,3,8,2,8,3,4,1]]
[[30,39,48,1,10,19,28],[38,47,7,9,18,27,29],[46,6,8,17,26,35,37],[5,14,16,25,34,36,45],[13,15,24,33,42,44,4],[21,23,32,41,43,3,12],[22,31,40,49,2,11,20]]
[[7,10,1],[4,4,2],[6,3,4],[1,4,10],[5,7,6]]

Questo è code-golf, quindi vince la soluzione più breve in ogni lingua.

code-golf  math  matrix 
— Stewie Griffin
fonte
2
@JonathanAllan, stampare gli zeri per sempre è un po 'allungato, quindi penso di dover dire di no a quello.
— Stewie Griffin,
1
Programma Retina per convertire da graziosi esempi ad array Python.
— mbomb007,
1
Guardando gli esempi. la descrizione dell'attività è errata. La seconda colonna nel primo esempio è 10,7,7,1, la seconda riga è 9,7,7,2,9e la somma è 59. E così via
— edc65
1
@ edc65 Guardando gli esempi, sembra che i numeri utilizzati nei calcoli precedenti non vengano riutilizzati. O in un altro modo, quando si considera l'ennesima riga, utilizzare solo i valori dall'ennesima colonna in poi e ignorare quelli nelle colonne da 1 a n-1.
— Brian J,
1
@ Arc676 Regole io standard. Gli argomenti di funzione sono uno dei metodi di input accettati.
— Stewie Griffin,

Risposte:

10

MATL , 16 byte

&n:w:!XlX:GX:1XQ

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera, ad esempio, l'input 

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

Il codice &n:w:!Xlcrea il vettore di colonna [1; 2; 3; 4]e il vettore di riga [1 2 3 4 5]. Quindi Xlcalcola il minimo elemento-saggio con broadcast, che dà la matrice

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

X:linearizza questa matrice (in ordine di colonna maggiore) nel vettore colonna [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Questo vettore e la matrice di input linearizzata, ottenuta come GX:, vengono passati come input alla accumarray(... @sum)funzione, o 1XQ. Questo calcola la somma del secondo input raggruppata per i valori del primo input.

— Luis Mendo
fonte
5

CJam , 23 18 byte

{[{(:+\z}h;]2/::+}

Blocco anonimo in attesa dell'argomento nello stack e lasciando il risultato nello stack.

Provalo online!

Spiegazione

[      e# Begin working in an array.
 {     e#  Do:
  (:+  e#   Remove the first row of the matrix and sum it.
  \z   e#   Bring the matrix back to the top and transpose it.
 }h    e#  While the matrix is non-empty.
 ;     e#  Discard the remaining empty matrix.
]      e# Close the array.
2/     e# Split it into consecutive pairs of elements (possibly with a singleton on the end).
::+    e# Sum each pair.
— Gatto di affari
fonte
Non è un po '"barare"? Voglio dire, non stai contando il codice di input e output nel conteggio dei byte. Con input e output è solo 1 byte più lungo:q~[{(:+\z}h;]2/::+p
— FrodCube,
@FrodCube È consentito dal meta consenso .
— Business Cat,
2
In realtà, tecnicamente, sarebbe la stessa lunghezza di un programma completo, poiché potrei omettere l'apertura [. Ma come blocco penso di averne bisogno perché non deve catturare anche l'intero stack sottostante.
— Business Cat,
5

05AB1E , 14 11 byte

[ćOˆøŽ]¯2ôO

Provalo online!

Spiegazione

[   Ž ]       # loop until stack is empty
 ć            # extract the head
  Oˆ          # sum and add to global list
     ø        # transpose
       ¯      # push global list
        2ô    # split into pairs
          O   # sum each pair
— Emigna
fonte
4

JavaScript (ES6), 60 byte

a=>a.map((b,y)=>b.map((c,x)=>r[x=x<y?x:y]=~~r[x]+c),r=[])&&r

Soluzione ingenua, potrebbe essere un modo migliore.

— ETHproductions
fonte
4

Mathematica, 60 byte

Ispirato dalla risposta MATL di Luis Mendo .

Pick[#,Min~Array~d,n]~Total~2~Table~{n,Min[d=Dimensions@#]}&

Spiegazione: Min~Array~Dimensions@#costruisce una matrice come la seguente:

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

Quindi Pick[#,...,n]~Total~2seleziona le voci della matrice di input corrispondenti al numero nnella strana matrice sopra e le somma. Finalmente si ...~Table~{n,Min[d=Dimensions@#]}ripete n.

Questo è 1 byte più corto dell'approccio ingenuo:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&
— Non un albero
fonte
4

Haskell, 50 49 byte

f(a@(_:_):b)=sum(a++map(!!0)b):f(tail<$>b)
f _=[]

Provalo online!

Se c'è almeno una riga con almeno un elemento, il risultato è la somma della prima riga e delle intestazioni di tutte le altre righe seguite da una chiamata ricorsiva con le code di tutte le altre righe. In tutti gli altri casi, il risultato è l'elenco vuoto.

Modifica: Ørjan Johansen ha salvato un byte. Grazie!

— Nome del modello
fonte
4

Ottava , 64 52 byte

Grazie a @StewieGriffin per aver salvato 1 byte!

@(x)accumarray(min((1:size(x))',1:rows(x'))(:),x(:))

Questo definisce una funzione anonima.

Provalo online!

Spiegazione

Il codice è simile alla mia risposta MATL (vedi spiegazione lì).

Due byte sono stati salvati usando 1:size(x)invece di 1:size(x,1), sfruttando il fatto che 1:[a b]si comporta come 1:a. Inoltre, è stato salvato un byte usando 1:rows(x')invece di 1:size(x,2), grazie a Stewie.

— Luis Mendo
fonte
3

k, 19 byte

|1_-':|+//'(1_+1_)\

Provalo online!

Spiegazione:

           (1_+1_)   /a function that strips the top and leftmost rows of a matrix
                  \  /apply this function as many times as possible,
                     /    saving each result as one element of a list
       +//'          /for each result, get the sum of all numbers
|  -':|              /subtract every right value from every left value
 1_                  /remove the extra 0
— zgrep
fonte
3

05AB1E , 16 byte

[ćOsø.g<NQ#])2ôO

Provalo online! oppure prova tutti i test

[                # Start loop
 ć               # Extract first element
  O              # Sum
   sø            # Transpose the input array (without the first N rows and columns)
     .g<NQ       # Push if (stack height - 1 == loop count)
          #]     # If they were equal break
            )2ô  # Break stack into chunks of 2
               O # Sum the chunks
— Riley
fonte
3

Ottava , 63 60 byte

@(A)(@(L)sum(triu(A,1)')(L)+sum(tril(A))(L))(1:min(size(A)))

Provalo online!

La risposta per questa matrice:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

è il vettore delle somme di riga della sua parte triangolare superiore:

0   10   10    2    4
0    0    7    2    9
0    0    0    2    4
0    0    0    0    9

più il vettore delle somme di colonna della sua parte triangolare inferiore:

2    0    0    0    0
9    7    0    0    0
1    7    6    0    0
7    1    4    8    0

che è esattamente ciò che la mia risposta è informatica.

— eush77
fonte
2

Julia , 62 byte

f=x->1∈size(x)?sum(x):(n=f(x[2:end,2:end]);[sum(x)-sum(n);n])

Funziona in modo ricorsivo riassumendo l'intera matrice e quindi sottraendo la somma del blocco successivo. Probabilmente non è l'approccio più efficace, ma ben intuitivo.

— Julian Wolf
fonte
2

Java 7, 248 byte

String c(int[][]a){int l=a.length,L=a[0].length,b[][]=new int[l][L],i,j,x=1,s;for(;x<(l>L?l:L);x++)for(i=l;i-->x;)for(j=L;j-->x;b[i][j]=x);String r="";for(;x-->0;r=s>0?s+" "+r:r)for(s=0,i=0;i<l;i++)for(j=0;j<L;j++)s+=b[i][j]==x?a[i][j]:0;return r;}

Provalo qui.

Spiegazione generale:

Supponiamo che l'array di input abbia dimensioni di 4x6. La prima parte del codice creerà una matrice temporanea e la riempirà come segue:

// 1. Fill the entire array with 0:
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

// 2. Overwrite the inner part with 1 (excluding the first row & column):
0 0 0 0 0 0
0 1 1 1 1 1
0 1 1 1 1 1
0 1 1 1 1 1

// #. Etc. until we are left with this:
0 0 0 0 0 0
0 1 1 1 1 1
0 1 2 2 2 2
0 1 2 3 3 3

E nella seconda parte del codice passerà sopra questa matrice temporanea e sommerà tutti i valori della matrice di input per ciascuno dei numeri distinti nella matrice temporanea.

Spiegazione del codice:

String c(int[][]a){               // Method with int-matrix parameter and String return-type
  int l=a.length,                 //  Amount of rows
      L=a[0].length,              //  Amount of columns
      b[][]=new int[l][L],        //  New temp matrix to fill as explained above
      i,j,x=1,s;                  //  Some temp integers

                                  //This is the first part of the code mentioned above:
  for(;x<(l>L?l:L);x++)           //  Loop (1) over the rows or columns (whichever is highest)
    for(i=l;i-->x;)               //   Inner loop (2) over the rows
      for(j=L;j-->x;              //    Inner loop (3) over the columns
        b[i][j]=x);               //     Set the current `x`-number
                                  //    End of loop (3) (implicit / no body)
                                  //   End of loop (2) (implicit / single-line body)
                                  //  End of loop (1) (implicit / single-line body)

                                  //This is the second part of the code mentioned above:
  String r="";                    //  Result-String
  for(;x-->0;                     //  Loop (4) over the unique numbers in the temp matrix
             r=s>0?s+" "+r:r)     //   After every iteration, append the sum to the result (if it's larger than 0)
    for(s=0,i=0;i<l;i++)          //   Inner loop (5) over the rows (and reset the sum to 0)
      for(j=0;j<L;j++)            //    Inner loop (6) over the columns
        s+=b[i][j]==x?a[i][j]:0;  //     Add to the sum if its position equals the current `x` in the temp matrix
                                  //    End of loop (6) (implicit / single-line body)
                                  //   End of loop (5) (implicit / single-line body)
                                  //  End of loop (4) (implicit / single-line body)
  return r;                       //  Return the result-String
}                                 // End of method
— Kevin Cruijssen
fonte
2

Perl 6 , 63 55 byte

{($_ Z [Z] $_).kv.map(->\a,\b{b.flatmap(*[a..*]).sum -b[0;a]})}

{($_ Z [Z] .skip).kv.map({$^b.flatmap(*[$^a..*]).sum})}
  • $_ è l'input della matrice per la funzione anonima
  • .skip è la matrice di input con la sua prima riga rimossa
  • [Z] .skipè la trasposizione della matrice di input con la sua prima riga rimossa; cioè, la trasposizione senza la sua prima colonna
  • $_ Z [Z] .skip comprime la matrice di input con la sua colonna transpose-sans-first, producendo un elenco ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
  • .kv prefissa ogni coppia con il suo indice
  • map({...})mappa sulle coppie, usando una funzione che accetta il suo primo argomento (l'indice) in $^ae il suo secondo (la coppia riga / colonna) in$^b
  • $^b.flatmap(*[$^a..*]).sumelimina i primi $^aelementi di ciascuna coppia riga / colonna, quindi somma tutti gli elementi rimanenti

Dopo aver pensato, mi sono reso conto che togliere la prima colonna della trasposizione prima di zippare equivaleva a sottrarre gli elementi diagonali che contribuivano doppiamente, come nella mia prima soluzione. Ciò mi ha permesso di eliminare quella sottrazione e di utilizzare ogni argomento per la funzione di mappatura una volta sola ha reso il {...$^a...$^b...}metodo di passaggio degli argomenti a una funzione anonima più efficiente dell'originale -> \a, \b {...a...b...}.

— Sean
fonte
1

Vim, 66 , 52 byte

qq^f j<C-v>}dkV}Jo<esc>p@qq@q:%s/\v> +</+/g|%norm C<C-v><C-r>=<C-v><C-r>"<C-v><cr><cr>

Provalo online!

Lo strumento sbagliato per il lavoro ...

— DJMcMayhem
fonte
1

Gelatina , 10 byte

Ḣ;Ḣ€SṄȧßS¿

Un programma completo che stampa i valori

Provalo online!

Come?

Ḣ;Ḣ€SṄȧßF¿ - Main link: list of lists a
Ḣ          - head a (pop the first row and yield it, modifying a)
  Ḣ€       - head €ach (do the same for each of the remaining rows)
 ;         - concatenate
    S      - sum (adds up the list that contains the top row and left column)
     Ṅ     - print that plus a linefeed and yield the result
         ¿ - while:
           - ... condition:
        F  -   flatten (a list of empty lists flattens to an empty list which is falsey) 
           - ... body:
       ß   -   call this link with the same arity (as a monad) i.e. Main(modified a)
      ȧ    - logical and (when the sum is non-zero gets the modified a to feed back in)
— Jonathan Allan
fonte
1

Python + NumPy, 75 byte

L'input è una matrice numpy 2D.

lambda L:[sum(L[i,i:])+sum(L[i+1:,i])for i in range(min(len(L),len(L[0])))]

Provalo online

— mbomb007
fonte
1

Pyth, 16 15 byte

.es+>b+1k>@CQkk

Prende una matrice in stile pitone di matrici di numeri, restituisce una matrice di somme.

Provalo!

Spiegazione

.es+>b+1k>@CQkk 
.e             Q  # Enumerated map over the implicit input (Q); indices k, rows b
           CQ     # Take the transpose
          @  k    # The kth column
         >    k   # cut off the first k elements
    >b+1k         # cut off the first k+1 elements of the rows, so (k,k) isn't counted twice
  s+              # add the row and column together and sum
— KarlKastor
fonte
1

GNU APL 1.7, 123 byte

La soluzione richiede due funzioni: una crea un array globale e le chiamate la seconda, che aggiunge ricorsivamente le somme a tale array.

∇f N
R←⍬
g N
R
∇
∇g N
→2+2×0∈⍴N
R←R,(+/N[1;])+(+/N[;1])-N[1;1]
g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]
∇

∇inizia e termina la funzione. Entrambi fe gprendono le tabelle come argomenti (essenzialmente array 2D). Questi possono essere creati con X←rows cols ⍴ 1 2 3 4....

R←⍬assegna un vettore vuoto alla variabile globale R.

g N chiama la seconda funzione con lo stesso argomento dato alla prima.

⍴Ndà le dimensioni di N; quando una delle dimensioni è zero, non ci sono più righe / colonne da aggiungere. 0∈⍴Nrestituisce 1 se c'è uno zero nelle dimensioni. →2+2×0∈⍴Nsi dirama alla riga numero 2 più 2 volte il valore di ritorno della ∈funzione: se non c'è zero, ∈restituisce 0 e la funzione si dirama alla riga 2 (la riga successiva). Se v'è uno zero, ∈restituisce 1 e la funzione accede linea 4 (la fine della funzione, così returnessenzialmente).

/è l'operatore di riduzione. Applica l'argomento left, che è un operatore ( +) a ogni elemento nell'elenco dato come argomento giusto. N[1;]fornisce l'intera prima riga della tabella e N[;1]fornisce la prima colonna. (+/N[1;])+(+/N[;1])-N[1;1]somma la prima riga e colonna e sottrae il valore nell'angolo in alto a sinistra perché viene aggiunto sia nella somma delle colonne che nella somma delle righe. R←R,...aggiunge il nuovo valore calcolato al vettore globale R.

La funzione quindi chiama se stessa (ricorrere fino a quando non ci sono più righe o colonne). L' ⊃operatore pick ottiene l'elemento specificato dall'elenco. 1⊃⍴Nindica il numero di righe, 2⊃⍴Nil numero di colonne. ⍳fornisce tutti i numeri da 1 al numero specificato. L' ↓operatore di rilascio rimuove gli elementi dall'inizio dell'elenco. Se si danno più indici quando si accede a elementi da una tabella o un vettore (ad esempio N[1 2 3]), APL accede a ciascuno di essi. Pertanto, 1↓⍳1⊃⍴Nfornisce gli indici di ogni riga escludendo il primo ( 2, 3, 4, ..., N) e 1↓⍳2⊃⍴Nfornisce un vettore simile ma per le colonne. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]chiama di nuovo la funzione ma senza la prima riga o colonna.

— Arc676
fonte
0

Mathematica, 116 byte

l=Length;If[l@#==1||l@#[[1]]==1,Total@Flatten@#,Total/@Flatten/@Table[{#[[i]][[i;;]],#[[All,i]][[i+1;;]]},{i,l@#}]]&

Modulo di input

[{{5}}], [{{1}, {4}}], [{{7,2}}] o [{{....}, {....} ... {. ...}}]

— J42161217
fonte
0

Clojure, 98 byte

#(vals(apply merge-with +(sorted-map)(mapcat(fn[i r](map(fn[j v]{(min i j)v})(range)r))(range)%)))

Scorre sull'input con indici di riga e colonna (in modo molto dettagliato), crea una mappa hash con il minimo di ie jcome chiave, unisce le mappe hash +in una mappa ordinata, restituisce valori.

— NikoNyrh
fonte
0

R, 102 byte

function(x)`for`(i,1:min(r<-nrow(x),k<-ncol(x)),{dput(sum(x[,1],x[1,-1]));x=matrix(x[-1,-1],r-i,k-i)})

restituisce una funzione anonima; stampa i risultati sulla console, con una nuova riga finale. Probabilmente ho bisogno di un approccio diverso.

Scorre il minimo tra le righe e le colonne; stampa la somma di x[,1](la prima colonna) e x[1,-1]la prima riga tranne la prima voce, quindi imposta xuna matrice uguale a x[-1,-1](cioè, xescludendo la sua prima riga e colonna). Sfortunatamente, la semplice impostazione x=x[-1,-1]fa sì che fallisca nel caso di una matrice quadrata, perché quando xè 2x2, il sottoinsieme restituisce un vettore anziché una matrice.

Provalo online!

— Giuseppe
fonte
0

Java 7, 280 276 byte

import java.util.*;String d(ArrayList l){String r="";for(;l.size()>0&&((List)l.get(0)).size()>0;l.remove(0))r+=s(l)+" ";return r;}int s(List<ArrayList<Integer>>l){int s=0,L=l.size(),i=1;for(;l.get(0).size()>0;s+=l.get(0).remove(0));for(;i<L;s+=l.get(i++).remove(0));return s;}

Provalo qui.

Approccio alternativo rispetto alla mia precedente risposta con array, che alla fine è ancora più breve di questo (quindi ho perso tempo a provare questo approccio alternativo).

Spiegazione generale:

L'ispirazione da @Riley sorprendente risposta 05AB1E s'
Questa risposta utilizza un elenco e dopo ogni somma è calcolata rimuove la prima colonna e prima riga dalla lista a matrice, in questo modo:

// Starting matrix:
7 10 1
4 4  2
6 3  4
1 4  10
5 7  6

// After first iteration (result so far: "34 "):
4  2
3  4
4  10
7  6

// After second iteration (result so far: "34 20 "):
4
10
6

// After last iteration, result: "34 20 20 "

Spiegazione del codice:

import java.util.*;                // Required import for List and ArrayList

String d(ArrayList l){             //  Method with ArrayList parameter and String return-type
  String r="";                     //  Return-String
  for(;l.size()>0&&((List)l.get(0)).size()>0; 
                                   //  Loop as long as the list still contains anything
       l.remove(0))                //  And remove the first row after every iteration
    r+=s(l)+" ";                   //   Append the sum to the result-String
                                   //  End of loop (implicit / single-line body)
  return r;                        //  Return result-String
}                                  // End of method

int s(List<ArrayList<Integer>>l){  // Separate method with List-matrix parameter and integer return-type
  int s=0,                         //  The sum
      L=l.size(),                  //  The size of the input list
      i=1;                         //  Temp integer
  for(;l.get(0).size()>0;          //  Loop (1) over the items of the first row
    s+=l.get(0).                   //   Add the number to the sum
                remove(0)          //   And remove it from the list afterwards
  );                               //  End of loop (1)
  for(;i<L;                        //  Loop (2) over the rows
    s+=l.get(i++).                 //   Add the first number of the row to the sum
                  remove(0)        //   And remove it from the list afterwards
  );                               //  End of loop (2)
  return s;                        //  Return sum
}                                  // End of separate method
— Kevin Cruijssen
fonte
0

Python, 93 byte

Simile alla risposta di mbomb007, ma senza NumPy

f=lambda m:[sum(m[k][k:])+sum(list(zip(*m))[k][k+1:])for k in range(min(len(m),len(m[0])))]
— PattuX
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.