Resumen de rotación

26

Tome una matriz cuadrada que contenga enteros positivos como entrada y calcule la "suma rotada" de la matriz.

Suma rotada:

Tome la suma de la matriz original y la misma matriz rotó 90, 180 y 270 grados.

Supongamos que la matriz es:

 2    5    8
 3   12    8
 6    6   10

entonces la suma rotada será:

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

Casos de prueba:

Entrada y salida separadas por guiones, diferentes casos de prueba separados por una nueva línea. Los casos de prueba en formatos más convenientes se pueden encontrar aquí .

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

El código más corto en bytes en cada idioma gana. ¡Las explicaciones son altamente recomendables!

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

Respuestas:

9

Python 2 , 78 bytes

Gracias a Dennis por jugar dos bytes de mi enfoque recursivo anterior.

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

Pruébalo en línea! o Ver un conjunto de pruebas.

Python 2 , 80 81 83 85 bytes (no recursivo)

Toma la entrada como una lista singleton .

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

Pruébalo en línea!

Funcionalidad de código

Dado que esto es bastante largo para analizarlo en su conjunto, vamos a verlo pieza por pieza:

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.

Y para el segundo programa:

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: Genere la lista de matrices necesarias girando la entrada 3 veces en 90 grados y recopilando los resultados. Luego, obtenga las sumas de las columnas de cada matriz en la transposición del resultado.

— Sr. Xcoder
fuente
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)guarda dos bytes con entrada "normal". Pruébalo en línea!
— Dennis
@ Dennis Gracias! Pensé que lambda*lno era posible en Python 2 por alguna razón.
— Sr. Xcoder
No se puede hacer x,*y=1,2,3en Python 2.7 o [*x]en Python 3.4, pero las expresiones destacadas se pueden usar para argumentos de función incluso en Python 1.6. Pruébalo en línea!
— Dennis
8

Octava , 29 bytes

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

Pruébalo en línea!

Explicación

Esto agrega la matriz de entrada con una versión girada de 90 grados de sí misma. El resultado se agrega luego con una versión girada de 180 grados de sí mismo.

— Luis Mendo
fuente
5

Limpio , 110 bytes

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)]

Pruébalo en línea!

De las matrículas:

  • X = transpose(reverse M): Rotación de 90 grados
  • Y = reverse(map reverse M): Rotación de 180 grados
  • Z = reverse(transpose M): Rotación de 270 grados

Esto comprime el operador de suma sobre My X, así como Yy Z, y luego sobre los resultados.

— Οurous
fuente
5

Julia 0.6 , 29 bytes

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

Pruébalo en línea!

No pude ponerme debajo de la solución de LukeS

Pero al intentarlo se me ocurrió esto, que creo que es un poco lindo.

Primero redefinimos la multiplicación para que sea la operación de rotación, donde la primera vez es la cantidad de veces que se rota. Entonces, desde julia multipie por yuxtaposición, entonces: se 1xconvierte rotr90(x,1)y se 3xconvierte en rotr90(x,3)etc.

Luego escribimos la suma.

— Lyndon White
fuente
5

Julia 0.6 , 28 24 bytes

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

Pruébalo en línea!

~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
— Lucas
fuente
1
Vale la pena señalar que hacer el [1]ejemplo debería hacerlo ~reshape([1], (1,1))porque así es como se declara una matriz 1x1 en julia 0.6.
— Lyndon White
4

MATL , 9 bytes

i3:"G@X!+

Pruébalo en MATL Online

Explicación

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
fuente
4

Octava , 33 bytes

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

Pruébalo en línea!

Explicación:

(r=@rot90)en una forma en línea de crear un controlador de función rutilizado para rotar la matriz 90 grados. Si un segundo argumento, kse da a rcontinuación, girará las matrices k*90grados. Entonces esto es equivalente al pseudocódigo:

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

MATL , 7 bytes

,t@QX!+

¡Pruébalo en MATL Online!

Explicación

Puerto de mi octava respuesta.

,        % 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
fuente
3

R , 69 64 bytes

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

Pruébalo en línea!

Intento número tres en codegolf. ¡De 69 a 64 bytes gracias a Giuseppe!

— Florian
fuente
Pasar aa un argumento de función ahorrará bytes al permitirle deshacerse del {}cuerpo de la función. Además, ¿portar el enfoque de octava de Luis Mendo podría ahorrar algunos bytes? Finalmente, no estoy 100% seguro pero es t(apply(x,2,rev))equivalente a apply(x,1,rev)?
— Giuseppe
Gracias, pude mejorar con los consejos n. ° 1 y n. ° 3. No tuve éxito en el ahorro de bytes mediante la adición de un argumento na a()repetir la operación sin embargo.
— Florian
1
Quise decir algo como esto
— Giuseppe
2

JavaScript (ES6), 77 bytes

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
fuente
2

Jalea , 7 bytes

ṚZ$3СS

Pruébalo en línea!

Guardado 1 byte gracias a Erik the Outgolfer (también gracias a una sugerencia para corregir un error).

¿Cómo?

ṚZ $ 3СS || Programa completo (monádico).

   3С || Haga esto 3 veces y recopile los resultados en una lista
  $ || -> Aplicar los dos últimos enlaces como mónada
Ṛ || –––> Reverso,
 Z || –––> Transponer.
      S || Suma.
