Penjumlahan rotasi

26

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!

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

Jawaban:

9

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.

— Tuan Xcoder
sumber
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)menyimpan dua byte dengan input "normal". Cobalah online!
— Dennis
@ Dennis Terima kasih! Saya pikir lambda*litu tidak mungkin dalam Python 2 karena beberapa alasan.
— Tn. Xcoder
Anda tidak dapat melakukannya x,*y=1,2,3dengan Python 2.7 atau [*x]Python 3.4, tetapi ekspresi berbintang dapat digunakan untuk argumen fungsi bahkan dalam Python 1.6. Cobalah online!
— Dennis
8

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.

— Luis Mendo
sumber
5

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.

— Suram
sumber
5

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.

— Lyndon White
sumber
5

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
— LukeS
sumber
1
Perlu dicatat bahwa untuk melakukan [1]contoh harus dilakukan ~reshape([1], (1,1))karena itulah bagaimana matriks 1x1 dinyatakan dalam julia 0.6.
— Lyndon White
4

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
— Suever
sumber
4

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)
— Stewie Griffin
sumber
3

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)
— Luis Mendo
sumber
3

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!

— Florian
sumber
Pindah ake argumen fungsi akan menghemat byte dengan memungkinkan Anda untuk menyingkirkan {}sekitar fungsi body. Juga, porting pendekatan Octave Luis Mendo mungkin menghemat beberapa byte? Akhirnya, saya tidak yakin 100% tetapi t(apply(x,2,rev))setara dengan apply(x,1,rev)?
— Giuseppe
Terima kasih, saya dapat meningkatkan dengan tip # 1 dan # 3. Saya tidak berhasil menyelamatkan byte dengan menambahkan argumen nuntuk a()mengulang operasi sekalipun.
— Florian
1
Saya maksudkan sesuatu seperti ini
— Giuseppe
2

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)
— Neil
sumber
2

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
— Tuan Xcoder
sumber
2

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
~
— RosLuP
sumber
270 bisa saja adil ⍉⌽dan semuanya cocok untuk kereta
— ngn
Jika ada satu f sehingga gfwwww adalah w gw ggw gggw jawabannya adalah + / ⌽⍉f 4 / rho w
— RosLuP
Maksudmu +/⌽∘⍉f 4⍴⊂⍵? Untuk mendapatkan empat salinan ⍵, pertama Anda harus melampirkannya ⊂. Untuk memiliki ⌽⍉sebagai operand untuk f, Anda harus menulis ke dalam fungsi tunggal seperti ini: ⌽∘⍉. Misterius fbisa berupa pemindaian (backslash), tetapi ada detail lain untuk dijaga - ⌽∘⍉akan mendapatkan argumen kiri, jadi kita harus membuatnya mengabaikannya: +/{⌽⍉⍵}\4⍴⊂⍵atau +/⊢∘⌽∘⍉\4⍴⊂⍵.
— ngn
Dalam komentar pertama saya saya menyarankan kereta ini: ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽. Itu bisa mengarah pada solusi yang lebih singkat jika Anda mengatur ulang coretan dengan cerdik dan memanfaatkan kereta dengan baik.
— ngn
@ngn bahkan {⍵ + ⍺} \ 1 2 3 4 kesalahan domain pengembalian
— sederhana
2

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
— streetster
sumber
— ngn
Saya tahu ada cara yang lebih baik untuk menerapkan transformasi!
— streetster
+ / (| + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA sayangnya jumlah yang sama ... Gah tidak dapat menemukan markup di ponsel.
— streetster
Tampaknya markup di komentar memiliki bug, tidak hanya pada ponsel - backslash sebelum backquote mengacaukan semuanya. Saya menghindarinya dengan memasukkan spasi.
— ngn
2

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

— MegaTom
sumber
1

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!

— Asone Tuhid
sumber
1
Saya cukup yakin Anda dapat mengganti .map &:dupdengan *1untuk memotong banyak karakter. array*lengthmenciptakan array baru dan merupakan cara praktis untuk mengkloning dangkal.
— Unihedron
Sebenarnya, n=*mini lebih pendek.
— Unihedron
@Unihedron itulah masalahnya, saya perlu kloning yang dalam
— Asone Tuhid
Menurut saya itu tidak mempengaruhi output; Saya mengutak-atiknya di tautan "coba online" dan hasilnya tampaknya tetap benar dengan perubahan itu
— Unihedron
Anda benar, sebenarnya Anda bahkan tidak perlu tiruan yang dangkal, transpose
— urus
1

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

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))))
— DLosc
sumber
1

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.

— Conor O'Brien
sumber
1

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
— Kevin Cruijssen
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.