Lấy một ma trận vuông chứa các số nguyên dương làm đầu vào và tính "tổng xoay" của ma trận.

Tổng số luân chuyển:

Lấy tổng của ma trận gốc và cùng một ma trận xoay 90, 180 và 270 độ.

Giả sử ma trận là:

 2    5    8
 3   12    8
 6    6   10

thì tổng số vòng quay sẽ là:

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

Các trường hợp thử nghiệm:

Đầu vào và đầu ra được phân tách bằng dấu gạch ngang, các trường hợp thử nghiệm khác nhau được phân tách bằng một dòng mới. Các trường hợp thử nghiệm ở các định dạng thuận tiện hơn có thể được tìm thấy ở đây .

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

Mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng. Giải thích rất được khuyến khích!

Python 2 , 78 byte

Cảm ơn Dennis vì đã chơi golf hai byte khỏi phương pháp đệ quy trước đây của tôi.

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

Hãy thử trực tuyến! hoặc Xem bộ kiểm tra.

Python 2 , 80 81 83 85 byte (không đệ quy)

Đưa đầu vào như một danh sách đơn .

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

Hãy thử trực tuyến!

Chức năng mã

Vì đây là một khoảng thời gian khá dài để phân tích tổng thể, chúng ta hãy kiểm tra từng mảnh một:

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.

Và cho chương trình thứ hai:

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: Tạo danh sách ma trận cần thiết bằng cách xoay đầu vào 3 lần 90 độ và thu thập kết quả. Sau đó, lấy tổng của các cột của mỗi ma trận trong chuyển vị của kết quả.

Octave , 29 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này thêm ma trận đầu vào với phiên bản xoay 90 độ của chính nó. Kết quả sau đó được thêm vào với một phiên bản xoay 180 độ của chính nó.

Sạch , 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)]

Hãy thử trực tuyến!

Từ các ma trận:

• X = transpose(reverse M): Xoay 90 độ
• Y = reverse(map reverse M): Xoay 180 độ
• Z = reverse(transpose M): Xoay 270 độ

Đây kéo khóa các nhà điều hành bổ sung hơn Mvà X, cũng như Yvà Z, và sau đó so với kết quả.

Ngôn ngữ Wolfram (Mathicala) , 28 byte

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

là \[Transpose].

Hãy thử trực tuyến!

Julia 0,6 , 29 byte

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

Hãy thử trực tuyến!

Tôi không thể nhận được dưới giải pháp của LukeS

Nhưng trong khi thử tôi đã nghĩ ra cái này, cái mà tôi nghĩ là dễ thương.

Đầu tiên chúng ta xác định lại phép nhân là phép toán xoay, trong đó lần đầu tiên là số lần cần xoay. Vì vậy, vì julia multipes bởi juxtap vị trí sau đó: 1xtrở thành rotr90(x,1)và 3xtrở thành rotr90(x,3)vv

Sau đó, chúng tôi viết ra tổng.

Julia 0,6 , 28 24 byte

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

Hãy thử trực tuyến!

~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

Thạch , 7 byte

ZU+µUṚ+

Hãy thử trực tuyến!

MATL , 9 byte

i3:"G@X!+

Dùng thử tại MATL Online

Giải trình

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

Octave , 33 byte

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

Hãy thử trực tuyến!

Giải trình:

(r=@rot90)trong một cách nội tuyến để tạo một hàm xử lý rđược sử dụng để xoay ma trận 90 độ. Nếu một đối số thứ hai, kđược đưa ra rthì nó sẽ xoay k*90độ ma trận . Vì vậy, điều này tương đương với mã giả:

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

Bình thường , 13 byte

m+MCdC.u_CN3Q

Hãy thử trực tuyến!

J , 16 15 byte

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

Hãy thử trực tuyến!

MATL , 7 byte

,t@QX!+

Hãy thử nó tại MATL Online!

Giải trình

Cổng câu trả lời Octave của tôi.

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

Hãy thử trực tuyến!

Cố gắng số ba tại codegolf. Từ 69 đến 64 byte nhờ Giuseppe!

APL (Dyalog Classic) , 8 byte

