Ambil matriks persegi yang berisi bilangan bulat positif sebagai input, dan hitung "jumlah yang diputar" dari matriks.

Jumlah yang diputar:

Ambil jumlah dari matriks asli dan matriks yang sama diputar 90, 180 dan 270 derajat.

Misalkan matriksnya adalah:

 2    5    8
 3   12    8
 6    6   10

maka jumlah yang diputar adalah:

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

Kasus uji:

Input dan output dipisahkan oleh tanda hubung, kasus uji berbeda dipisahkan oleh baris baru. Kasing uji dalam format yang lebih nyaman dapat ditemukan di sini .

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

Kode terpendek dalam byte di setiap bahasa akan menang. Penjelasan sangat dianjurkan!

Python 2 , 78 byte

Terima kasih kepada Dennis untuk bermain golf dua byte dari pendekatan rekursif saya sebelumnya.

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

Cobalah online! atau Lihat suite tes.

Python 2 , 80 81 83 85 byte (non-rekursif)

Mengambil input sebagai daftar tunggal .

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

Cobalah online!

Fungsionalitas kode

Karena ini cukup panjang untuk menganalisanya secara keseluruhan, mari kita periksa sepotong demi sepotong:

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.

Dan untuk program kedua:

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: Hasilkan daftar matriks yang dibutuhkan dengan memutar input 3 kali 90 derajat dan mengumpulkan hasilnya. Kemudian, dapatkan jumlah kolom dari setiap matriks dalam transpos hasil.

Oktaf , 29 byte

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

Cobalah online!

Penjelasan

Ini menambahkan matriks input dengan versi rotasi 90 derajat itu sendiri. Hasilnya kemudian ditambahkan dengan versi diputar 180 derajat itu sendiri.

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

Cobalah online!

Dari matricies:

• X = transpose(reverse M): Rotasi 90 derajat
• Y = reverse(map reverse M): Rotasi 180 derajat
• Z = reverse(transpose M): Rotasi 270 derajat

Ini ritsleting operator tambahan atas Mdan X, serta Ydan Z, dan kemudian atas hasilnya.

Bahasa Wolfram (Mathematica) , 28 byte

Sum[a=Reverse@a,{a=#;4}]&

adalah \[Transpose].

Cobalah online!

Julia 0,6 , 29 byte

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

Cobalah online!

Saya tidak bisa mendapatkan di bawah solusi LukeS

Tetapi dalam mencoba saya memang datang dengan ini, yang saya pikir agak lucu.

Pertama kita mendefinisikan ulang perkalian menjadi operasi rotasi, di mana pertama kali ada berapa kali untuk memutar. Jadi sejak julia dikalikan dengan penjajaran lalu: 1xmenjadi rotr90(x,1)dan 3xmenjadi rotr90(x,3)dll.

Lalu kami menulis jumlahnya.

Julia 0,6 , 28 24 byte

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

Cobalah 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

Jelly , 7 byte

ZU+µUṚ+

Cobalah online!

MATL , 9 byte

i3:"G@X!+

Cobalah di MATL Online

Penjelasan

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

Oktaf , 33 byte

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

Cobalah online!

Penjelasan:

(r=@rot90)dengan cara inline menciptakan pegangan fungsi yang rdigunakan untuk memutar matriks 90 derajat. Jika argumen kedua, kdiberikan rmaka akan memutar k*90derajat matriks . Jadi ini sama dengan kode pseudo:

a + rot90(a) + rot180(a) + rot270(a)

Pyth , 13 byte

m+MCdC.u_CN3Q

Cobalah online!

J , 16 15 byte

[:+/|.@|:^:(<4)

Cobalah online!

MATL , 7 byte

,t@QX!+

Cobalah di MATL Online!

Penjelasan

Port jawaban Octave saya.

,        % 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)

R , 69 64 byte

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

Cobalah online!

Coba nomor tiga di codegolf. Dari 69 hingga 64 byte, terima kasih kepada Giuseppe!

APL (Dyalog Classic) , 8 byte

(⌽+⍉)⊖+⌽

Cobalah online!

Pari / GP , 31 byte

a->sum(i=1,4,a=Mat(Vecrev(a))~)

Cobalah online!

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)

Jelly , 7 byte

ṚZ$3СS

Cobalah online!

Disimpan 1 byte berkat Erik the Outgolfer (juga berkat saran untuk memperbaiki bug).

Bagaimana?

ṚZ $ 3СS || Program lengkap (monadik).

   3С || Lakukan ini 3 kali dan kumpulkan hasil dalam daftar
  $ || -> Terapkan dua tautan terakhir sebagai monad
Ṛ || –––> Balikkan,
 Z || –––> Transpose.
      S || Penjumlahan

Python 2 , 76 byte

f=lambda x,k=-2:k*x or[map(sum,zip(*r))for r in zip(x,f(zip(*x)[::-1],k+1))]

Cobalah online!

APL (Dyalog Classic) , 17 byte

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

Cobalah online!

APL NARS 34bytes 21 17 karakter

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

-2 karakter berkat ngn

-2 karakter karena operator komposit ∘ tampaknya lebih diutamakan pada +

sepertinya rota putar dari 90 °, ⌽⊖a putar dari 180 °, aa putar dari 270 ° seperti ⍉⌽

Jika ada operator p sebagai:

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

Operator p di atas akan sedemikian rupa sehingga jika g adalah fungsi argumen 1 (monadik?) Maka harus:

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

solusinya adalah pheraps 15 chars

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

Tetapi bisa lebih baik satu operator "terdiri n waktu" d sedemikian rupa sehingga "3 df w" adalah f (f (f (w ()))).

Sekarang saya menulis sesuatu tetapi terlalu rapuh tanpa perlu memeriksa jenis.

Tetapi saya lebih suka operator q yang mengulangi penulisan f dengan argumen m (tidak lengkap karena kasus kesalahan jenis tidak ditulis)

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

solusinya adalah 17 karakter tetapi saya lebih suka itu

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~

K4 / K (oK) , 23 8 byte

Larutan:

+/(|+:)\

Cobalah online!

Contoh:

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

Penjelasan:

Terima kasih kepada ngn untuk teknik transformasi yang disederhanakan.

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

Tambahan:

Dalam Q ini bisa ditulis sebagai

sum (reverse flip @) scan

Ruby , 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]}}}}

