Somma della rotazione

26

Prendi una matrice quadrata contenente numeri interi positivi come input e calcola la "somma ruotata" della matrice.

Somma ruotata:

Prendi la somma della matrice originale e la stessa matrice ruotava di 90, 180 e 270 gradi.

Supponiamo che la matrice sia:

 2    5    8
 3   12    8
 6    6   10

quindi la somma ruotata sarà:

2    5    8     8    8   10    10    6    6     6    3    2
3   12    8  +  5   12    6  +  8   12    3  +  6   12    5  = 
6    6   10     2    3    6     8    5    2    10    8    8   

26   22   26
22   48   22
26   22   26

Casi test:

Input e output separati da trattini, diversi casi di test separati da una nuova riga. I casi di test in formati più convenienti sono disponibili qui .

1
-------------
4

1 3
2 4
-------------
10   10 
10   10    

14    6    7   14
 6   12   13   13
 6    2    3   10
 5    1   12   12
-------------
45   37   24   45
24   30   30   37
37   30   30   24
45   24   37   45    

14    2    5   10    2
18    9   12    1    9
 3    1    5   11   14
13   20    7   19   12
 2    1    9    5    6
-------------
24   29   31   41   24
41   49   31   49   29
31   31   20   31   31
29   49   31   49   41
24   41   31   29   24

Vince il codice più breve in byte in ogni lingua. Le spiegazioni sono fortemente incoraggiate!

code-golf  math  number  array-manipulation  matrix 
— Stewie Griffin
fonte

Risposte:

9

Python 2 , 78 byte

Grazie a Dennis per aver giocato a golf a due byte dal mio precedente approccio ricorsivo.

f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)

Provalo online! oppure Guarda una suite di test.

Python 2 , 80 81 83 85 byte (non ricorsivo)

Prende l'input come un elenco singleton .

l=input()
exec"l+=zip(*l[-1][::-1]),;"*3
print[map(sum,zip(*d))for d in zip(*l)]

Provalo online!

Funzionalità del codice

Poiché questo è abbastanza lungo per analizzarlo nel suo insieme, diamo un'occhiata pezzo per pezzo:

f = lambda *l:                # This defines a lambda-function that can accept any number
                              # of arguments (the matrix) using starred expressions.
l[3:] and ...X... or ...Y...  # If l[3:] is truthy (that is, the length of the list is
                              # higher than 3), return X, otherwise Y.

[map(sum,zip(*d))for d in zip(*l)]     # The first expression, X.
[                                ]     # Start a list comprehension, that:
                 for d in              # ... Iterates using a variable d on:
                          zip(*l)      # ... The "input", l, transposed.
         zip(*d)                       # ... And for each d, transpose it...
 map(sum,       )                      # ... And compute the sum of its rows.
                                       # The last two steps sum the columns of d.

f(zip(*l[0][::-1]),*l)     # The second expression, Y. This is where the magic happens.
f(                   )     # Call the function, f with the following arguments:
  zip(*          )         # ... The transpose of:
       l[0][::-1]          # ...... The first element of l (the first arg.), reversed.
                  ,        # And:
                   *l      # ... l splatted. Basically turns each element of l
                           # into a separate argument to the function.

E per il secondo programma:

l=input()                                # Take input and assign it to a variable l.
                                         # Note that input is taken as a singleton list.

exec"l+=zip(*l[-1][::-1]),;"*3           # Part 1. Create the list of rotations.
exec"                     ;"*3           # Execute (Do) the following 3 times:
     l+=                 ,               # ... Append to l the singleton tuple:
        zip(*           )                # ...... The transpose of:
             l[-1][::-1]                 # ......... The last element of l, reversed.

print[map(sum,zip(*d))for d in zip(*l)]  # Part 2. Generate the matrix of sums.
print                                    # Output the result of this expression:
     [                for d in        ]  # Create a list comprehension, that iterates
                                         # with a variable called "d" over:
                               zip(*l)   # ... The transpose of l.
      map(sum,       )                   # ... And computes the sum:
              zip(*d)                    # ... Of each row in d's transpose.
                                         # The last 2 steps generate the column sums.