— Sr. Xcoder
fuente
2

APL (Dyalog Classic) , 17 bytes

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

Pruébalo en línea!

NARS APL 34bytes 21 17 caracteres

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

-2 caracteres gracias a ngn

-2 caracteres porque el operador compuesto ∘ parece tener prioridad sobre +

parece ⌽⍉a rotar a de 90 °, ⌽⊖a rotar a de 180 °, ⌽⍉⌽⊖a rotar a de 270 ° como ⍉⌽

Si existe el operador p como:

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

El operador p anterior sería tal que si g es una función de 1 argumento (¿monádico?) Debería ser:

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

la solución sería pheraps 15 chars

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

Pero podría ser mejor un operador "compuesto n tiempo" d tal que "3 df w" es f (f (f (w))).

Ahora escribí algo pero es demasiado frágil sin la necesidad de verificar el tipo.

Pero me gusta más el operador q que repite componer de f con argumento m (no está completo porque los casos de error de los tipos no están escritos)

∇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 solución sería 17 caracteres pero lo prefiero

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~
— RosLuP
fuente
270 podría ser justo ⍉⌽y toda la cosa es adecuado para un tren
— NGN
Si existe una f tal que gfwwww es w gw ggw gggw la respuesta sería + / ⌽⍉f 4 / rho w
— RosLuP
Quieres decir +/⌽∘⍉f 4⍴⊂⍵? Para obtener cuatro copias ⍵, primero debe adjuntarlo con ⊂. Tener ⌽⍉como operando a f, debe componer en una única función como esta: ⌽∘⍉. Lo misterioso fpodría ser el escaneo (barra invertida), pero hay otro detalle que ⌽∘⍉se debe tener en cuenta: obtendrá un argumento izquierdo, por lo que debemos hacer que lo ignore: +/{⌽⍉⍵}\4⍴⊂⍵o +/⊢∘⌽∘⍉\4⍴⊂⍵.
— ngn
En mi primer comentario que sugería este tren: ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽. Eso puede conducir a soluciones aún más cortas si reorganiza los garabatos de manera inteligente y hace un buen uso de los trenes.
— ngn
@ngn incluso un simple {⍵ + ⍺} \ 1 2 3 4 error de retorno de dominio
— RosLuP
2

K4 / K (oK) , 23 8 bytes

Solución:

+/(|+:)\

Pruébalo en línea!

Ejemplo:

+/(|+:)\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

Explicación:

Gracias a ngn por la técnica de transformación simplificada.

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

Extra:

En Q esto podría escribirse como

sum (reverse flip @) scan
— callejero
fuente
— ngn
¡ Sabía que había una mejor manera de aplicar las transformaciones!
— Callejero el
+ / (| + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA es tristemente el mismo recuento ... Gah no puede calcular el marcado en el móvil.
— Callejero el
Parece que el marcado en los comentarios tiene un error, no solo en el móvil: la barra diagonal inversa antes de que la cita inversa arruine las cosas. Lo evité insertando un espacio.
— ngn
2

Ruby , 74 72 66 bytes

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

Pruébalo en línea!

Esto funciona elemento por elemento, encontrando los elementos asociados matemáticamente, en lugar de rotar la matriz. La parte clave esi,j=j,~i , que gira (i, j) en sentido horario 90 grados.

-2 bytes gracias al Sr. Xcoder

-6 bytes debido a sum

— MegaTom
fuente
1

Ruby 89 79 bytes

-10 bytes gracias a Unihedron 

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

Pruébalo en línea!

— Asone Tuhid
fuente
1
Estoy bastante seguro de que puede reemplazar .map &:dupcon *1cortar una gran cantidad de caracteres. array*lengthcrea una nueva matriz y es una forma práctica de clonar poco profundo.
— Unihedron
En realidad, n=*mes aún más corto.
— Unihedron
@Unihedron ese es el problema, necesito clonar profundamente
— Asone Tuhid
Me parece que no afecta la salida; Lo manipulé en su enlace "pruébelo en línea" y la salida parece seguir siendo correcta con ese cambio
— Unihedron
Tienes razón, en realidad ni siquiera necesitas un clon superficial, transposese encarga de eso
— Asone Tuhid
1

Casco , 9 bytes

F‡+↑4¡(↔T

Pruébalo en línea!

Explicación

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]]
— ბიმო
fuente
1

tinylisp , 132 bytes

¡Vamos a probar la función de biblioteca recientemente agregada transpose!

(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

La última línea es una función lambda sin nombre que realiza la suma de rotación. Para usarlo realmente, querrás usarlo dpara vincularlo a un nombre. Pruébalo en línea!

Ungolfed, con comentarios

(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
fuente
1

Adjunto , 20 bytes

Sum@MatrixRotate&0:3

Pruébalo en línea!

Explicación

Sum@MatrixRotate&0:3

MatrixRotate&0:3expande para, con la entrada x, MatrixRotate[x, 0:3]que, a su turno para exapnds [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Es decir, se vectoriza sobre el RHS. Luego, Sumtoma la suma de todas estas matrices en un nivel. Esto da el resultado deseado.

— Conor O'Brien
fuente
1

Java 8, 135 133 bytes

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 bytes gracias a @ceilingcat .

Explicación:

Pruébalo en línea.

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
fuente
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.