Cobalah online!

Ini bekerja berdasarkan elemen-demi-elemen, menemukan elemen terkait secara matematis, alih-alih memutar array. Bagian kuncinya adalah i,j=j,~i, yang berputar (i, j) searah jarum jam 90 derajat.

-2 byte terima kasih kepada Tn. Xcoder

-6 byte karena sum

Python 3 , 105 102 byte

3 byte terima kasih kepada Tn. Xcoder.

def f(a):l=len(a)-1;r=range(l+1);return[[a[i][j]+a[l-j][i]+a[l-i][l-j]+a[j][l-i]for j in r]for i in r]

Cobalah online!

Ruby 89 79 byte

-10 byte terima kasih kepada Unihedron

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

Cobalah online!

05AB1E , 12 byte

3FÂø}3F‚øε`+

Cobalah online!

Haskell , 84 83 67 byte

z=zipWith
e=[]:e
f l=foldr(\_->z(z(+))l.foldr(z(:).reverse)e)l"123"

Cobalah online!

Terima kasih kepada Laikoni dan benar-benar manusiawi karena menghemat banyak byte!

Sekam , 9 byte

F‡+↑4¡(↔T

Cobalah online!

Penjelasan

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

tinylisp , 132 byte

Mari kita ambil fungsi perpustakaan yang baru ditambahkan transposeuntuk memutar!

(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

Baris terakhir adalah fungsi lambda tanpa nama yang melakukan penjumlahan rotasi. Untuk benar-benar menggunakannya, Anda ingin menggunakannya duntuk mengikatnya ke sebuah nama. Cobalah online!

Tidak disatukan, dengan komentar

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

Attache , 20 byte

Sum@MatrixRotate&0:3

Cobalah online!

Penjelasan

Sum@MatrixRotate&0:3

MatrixRotate&0:3mengembang untuk, dengan masukan x, MatrixRotate[x, 0:3]yang pada gilirannya exapnds untuk [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Dengan kata lain, ini melakukan vektorisasi pada RHS. Kemudian, Sumambil jumlah semua matriks ini dengan satu level. Ini memberikan hasil yang diinginkan.

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 terima kasih kepada @ceilingcat .

Penjelasan:

Cobalah 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