TL; DR: genera l'elenco delle matrici necessarie ruotando l'input di 3 volte di 90 gradi e raccogliendo i risultati. Quindi, ottieni le somme delle colonne di ciascuna matrice nella trasposizione del risultato.

— Mr. Xcoder
fonte
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)salva due byte con input "normale". Provalo online!
— Dennis,
@Dennis Grazie! Pensavo che lambda*lnon fosse possibile in Python 2 per qualche motivo.
— Mr. Xcoder,
Non puoi farlo x,*y=1,2,3in Python 2.7 o [*x]in Python 3.4, ma le espressioni speciali possono essere usate per argomenti di funzione anche in Python 1.6. Provalo online!
— Dennis,
8

Ottava , 29 byte

@(x)(y=x+rot90(x))+rot90(y,2)

Provalo online!

Spiegazione

Ciò aggiunge la matrice di input con una versione ruotata di 90 gradi di se stesso. Il risultato viene quindi aggiunto con una versione ruotata di 180 gradi di se stesso.

— Luis Mendo
fonte
5

Pulito , 110 byte

import StdEnv,StdLib
r=reverse
t=transpose
z=zipWith(+)
$m=[z(z(r b)a)(z(r c)d)\\a<-m&b<-r m&c<-t m&d<-r(t m)]

Provalo online!

Dalle matrici:

  • X = transpose(reverse M): Rotazione di 90 gradi
  • Y = reverse(map reverse M): Rotazione di 180 gradi
  • Z = reverse(transpose M): Rotazione di 270 gradi

Ciò comprime l'operatore addizione sopra Me X, così come Ye Z, e poi sopra i risultati.

— Οurous
fonte
5

Julia 0.6 , 29 byte

x*y=rotr90(y,x)
!x=x+1x+2x+3x

Provalo online!

Non sono riuscito a scendere sotto la soluzione di LukeS

Ma provando, mi è venuto in mente questo, che penso sia piuttosto carino.

Innanzitutto ridefiniamo la moltiplicazione come operazione di rotazione, in cui la prima volta è il numero di volte in cui ruotare. Quindi, poiché julia multipes per giustapposizione, allora: 1xdiventa rotr90(x,1)e 3xdiventa rotr90(x,3)ecc.

Quindi scriviamo la somma.

— Lyndon White
fonte
5

Julia 0.6 , 28 24 byte

~A=sum(rotr90.([A],0:3))

Provalo online!

~A=sum(rotr90.([A],0:3)) #
~                        # redefine unary operator ~
 A                       # function argument
               [A]       # put input matrix A into a list with one element
                   0:3   # integer range from 0 to 3
       rotr90.(   ,   )  # apply function rotr90 elementwise, expand singleton dimensions
       rotr90.([A],0:3)  # yields list of rotated matrices:
                         # [rotr90(A,0), rotr90(A,1), rotr90(A,2), rotr90(A,3)]
  sum(                )  # sum
— Lukes
fonte
1
Vale forse la pena notare che fare l' [1]esempio dovrebbe fare ~reshape([1], (1,1))perché è così che viene dichiarata una matrice 1x1 in julia 0.6.
— Lyndon White,
4

MATL , 9 byte

i3:"G@X!+

Provalo su MATL Online

Spiegazione

i       # Explicitly grab the input matrix
3:"     # Loop through the values [1, 2, 3], and for each value, N:
  G     # Grab the input again
  @X!   # Rotate the value by 90 degrees N times
  +     # Add it to the previous value on the stack
        # Implicitly end the for loop and display the resulting matrix
— Suever
fonte
4

Ottava , 33 byte

@(a)a+(r=@rot90)(a)+r(a,2)+r(a,3)

Provalo online!

Spiegazione:

