ใช้เมทริกซ์จตุรัสที่มีจำนวนเต็มบวกเป็นอินพุตและคำนวณ "ผลรวมการหมุน" ของเมทริกซ์

ผลรวมการหมุน:

หาผลรวมของเมทริกซ์ดั้งเดิมและเมทริกซ์เดียวกันหมุน 90, 180 และ 270 องศา

สมมติว่าเมทริกซ์คือ:

 2    5    8
 3   12    8
 6    6   10

จากนั้นผลรวมการหมุนจะเป็น:

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

กรณีทดสอบ:

อินพุตและเอาต์พุตคั่นด้วยเครื่องหมายขีดคั่นกรณีทดสอบที่แตกต่างกันคั่นด้วยบรรทัดใหม่ กรณีทดสอบในรูปแบบที่สะดวกมากขึ้นสามารถพบได้ที่นี่

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

รหัสสั้นที่สุดเป็นไบต์ในแต่ละภาษาชนะ คำอธิบายได้รับการสนับสนุนอย่างมาก!

Python 2 , 78 ไบต์

ขอบคุณเดนนิสสำหรับการเล่นกอล์ฟสองไบต์จากวิธีการเรียกซ้ำก่อนหน้านี้ของฉัน

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

ลองออนไลน์! หรือดูชุดทดสอบ

Python 2 , 80 81 83 85ไบต์ (ไม่เรียกซ้ำ)

จะเข้าเป็นรายการเดี่ยว

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

ลองออนไลน์!

ฟังก์ชั่นรหัส

เนื่องจากนี่เป็นความยาวค่อนข้างมากในการวิเคราะห์โดยรวมลองตรวจสอบทีละชิ้น:

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.

และสำหรับโปรแกรมที่สอง:

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:สร้างรายการเมทริกซ์ที่ต้องการโดยหมุนอินพุต 3 ครั้ง 90 องศาและรวบรวมผลลัพธ์ จากนั้นรับผลรวมของคอลัมน์ของแต่ละเมทริกซ์ในผลลัพธ์ของทรานสโพส

อ็อกเทฟ 29 ไบต์

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

ลองออนไลน์!

คำอธิบาย

สิ่งนี้จะเพิ่มเมทริกซ์อินพุตด้วยเวอร์ชันที่หมุนได้ 90 องศา จากนั้นผลลัพธ์จะถูกเพิ่มเข้าไปด้วยเวอร์ชันที่หมุนได้ 180 องศา

ทำความสะอาด , 110 ไบต์

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

ลองออนไลน์!

จาก matricies:

• X = transpose(reverse M): การหมุน 90 องศา
• Y = reverse(map reverse M): การหมุน 180 องศา
• Z = reverse(transpose M): การหมุน 270 องศา

รหัสไปรษณีย์นี้ผู้ประกอบการนอกจากนี้มากกว่าMและXเช่นเดียวกับYและZแล้วมากกว่าผล

ภาษา Wolfram (Mathematica)ขนาด 28 ไบต์

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

\[Transpose]เป็น

ลองออนไลน์!

Julia 0.6 , 29 bytes

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

ลองออนไลน์!

ฉันไม่สามารถลงมาด้านล่าง แก้ไขปัญหาของลุค

แต่ในการพยายามฉันทำสิ่งนี้ขึ้นมาซึ่งฉันคิดว่ามันน่ารักดี

ก่อนอื่นเราทำการคูณการคูณใหม่เพื่อเป็นการหมุนโดยที่ครั้งแรกคือจำนวนครั้งที่จะหมุน ดังนั้นตั้งแต่ julia multipes โดยการตีข่าวแล้ว: 1xกลายเป็นrotr90(x,1)และ3xกลายเป็นrotr90(x,3)ฯลฯ

จากนั้นเราก็เขียนผลรวม

Julia 0.6 , 28 24 ไบต์

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

ลองออนไลน์!

~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

เยลลี่ขนาด 7 ไบต์

ZU+µUṚ+

ลองออนไลน์!

MATL , 9 ไบต์

i3:"G@X!+

ลองใช้ที่MATL Online

คำอธิบาย

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

อ็อกเทฟ 33 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

(r=@rot90)ในวิธีการสร้างฟังก์ชั่นการจัดการที่rใช้ในการหมุนเมทริกซ์ 90 องศา ถ้าอาร์กิวเมนต์ตัวที่สองkถูกกำหนดให้rมันจะหมุนk*90องศาเมทริกซ์ ดังนั้นนี่เท่ากับโค้ดหลอก:

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

Pyth , 13 ไบต์

m+MCdC.u_CN3Q

ลองออนไลน์!

J , 16 15 ไบต์

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

ลองออนไลน์!

MATL , 7 ไบต์

,t@QX!+

ลองที่MATL Online!

คำอธิบาย

พอร์ตของคำตอบ 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)

R , 69 64 ไบต์

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

ลองออนไลน์!

พยายามหมายเลขสามที่ codegolf จาก 69 ถึง 64 ไบต์ต้องขอบคุณ Giuseppe!

APL (Dyalog Classic) 8 ไบต์

(⌽+⍉)⊖+⌽

ลองออนไลน์!

Pari / GP , 31 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 77 ไบต์

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)

