Rotationssummation

26

Nehmen Sie eine quadratische Matrix mit positiven ganzen Zahlen als Eingabe und berechnen Sie die "gedrehte Summe" der Matrix.

Gedrehte Summe:

Nehmen Sie die Summe der Originalmatrix und derselben um 90, 180 und 270 Grad gedrehten Matrix.

Angenommen, die Matrix lautet:

 2    5    8
 3   12    8
 6    6   10

dann ist die gedrehte Summe:

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

Testfälle:

Eingabe und Ausgabe durch Bindestriche getrennt, verschiedene Testfälle durch einen Zeilenumbruch getrennt. Testfälle in bequemeren Formaten finden Sie hier .

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

Der kürzeste Code in Bytes in jeder Sprache gewinnt. Erklärungen sind ausdrücklich erwünscht!

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

Antworten:

9

Python 2 , 78 Bytes

Vielen Dank an Dennis, der zwei Bytes von meinem vorherigen rekursiven Ansatz abgezogen hat.

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

Probieren Sie es online! oder Sehen Sie sich eine Testsuite an.

Python 2 , 80 81 83 85 Bytes (nicht rekursiv)

Übernimmt die Eingabe als Singleton-Liste .

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

Probieren Sie es online!

Code-Funktionalität

Da es ziemlich langwierig ist, es als Ganzes zu analysieren, sollten wir es Stück für Stück überprüfen:

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.

Und für das zweite Programm:

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: Generieren Sie die Liste der benötigten Matrizen, indem Sie die Eingabe dreimal um 90 Grad drehen und die Ergebnisse sammeln. Dann erhalten Sie die Summen der Spalten jeder Matrix in der Transponierung des Ergebnisses.

— Mr. Xcoder
quelle
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)Speichert zwei Bytes bei "normaler" Eingabe. Probieren Sie es online!
— Dennis
@ Tennis Danke! Ich dachte, lambda*ldass Python 2 aus irgendeinem Grund nicht möglich ist.
— Mr. Xcoder
Dies ist x,*y=1,2,3in Python 2.7 oder [*x]Python 3.4 nicht möglich, aber Ausdrücke mit Sternchen können auch in Python 1.6 für Funktionsargumente verwendet werden. Probieren Sie es online!
— Dennis
8

Oktave , 29 Bytes

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

Probieren Sie es online!

Erläuterung

Dies fügt die Eingabematrix mit einer um 90 Grad gedrehten Version von sich selbst hinzu. Das Ergebnis wird dann mit einer um 180 Grad gedrehten Version von sich selbst hinzugefügt.

— Luis Mendo
quelle
5

Sauber , 110 Bytes

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

Probieren Sie es online!

Aus den Matricies:

  • X = transpose(reverse M): 90-Grad-Drehung
  • Y = reverse(map reverse M): 180-Grad-Drehung
  • Z = reverse(transpose M): 270-Grad-Drehung

Dadurch wird der Additionsoperator über Mund Xsowie Yund Zund dann über die Ergebnisse gezippt.

— Οurous
quelle
5

Julia 0,6 , 29 Bytes

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

Probieren Sie es online!

Ich konnte nicht unter die Lösung von LukeS kommen

Aber als ich es versuchte, habe ich mir das ausgedacht, was ich irgendwie süß finde.

Zuerst definieren wir die Multiplikation neu, um die Rotationsoperation zu sein, wobei das erste Mal die Anzahl der Rotationen ist. Da sich Julia also durch Nebeneinander vermehrt, 1xwird rotr90(x,1)und 3xwird sierotr90(x,3) usw.

Dann schreiben wir die Summe aus.

— Lyndon White
quelle
5

Julia 0,6 , 28 24 Bytes

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

Probieren Sie es 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
quelle
1
Es ist vielleicht erwähnenswert, dass das Ausführen des [1]Beispiels dies tun sollte, ~reshape([1], (1,1))da auf diese Weise eine 1x1-Matrix in Julia 0.6 deklariert wird.
— Lyndon White
4

MATL , 9 Bytes

i3:"G@X!+