(r=@rot90)in modo inline di creare una maniglia di funzione rutilizzata per ruotare la matrice di 90 gradi. Se kviene dato un secondo argomento, rruoterà i k*90gradi della matrice . Quindi questo equivale allo pseudo codice:

a + rot90(a) + rot180(a) + rot270(a)
— Stewie Griffin
fonte
3

MATL , 7 byte

,t@QX!+

Provalo su MATL Online!

Spiegazione

Risposta Port of my Octave.

,        % Do twice
  t      %   Duplicate. Takes input (implicit) the first time
  @Q     %   Push 1 in the first iteration, and 2 in the second
  X!     %   Rotate by that many 90-degree steps
  +      %   Add
         % End (implicit). Display (implicit)
— Luis Mendo
fonte
3

R , 69 64 byte

function(x,a=function(y)apply(y,1,rev))x+a(x)+a(a(x))+a(a(a(x)))

Provalo online!

Tentativo numero tre su codegolf. Da 69 a 64 byte grazie a Giuseppe!

— Florian
fonte
Passare aa un argomento della funzione salverà i byte consentendo di eliminare {}tutto il corpo della funzione. Inoltre, il porting dell'approccio Octave di Luis Mendo potrebbe far risparmiare qualche byte? Infine, non sono sicuro al 100% ma t(apply(x,2,rev))equivale a apply(x,1,rev)?
— Giuseppe,
Grazie, sono riuscito a migliorare con il suggerimento n. 1 e n. 3. Non sono riuscito a salvare byte con l'aggiunta di un argomento nper a()ripetere l'operazione però.
— Florian,
1
Intendevo qualcosa del genere
— Giuseppe,
2

JavaScript (ES6), 77 byte

a=>a.map((b,i)=>b.map((c,j)=>c+a[j][c=l+~i]+a[c][c=l+~j]+a[c][i]),l=a.length)
— Neil
fonte
2

Gelatina , 7 byte

ṚZ$3СS

Provalo online!

Salvato 1 byte grazie a Erik the Outgolfer (anche grazie a un suggerimento per la correzione di un bug).

Come?

$Z $ 3СS || Programma completo (monadico).

   3С || Fallo 3 volte e raccogli i risultati in un elenco
  $ || -> Applica gli ultimi due collegamenti come monade
Ṛ || –––> Indietro,
 Z || –––> Transpose.
      S || Somma.
— Mr. Xcoder
fonte
2

APL (Dyalog Classic) , 17 byte

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

Provalo online!

APL NARS 34bytes 21 17 caratteri

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

-2 caratteri grazie a ngn

-2 caratteri perché l'operatore composito ∘ sembra avere la precedenza su +

sembra ⌽⍉a ruotare a da 90 °, ⌽⊖a ruotare a da 180 °, ⌽⍉⌽⊖a ruotare a da 270 ° come ⍉⌽

Se esiste l'operatore p come:

∇r←(g p)n;a;i;k
   a←⌽,n⋄r←⍬⋄i←0⋄k←⍴a⋄→C
A: →B×⍳r≡⍬⋄r←g¨r
B: r←r,⊂i⊃a
C: →A×⍳k≥i+←1
   r←⌽r
∇

L'operatore p sopra sarebbe tale che se g è una funzione argomento 1 (monadica?) Dovrebbe essere:

"g f a a a a" is "a ga gga ggga"

la soluzione sarebbe pheraps 15 caratteri

  g←{⊃+/⌽∘⍉ p 4⍴⊂⍵}
  a←2 2⍴1 3 2 4
  g a
10 10 
10 10 
  g 1
4

Ma potrebbe essere meglio un operatore "composto n tempo" d tale che "3 df w" è f (f (f (w))).

Ora ho scritto qualcosa, ma è troppo fragile senza la necessità del controllo del tipo.

Ma mi piace di più l'operatore q che ripete comporre f con argomento m (non è completo perché i casi di errore dei tipi non sono scritti)

∇r←(n q f)m;i;k;l
   r←⍬⋄k←⍴,n⋄→A×⍳k≤1⋄i←0⋄→D
