Girdi olarak pozitif tam sayılar içeren kare bir matris alın ve matrisin "döndürülmüş toplamını" hesaplayın.

Döndürülmüş toplam:

Orijinal matrisin toplamını ve aynı matrisin 90, 180 ve 270 derece döndürülmüş şekilde alın.

Diyelim ki matris:

 2    5    8
 3   12    8
 6    6   10

o zaman döndürülmüş toplam:

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

Test durumları:

Çizgilerle ayrılmış girdi ve çıktılar, yeni bir çizgiyle ayrılmış farklı test durumları. Test senaryolarını daha uygun formatlarda burada bulabilirsiniz .

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

Her dilde bayt cinsinden en kısa kod kazanır. Açıklamalar şiddetle tavsiye edilir!

Python 2,78 bayt

Benim önceki özyinelemeli yaklaşım kapalı iki bayt golf için Dennis teşekkürler .

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

Çevrimiçi deneyin! veya Bir test takımına bakın.

Python 2 , 80 81 83 85 bayt (özyinelemeli olmayan)

Tekli bir liste olarak girdi alır .

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

Çevrimiçi deneyin!

Kod işlevselliği

Bu bir bütün olarak analiz etmek için oldukça uzun olduğu için, her bir bölümü inceleyelim:

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.

Ve ikinci program için:

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: Girişi 3 kez 90 derece döndürerek ve sonuçları toplayarak gereken matrislerin listesini oluşturur. Ardından, sonucun transpozisyonundaki her matrisin sütunlarının toplamını alın.

Octave , 29 bayt

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

Çevrimiçi deneyin!

açıklama

Bu, giriş matrisini 90 derece döndürülmüş bir versiyonuyla ekler. Sonuç daha sonra 180 derece döndürülmüş bir versiyonuyla eklenir.

Temiz , 110 bayt

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

Çevrimiçi deneyin!

Matrislerden:

• X = transpose(reverse M): 90 derece dönme
• Y = reverse(map reverse M): 180 derece dönme
• Z = reverse(transpose M): 270 derece dönme

Bu aşkın toplama operatörünü fermuarlar Mve Xyanı sıra Yve Zve sonuçlara bitti.

Wolfram Dili (Mathematica) , 28 bayt

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

olduğunu \[Transpose].

Çevrimiçi deneyin!

Julia 0.6 , 29 bayt

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

Çevrimiçi deneyin!

Luke'un çözümünün altına giremedim

Ama denemeye başladım, sanırım bu çok sevimli.

İlk önce çarpma işlemini döndürme işlemi olarak yeniden tanımlarız; burada ilk kez döndürülecek zaman sayısı vardır. Yani Julia yan yana 1xgeldiğinde çoğaldığından beri: olur rotr90(x,1)ve 3xolur rotr90(x,3)vb.

Sonra toplamı yazarız.

Julia 0.6 , 28 24 bayt

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

Çevrimiçi deneyin!

~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

Jöle , 7 bayt

ZU+µUṚ+

Çevrimiçi deneyin!

MATL , 9 bayt

i3:"G@X!+

MATL Online'da deneyin

açıklama

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 bayt

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

Çevrimiçi deneyin!

Açıklama:

(r=@rot90)rmatrisi 90 derece döndürmek için kullanılan bir işlev tutamaç oluşturma yolunda . Eğer ikinci bir argüman kverilirse, ro zaman matris k*90derecelerini döndürür. Yani bu sözde koda eşdeğerdir:

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

Pyth , 13 bayt

m+MCdC.u_CN3Q

Çevrimiçi deneyin!

J , 16 15 bayt

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

Çevrimiçi deneyin!

MATL , 7 bayt

,t@QX!+

MATL Online'da deneyin !

açıklama

Octave cevabımın limanı.

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

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

Çevrimiçi deneyin!

Codegolf'ta üç numarayı dene. Giuseppe sayesinde 69'dan 64 bayta!

APL (Dyalog Klasik) , 8 bayt

(⌽+⍉)⊖+⌽

Çevrimiçi deneyin!