Probieren Sie es bei MATL Online aus

Erläuterung

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
quelle
4

Oktave , 33 Bytes

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

Probieren Sie es online!

Erläuterung:

(r=@rot90)Inline-Erstellung eines Funktionshandles rzum Drehen der Matrix um 90 Grad. Wenn ein zweites Argument kangegeben wird, rwird die Matrix um k*90Grad gedreht. Das entspricht also dem Pseudocode:

a + rot90(a) + rot180(a) + rot270(a)
— Stewie Griffin
quelle
3

MATL , 7 Bytes

,t@QX!+

Probieren Sie es bei MATL Online!

Erläuterung

Port meiner Oktavantwort.

,        % 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
quelle
3

R , 69 64 Bytes

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

Probieren Sie es online!

Versuch Nummer drei beim Codegolf. 69 bis 64 Bytes dank Giuseppe!

— Florian
quelle
Wenn Sie azu einem Funktionsargument wechseln, werden Bytes gespart, da Sie den gesamten {}Funktionskörper entfernen können. Auch das Portieren von Luis Mendos Octave-Ansatz könnte einige Bytes sparen? Schließlich bin ich nicht 100% sicher, aber ist t(apply(x,2,rev))gleichbedeutend mit apply(x,1,rev)?
— Giuseppe
Danke, ich konnte mich mit Tipp 1 und 3 verbessern. Ich habe es nicht geschafft Bytes bei der Rettung durch ein Argument Hinzufügen nzu , a()obwohl die Operation zu wiederholen.
— Florian
1
Ich wollte etwas wie diese
— 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
quelle
2

Gelee , 7 Bytes

ṚZ$3СS

Probieren Sie es online!

Dank Erik the Outgolfer 1 Byte gespeichert (auch dank eines Vorschlags zur Behebung eines Fehlers).

Wie?

ṚZ $ 3СS || Volles Programm (monadisch).

   3С || Tun Sie dies dreimal und sammeln Sie die Ergebnisse in einer Liste
  $ || -> Wende die letzten beiden Links als Monade an
Ṛ || –––> Rückwärts,
 Z || –––> Transponieren.
      S || Summe.
— Mr. Xcoder
quelle
2

APL (Dyalog Classic) , 17 Byte

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

Probieren Sie es online!

APL NARS 34 Bytes 21 17 Zeichen

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

-2 Zeichen dank ngn

-2 Zeichen, da der Operator Composite ∘ Vorrang vor + zu haben scheint

Es scheint, als ob Sie a von 90 ° drehen, a von 180 ° drehen, a von 270 ° drehen als

Wenn vorhanden, ist der Operator p als:

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

Der obige Operator p wäre so, dass wenn g eine 1-Argument-Funktion ist (monadisch?), Es sein sollte:

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

Die Lösung wären 15 Zeichen

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

Könnte aber besser ein Operator sein, der n-mal so "zusammengesetzt" ist, dass "3 df w" f (f (f (w))) ist.

Jetzt habe ich etwas geschrieben, aber es ist zu zerbrechlich, ohne dass man den Typ überprüfen muss.

Aber ich mag eher den Operator q, der die Wiederholung von f mit dem Argument m schreibt (es ist nicht vollständig, weil die Fehlerfälle der Typen nicht geschrieben sind).

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

Die Lösung wäre 17 Zeichen, aber ich bevorzuge es

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~
— RosLuP
quelle
270 könnte gerecht sein ⍉⌽und das Ganze ist für einen Zug geeignet
— ngn
Wenn eine solche existiert, dass gfwwww w gw ggw gggw ist, wäre die Antwort + / ⌽⍉f 4 / rho w
— RosLuP
Du meinst +/⌽∘⍉f 4⍴⊂⍵? Um vier Exemplare zu erhalten ⍵, sollten Sie sie zuerst beilegen ⊂. Haben ⌽⍉als Operand zu fkönnen, müssen sie in eine einzige Funktion wie folgt zusammensetzen : ⌽∘⍉. Das Mysteriöse fkönnte Scan (Backslash) sein, aber es gibt noch ein weiteres Detail, um das man sich kümmern muss - ⌽∘⍉wird ein linkes Argument bekommen, also müssen wir dafür sorgen, dass es ignoriert wird: +/{⌽⍉⍵}\4⍴⊂⍵oder +/⊢∘⌽∘⍉\4⍴⊂⍵.
— 22.
In meinem ersten Kommentar vorschlagen ich diesen Zug: ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽. Das kann zu noch kürzeren Lösungen führen, wenn Sie die Kringel geschickt neu anordnen und die Züge gut ausnutzen.
— 22.
@ngn sogar eine einfache {⍵ + ⍺} \ 1 2 3 4 Rückkehr Domain-Fehler
— RosLuP
2