เยลลี่ขนาด 7 ไบต์

ṚZ$3СS

ลองออนไลน์!

บันทึก 1 ไบต์ด้วยErik the Outgolfer (ขอบคุณสำหรับคำแนะนำในการแก้ไขข้อบกพร่อง)

อย่างไร?

ṚZ $ 3СS || โปรแกรมเต็มรูปแบบ (monadic)

   3С || ทำเช่นนี้ 3 ครั้งและรวบรวมผลลัพธ์ในรายการ
  $ || -> ใช้สองลิงก์สุดท้ายเป็น monad
Ṛ || –––> ย้อนกลับ
 Z || –––> ไขว้
      S | | ผลบวก

Python 2 , 76 ไบต์

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

ลองออนไลน์!

APL (Dyalog Classic)ขนาด 17 ไบต์

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

ลองออนไลน์!

APL NARS 34bytes 21 17 ตัวอักษร

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

-2 chars ขอบคุณ ngn

-2 ตัวอักษรเนื่องจากตัวดำเนินการคอมโพสิต∘ดูเหมือนว่ามีความสำคัญเหนือกว่าใน

ดูเหมือน⌽⍉aหมุนจาก 90 °, ⌽⊖aหมุนจาก 180 °, ⌽⍉⌽⊖aหมุนจาก 270 °เป็น as

หากมีอยู่ตัวดำเนินการ p เป็น:

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

ตัวดำเนินการ p ด้านบนจะเป็นเช่นนั้นถ้า g เป็นฟังก์ชันอาร์กิวเมนต์ 1 (monadic?) ควรเป็น:

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

การแก้ปัญหาจะเป็น pheraps 15 ตัวอักษร

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

แต่น่าจะดีกว่าโอเปอเรเตอร์ "เวลา n ประกอบ" d เช่นนั้น "3 df w" คือ f (f (f (w)))

ตอนนี้ฉันเขียนบางอย่าง แต่มันเปราะบางมากเกินไปโดยไม่ต้องตรวจสอบประเภท

แต่ฉันชอบตัวดำเนินการ q ที่ทำซ้ำประกอบกับ f ด้วยอาร์กิวเมนต์ m (ไม่สมบูรณ์เพราะกรณีข้อผิดพลาดของชนิดไม่ถูกเขียน)

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

การแก้ปัญหาจะเป็น 17 ตัวอักษร แต่ฉันชอบมัน

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

K4 / K (oK) , 23 8 ไบต์

วิธีการแก้:

+/(|+:)\

ลองออนไลน์!

ตัวอย่าง:

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

คำอธิบาย:

ขอบคุณngnสำหรับเทคนิคการแปลงแบบง่าย

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

เสริม:

ใน Q นี้สามารถเขียนเป็น

sum (reverse flip @) scan

Ruby , 74 72 66 ไบต์

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

ลองออนไลน์!

วิธีนี้ใช้งานได้แบบองค์ประกอบต่อองค์ประกอบค้นหาองค์ประกอบที่เกี่ยวข้องทางคณิตศาสตร์แทนที่จะหมุนอาร์เรย์ ส่วนสำคัญคือi,j=j,~iซึ่งจะเปลี่ยน (i, j) ตามเข็มนาฬิกา 90 องศา

-2 ไบต์ขอบคุณ Mr. Xcoder

-6 ไบต์เนื่องจาก sum

Python 3 , 105 102 ไบต์

3 ไบต์ขอบคุณ Mr. 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]

ลองออนไลน์!

Ruby 89 79 ไบต์

-10 ไบต์ขอบคุณ Unihedron

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

ลองออนไลน์!

05AB1E , 12 ไบต์

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

ลองออนไลน์!

Haskell , 84 83 67 ไบต์

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

ลองออนไลน์!

ขอบคุณLaikoniและมนุษย์โดยสิ้นเชิงสำหรับการบันทึกจำนวนมาก!

Husk , 9 ไบต์

F‡+↑4¡(↔T

ลองออนไลน์!

คำอธิบาย

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 ไบต์

ลองใช้ฟังก์ชั่นห้องสมุดที่เพิ่งเพิ่มเข้าไป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

บรรทัดสุดท้ายคือฟังก์ชั่นแลมบ์ดาที่ไม่มีชื่อซึ่งจะทำการรวมการหมุน ในการใช้งานจริงคุณจะต้องใช้dผูกกับชื่อ ลองออนไลน์!

Ungolfed พร้อมความคิดเห็น

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

ทูตขนาด 20 ไบต์

Sum@MatrixRotate&0:3

ลองออนไลน์!

คำอธิบาย

Sum@MatrixRotate&0:3

MatrixRotate&0:3ขยายไปกับข้อมูลx, MatrixRotate[x, 0:3]ซึ่ง exapnds [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]หันไป กล่าวคือมันเวกเตอร์เหนือ RHS จากนั้นSumนำผลรวมของเมทริกซ์เหล่านี้ทั้งหมดมาหนึ่งระดับ สิ่งนี้จะให้ผลลัพธ์ที่ต้องการ

Java 8, 135 133 ไบต์

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 ไบต์ขอบคุณ@ceilingcat @ceilingcat

คำอธิบาย:

ลองออนไลน์

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