(⌽+⍉)⊖+⌽

Hãy thử trực tuyến!

Pari / GP , 31 byte

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

Hãy thử trực tuyến!

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)

Thạch , 7 byte

ṚZ$3СS

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ Erik the Outgolfer (cũng nhờ một gợi ý để sửa lỗi).

Làm sao?

ṚZ $ 3Đ¡S | | Chương trình đầy đủ (đơn âm).

   3Đ¡ | | Làm điều này 3 lần và thu thập kết quả trong một danh sách
  $ || -> Áp dụng hai liên kết cuối cùng dưới dạng đơn nguyên
| | | Càng về sau
 Z | | Cẩu con> <Transpose.
      S | | Tổng kết.

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

Hãy thử trực tuyến!

APL (Dyalog Classic) , 17 byte

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

Hãy thử trực tuyến!

APL NARS 34byte 21 17 ký tự

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

-2 ký tự nhờ ngn

-2 ký tự vì toán tử tổng hợp ∘ dường như được ưu tiên trên +

có vẻ như a xoay a từ 90 °, ⌽⊖a xoay a từ 180 °, ⌽⍉⌽⊖a xoay a từ 270 ° như

Nếu tồn tại toán tử p là:

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

Toán tử p ở trên sẽ sao cho nếu g là hàm đối số 1 (đơn âm?) Thì nên:

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

giải pháp sẽ là pheraps 15 ký tự

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

Nhưng có thể tốt hơn một toán tử "sáng tác n thời gian" d sao cho "3 df w" là f (f (f (w))).

Bây giờ tôi đã viết một cái gì đó nhưng nó quá mỏng manh mà không cần kiểm tra loại.

Nhưng tôi thích hơn toán tử q lặp lại việc soạn thảo f với đối số m (nó không hoàn thành vì các trường hợp lỗi của các loại không được viết)

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

giải pháp sẽ là 17 ký tự nhưng tôi thích nó

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

K4 / K (oK) , 23 8 byte

Dung dịch:

+/(|+:)\

Hãy thử trực tuyến!

Thí dụ:

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

Giải trình:

Cảm ơn ngn cho kỹ thuật biến đổi đơn giản.

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

Thêm:

Trong Q này có thể được viết là

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

Hãy thử trực tuyến!

Điều này hoạt động trên cơ sở từng yếu tố, tìm các yếu tố liên quan về mặt toán học, thay vì xoay mảng. Phần quan trọng là i,j=j,~i, xoay (i, j) theo chiều kim đồng hồ 90 độ.

-2 byte nhờ ông Xcoder

-6 byte vì sum

Python 3 , 105 102 byte

3 byte nhờ ông 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]

Hãy thử trực tuyến!

Ruby 89 79 byte

-10 byte nhờ Unihedron

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

Hãy thử trực tuyến!

05AB1E , 12 byte

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

Hãy thử trực tuyến!

Haskell , 84 83 67 byte

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

Hãy thử trực tuyến!

Cảm ơn Laikoni và hoàn toàn nhân đạo vì đã tiết kiệm rất nhiều byte!

Husk , 9 byte

F‡+↑4¡(↔T

Hãy thử trực tuyến!

Giải trình

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

Hãy dùng chức năng thư viện được thêm gần đây transposecho một vòng quay!

(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

Dòng cuối cùng là một hàm lambda chưa được đặt tên để thực hiện tổng hợp xoay. Để thực sự sử dụng nó, bạn sẽ muốn sử dụng dđể liên kết nó với một cái tên. Hãy thử trực tuyến!

Ungolfed, với ý kiến

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

Tùy viên , 20 byte

Sum@MatrixRotate&0:3

Hãy thử trực tuyến!

Giải trình

Sum@MatrixRotate&0:3

MatrixRotate&0:3mở rộng đến, với đầu vào x, MatrixRotate[x, 0:3]lần lượt thoát ra [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Đó là để nói, nó véc tơ trên RHS. Sau đó, Sumlấy tổng của tất cả các ma trận này theo một cấp. Điều này cho kết quả mong muốn.

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 nhờ @ceilingcat .

Giải trình:

Hãy thử trực tuyến.

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