C: r←r,⊂(i⊃n)q f m
D: →C×⍳k≥i+←1
   →0
A: l←n⋄r←m⋄→0×⍳n≤0
B: l-←1⋄r←f r⋄→B×⍳l≥1
∇

la soluzione sarebbe di 17 caratteri ma la preferisco

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~
— RosLuP
fonte
270 potrebbe essere giusto ⍉⌽e il tutto è adatto per un treno
— ngn
Se esiste una f tale che gfwwww è w gw ggw gggw la risposta sarebbe + / ⌽⍉f 4 / rho w
— RosLuP
Intendi +/⌽∘⍉f 4⍴⊂⍵? Per ottenere quattro copie di ⍵, per prima cosa dovresti racchiuderlo in ⊂. Avere ⌽⍉come un operando a f, è necessario comporla in una singola funzione come questa: ⌽∘⍉. Il misterioso fpotrebbe essere scan (backslash), ma c'è un altro dettaglio di cui occuparsi - ⌽∘⍉otterrà un argomento sinistro, quindi dobbiamo fargli ignorarlo: +/{⌽⍉⍵}\4⍴⊂⍵o +/⊢∘⌽∘⍉\4⍴⊂⍵.
— ngn
Nel mio primo commento stavo suggerendo questo treno: ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽. Ciò può portare a soluzioni ancora più brevi se si riorganizzano abilmente gli scarabocchi e si fa buon uso dei treni.
— ngn
@ngn anche un semplice {⍵ + ⍺} \ 1 2 3 4 errore nel dominio di ritorno
— RosLuP
2

K4 / K (oK) , 23 8 byte

Soluzione:

+/(|+:)\

Provalo online!

Esempio:

+/(|+:)\5 5#14 2 5 10 2 18 9 12 1 9 3 1 5 11 14 13 20 7 19 12 2 1 9 5 6
24 29 31 41 24
41 49 31 49 29
31 31 20 31 31
29 49 31 49 41
24 41 31 29 24

Spiegazione:

Grazie a ngn per la tecnica di trasformazione semplificata.

+/(|+:)\ / the solution
       \ / converge
  (   )  / function to converge
    +:   / flip
   |     / reverse
+/       / sum over the result

Extra:

In Q questo potrebbe essere scritto come

sum (reverse flip @) scan
— streetster
fonte
— ngn
Ho saputo che c'era un modo migliore per applicare le trasformazioni!
— streetter
+ / (| + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA è purtroppo lo stesso conteggio ... Gah non riesce a capire il markup sul cellulare.
— streetter
Sembra che il markup nei commenti abbia un bug, non solo sui dispositivi mobili: la barra rovesciata prima che il backquote rovini le cose. L'ho evitato inserendo uno spazio.
— ngn
2

Rubino , 74 72 66 byte

->a{r=0...a.size;r.map{|i|r.map{|j|(0..3).sum{i,j=j,~i;a[i][j]}}}}

Provalo online!

Funziona su una base elemento per elemento, trovando matematicamente gli elementi associati, invece di ruotare l'array. La parte chiave è i,j=j,~i, che gira (i, j) in senso orario di 90 gradi.

-2 byte grazie a Mr. Xcoder

-6 byte a causa di sum

— Megatom
fonte
1

Ruby 89 79 byte

-10 byte grazie a Unihedron 

->m{n=m;3.times{n=n.zip(m=m.transpose.reverse).map{|i,j|i.zip(j).map &:sum}};n}

Provalo online!

— Solo Tuhid
fonte
1
Sono abbastanza sicuro che puoi sostituirlo .map &:dupcon *1per tagliare molti personaggi. array*lengthcrea un nuovo array ed è un modo pratico per clonare in modo superficiale.
— Unihedron,
In realtà, n=*mè ancora più breve.
— Unihedron,
@Unihedron questo è il problema, ho bisogno di un clone profondo
— Asone Tuhid
Mi sembra che non influisca sull'output; L'ho cercato nel tuo link "provalo online" e l'output sembra rimanere corretto con quel cambiamento
— Unihedron,
Hai ragione, in realtà non hai nemmeno bisogno di un clone superficiale, se transposene occupa
— Asone Tuhid,
1

Buccia , 9 byte

F‡+↑4¡(↔T

Provalo online!

Spiegazione

F‡+↑4¡(↔T)  -- implicit input M, for example: [[1,0,1],[2,3,4],[0,0,2]]
     ¡(  )  -- repeat infinitely times starting with M  
        T   -- | transpose: [[1,2,0],[0,3,0],[1,4,2]]
       ↔    -- | reverse: [[1,4,2],[0,3,0],[1,2,0]]
            -- : [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]],[[1,0,1],[2,3,4],[0,0,2]],…
   ↑4       -- take 4: [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]]]