K4 / K (OK) , 23 8 Bytes

Lösung:

+/(|+:)\

Probieren Sie es online!

Beispiel:

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

Erläuterung:

Danke an ngn für die vereinfachte Transformationstechnik.

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

Extra:

In Q könnte dies geschrieben werden als

sum (reverse flip @) scan
— Streetster
quelle
— ngn
Ich wusste, dass es einen besseren Weg gibt, die Transformationen anzuwenden!
— Straßenhändler
+ / (| + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA ist leider die gleiche Anzahl ... Gah kann das Markup auf Mobilgeräten nicht herausfinden.
— Streetster
Es scheint, dass das Markup in Kommentaren einen Fehler aufweist, nicht nur auf Mobilgeräten - Backslash, bevor Backquote die Dinge durcheinander bringt. Ich habe es vermieden, indem ich ein Leerzeichen eingefügt habe.
— ngn
2

Ruby , 74 72 66 Bytes

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

Probieren Sie es online!

Dies funktioniert Element für Element, indem die zugehörigen Elemente mathematisch ermittelt werden, anstatt das Array zu drehen. Der Schlüsselteil ist i,j=j,~i, der sich um 90 Grad im Uhrzeigersinn dreht (i, j).

-2 Bytes dank Mr. Xcoder

-6 Bytes wegen sum

— MegaTom
quelle
1

Ruby 89 79 Bytes

-10 Bytes dank Unihedron 

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

Probieren Sie es online!

— Asone Tuhid
quelle
1
Ich bin ziemlich sicher , dass Sie ersetzen können .map &:dupmit *1abzuschneiden vielen Zeichen. array*lengthErstellt ein neues Array und ist eine praktische Möglichkeit, einen flachen Klon zu erstellen.
— Unihedron
Eigentlich n=*mist noch kürzer.
— Unihedron
@Unihedron das ist das Problem, ich muss tief klonen
— Asone Tuhid
Scheint mir, dass es die Ausgabe nicht beeinflusst; Ich habe in Ihrem Link "Online
— testen" damit herumgespielt
Du hast recht, eigentlich brauchst du nicht mal einen flachen Klon, transposekümmert sich darum
— Asone Tuhid
1

Schale , 9 Bytes

F‡+↑4¡(↔T

Probieren Sie es online!

Erläuterung

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

tinylisp , 132 bytes

Nehmen wir die kürzlich hinzugefügte Bibliotheksfunktion transposefür einen Dreh!

(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

Die letzte Zeile ist eine unbenannte Lambda-Funktion, die eine Rotationssummierung durchführt. Um es tatsächlich zu verwenden, müssen Sie des an einen Namen binden. Probieren Sie es online!

Ungolfed, mit Kommentaren

(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
quelle
1

Attache , 20 Bytes

Sum@MatrixRotate&0:3

Probieren Sie es online!

Erläuterung

Sum@MatrixRotate&0:3

MatrixRotate&0:3erweitert , um mit Eingang x, MatrixRotate[x, 0:3], was wiederum zu exapnds [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]. Das heißt, es wird über die RHS vektorisiert. Nimmt Sumdann die Summe aller dieser Matrizen um eine Stufe. Dies ergibt das gewünschte Ergebnis.

— Conor O'Brien
quelle
1

Java 8, 135 133 Bytes

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 Bytes dank @ceilingcat .

Erläuterung:

Probieren Sie es online aus.

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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.