Pari / GP , 31 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 77 bayt

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)

Jöle , 7 bayt

ṚZ$3СS

Çevrimiçi deneyin!

Outgolfer Erik sayesinde 1 bayt kurtarıldı (ayrıca bir hatayı düzeltmek için bir öneri sayesinde).

Nasıl?

$Z $ 3СS || Tam program (monadik).

   3С || Bunu 3 kez yapın ve sonuçları bir listede toplayın
  $ || -> Son iki linki monad olarak uygula
Ṛ || –––> Ters,
 Z || –––> Transpose.
      S || Toplama.

Python 2,76 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Klasik) , 17 bayt

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

Çevrimiçi deneyin!

APL NARS 34bytes 21 17 karakter

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

Ngn sayesinde -2 karakter

-2 karakter, çünkü operatör kompoziti ∘, +

⌽⍉a 90 ° döndürür, 180a 180 ° döndürür, ⌽⍉⌽⊖a 270 ° döndürür as

Varsa, p operatörü olarak:

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

Yukarıdaki p operatörü, eğer g bir 1 argüman fonksiyonu ise (monadik?) Olması gereken şekilde olacaktır:

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

çözüm pheraps 15 karakter olurdu

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

Ancak "n dn" den oluşan bir operatör "3 df w" f (f (f (w))) olacak şekilde daha iyi olabilir.

Şimdi bir şey yazdım ama ihtiyaç tipi kontrolü olmadan çok kırılgan.

Ama f 'nin f dizgesini m argümanı ile tekrarlayan q operatörünü daha çok seviyorum (tamamlanmadı çünkü türlerin hata durumları yazılmadı)

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

çözüm 17 karakter olurdu ama ben onu tercih ederim

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

K4 / K (oK) , 23 8 bayt

Çözüm:

+/(|+:)\

Çevrimiçi deneyin!

Örnek:

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

Açıklama:

Basitleştirilmiş dönüşüm tekniği için ngn sayesinde .

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

Ekstra:

Q'da bu şu şekilde yazılabilir

sum (reverse flip @) scan

Ruby , 74 72 66 bayt

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

Çevrimiçi deneyin!

Bu, diziyi döndürmek yerine, ilişkili öğeleri matematiksel olarak bulmak yerine, öğeye göre esasına göre çalışır. Anahtar bölüm i,j=j,~i(i, j) saat yönünde 90 derece döndürür.

Bay Xcoder sayesinde -2 bayt

-6 bayt nedeniyle sum

Python 3 , 105 102 bayt

Bay Xcoder sayesinde 3 bayt.

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]

Çevrimiçi deneyin!

Yakut 89 79 bayt

Unihedron sayesinde -10 bayt

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

Çevrimiçi deneyin!

05AB1E , 12 bayt

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

Çevrimiçi deneyin!

Haskell , 84 83 67 bayt

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

Çevrimiçi deneyin!

Çok bayt tasarrufu için Laikoni ve tamamen insanlık için teşekkürler !

Kabuğu , 9 bayt

F‡+↑4¡(↔T

Çevrimiçi deneyin!

açıklama

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 bayt

transposeDöndürmek için yeni eklenen kütüphane işlevini ele alalım !

(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

Son satır, döndürme toplamını gerçekleştiren adsız bir lambda işlevidir. Gerçekten kullanmak için, donu bir isme bağlamak için kullanmak isteyeceksiniz . Çevrimiçi deneyin!

Ungolfed, yorumlarla

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

Ataşesi , 20 bayt

Sum@MatrixRotate&0:3

Çevrimiçi deneyin!

açıklama

Sum@MatrixRotate&0:3

MatrixRotate&0:3girişi ile, genişler x, MatrixRotate[x, 0:3], dönüş exapnds 'de [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Yani, RHS üzerinden vektörleşiyor. Ardından, Sumtüm bu matrislerin toplamını bir seviye alır. Bu istenen sonucu verir.

Java 8, 135 133 bayt

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

@Ceilingcat sayesinde -2 bayt .

Açıklama:

Çevrimiçi deneyin.

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