F           -- fold (reduce) the elements (example with [[1,0,1],[2,3,4],[0,0,2]] [[1,4,2],[0,3,0],[1,2,0]])
 ‡+         -- | deep-zip addition (elementwise addition): [[2,4,3],[2,6,4],[1,2,2]]
            -- : [[4,6,4],[6,12,6],[4,6,4]]
— ბიმო
fonte
1

tinylisp , 132 byte

Prendiamo la funzione di libreria aggiunta di recente transposeper un giro!

(load library
(d T transpose
(d R(q((m #)(i #(c m(R(reverse(T m))(dec #)))(
(q((m)(foldl(q(p(map(q((r)(map sum(T r))))(T p))))(R m 4

L'ultima riga è una funzione lambda senza nome che esegue la somma della rotazione. Per usarlo effettivamente, ti consigliamo ddi associarlo a un nome. Provalo online!

Ungolfed, con commenti

(load library) (comment Get functions from the standard library)

(comment Rotating a matrix by 90 degrees is just transpose + reverse)
(def rotate
 (lambda (matrix)
  (reverse (transpose matrix))))

(comment This function recursively generates a list of (count) successive rotations
          of (matrix))
(def rotations
 (lambda (matrix count)
  (if count
   (cons matrix
    (rotations (rotate matrix) (dec count)))
   nil)))

(comment To add two matrices, we zip them together and add the pairs of rows)
(def matrix-add
 (lambda two-matrices
  (map row-sum (transpose two-matrices))))

(comment To add two rows of a matrix, we zip them together and add the pairs of numbers)
(def row-sum
 (lambda (two-rows)
  (map sum (transpose two-rows))))

(comment Our final function: generate a list containing four rotations of the argument
          and fold them using matrix-add)
(def rotated-sum
 (lambda (matrix)
  (foldl matrix-add (rotations matrix 4))))
— DLosc
fonte
1

Attache , 20 byte

Sum@MatrixRotate&0:3

Provalo online!

Spiegazione

Sum@MatrixRotate&0:3

MatrixRotate&0:3espande, con ingresso x, MatrixRotate[x, 0:3]che a sua volta exapnds a [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Vale a dire, vettorializza su RHS. Quindi, Sumprende la somma di tutte queste matrici di un livello. Questo dà il risultato desiderato.

— Conor O'Brien
fonte
1

Java 8, 135 133 byte

a->{int l=a.length,r[][]=new int[l][l],i=0,j;for(;i<l;i++)for(j=0;j<l;)r[i][j]=a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];return r;}

-2 byte grazie a @ceilingcat .

Spiegazione:

Provalo online.

a->{                        // Method with integer-matrix as both parameter and return-type
  int l=a.length,           //  Dimensions of the input-matrix
      r[][]=new int[l][l],  //  Result-matrix of same size
      i=0,j;                //  Index-integers
  for(;i<l;i++)             //  Loop over the rows
    for(j=0;j<l;)           //   Loop over the columns
      r[i][j]=              //    Set the cell of the result-matrix to:
              a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];
                            //     The four linked cells of the input-matrix
  return r;}                //  Return the result-matrix
— Kevin Cruijssen
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.