회전 요약

26

양의 정수를 포함하는 정사각 행렬을 입력으로 취하고 행렬의 "회전 합계"를 계산합니다.

회전 합계 :

원래 행렬과 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

각 언어에서 가장 짧은 바이트 코드가 이깁니다. 설명을 적극 권장합니다!

code-golf  math  number  array-manipulation  matrix 
— 스튜이 그리핀
소스

답변:

9

파이썬 2 , 78 바이트

이전 재귀 접근 방식에서 2 바이트를 골라 낸 데니스 에게 감사합니다 .

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

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

파이썬 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 : 입력을 90 도씩 3 번 회전하고 결과를 수집하여 필요한 행렬 목록을 생성합니다. 그런 다음 결과의 조옮김에서 각 행렬의 열 합계를 가져옵니다.

— 미스터 Xcoder
소스
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)"정상"입력으로 2 바이트를 저장합니다. 온라인으로 사용해보십시오!
— 데니스
@Dennis 감사합니다! lambda*l어떤 이유로 파이썬 2에서는 불가능 하다고 생각했습니다 .
— Mr. Xcoder
당신은 할 수없는 x,*y=1,2,3파이썬 2.7 또는 [*x]파이썬 3.4에 있지만, 별표 표현도 파이썬 1.6에서 함수 인수에 사용할 수 있습니다. 온라인으로 사용해보십시오!
— 데니스
5

클린 , 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, 다음 결과 위에.

— 뇨
소스
5

줄리아 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
— LukeS
소스
1
julia 0.6에서 1x1 행렬이 선언되는 방식이기 때문에 [1]예제 를 수행해야한다는 점에 주목할 가치가 ~reshape([1], (1,1))있습니다.
— Lyndon White
4

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
— 서버
소스
4

옥타브 , 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)
— 스튜이 그리핀
소스
3

MATL , 7 바이트

,t@QX!+

MATL Online 에서 사용해보십시오 !

설명

내 옥타브 포트 답변입니다.

,        % 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)
— 루이스 멘도
소스
3

R , 69 64 바이트

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

온라인으로 사용해보십시오!

codegolf에서 3 번 시도하십시오. 주세페 덕분에 69에서 64 바이트까지!

— 플로리안
소스
a함수 인수로 이동 {}하면 함수 본문 주위를 제거하여 바이트를 절약 할 수 있습니다 . 또한 Luis Mendo의 Octave 방식을 이식하면 바이트가 절약 될 수 있습니까? 마지막으로, 나는 100 % 확신하지만입니다 t(apply(x,2,rev))동등 apply(x,1,rev)?
— Giuseppe
감사합니다. 팁 # 1 및 # 3으로 개선 할 수있었습니다. 그래도 작업을 반복 n하기 a()위해 인수 를 추가하여 바이트를 저장하는 데 성공하지 못했습니다 .
— Florian
1
나는 이와 같은
— Giuseppe
2

자바 스크립트 (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)
— 닐
소스
2

APL (Dyalog Classic) , 17 바이트

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

온라인으로 사용해보십시오!

APL NARS 34 바이트 21 17 자

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

ngn 덕분에 -2 문자

연산자 복합 ∘가 +보다 우선 순위가 높은 것으로 보이므로 -2 문자

90a는 90 °에서 회전하고 ⌽⊖a는 180 °에서 회전하고 ⌽⍉⌽⊖a는 270 °에서 ⍉⌽

존재하는 경우 연산자 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 인수 함수 (모노 딕?) 인 경우 다음과 같아야합니다.

"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

그러나 "3 df w"가 f (f (f (w)))가되도록 "한번 구성된 n"d 연산자가 더 나을 수 있습니다.

이제 나는 무언가를 썼지 만 유형 검사가 필요하지 않으면 너무 약합니다.

그러나 나는 인수 m으로 f의 작성을 반복하는 연산자 q를 더 좋아합니다 (유형의 오류 사례가 작성되지 않았기 때문에 완전하지 않습니다)

∇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
~
— RosLuP
소스
270은 정당 할 수 있고 ⍉⌽모든 것이 기차에
— ngn
만약 gfwwww가 w gw ggw gggw와 같은 존재라면 대답은 + / ⌽⍉f 4 / rho w 일 것입니다
— RosLuP
당신은 의미 +/⌽∘⍉f 4⍴⊂⍵합니까? 네 개의 사본을 얻으려면 ⍵먼저로 묶어야합니다 ⊂. ⌽⍉피연산자로 사용 하려면 다음 f과 같은 단일 함수로 작성해야합니다 ⌽∘⍉. 수수께끼 f는 스캔 (백 슬래시) 일 수 있지만 돌봐야 할 또 다른 세부 사항이 있습니다 ⌽∘⍉. 왼쪽 인수를 얻으므로 무시해야합니다. +/{⌽⍉⍵}\4⍴⊂⍵또는 +/⊢∘⌽∘⍉\4⍴⊂⍵.
— ngn
첫 번째 의견에서 나는이 열차를 제안하고 있었다 : ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽. 스 쿼글을 영리하게 재정렬하고 열차를 잘 활용하면 솔루션이 더 짧아 질 수 있습니다.
— ngn
@ngn 간단한 {⍵ + ⍺} \ 1 2 3 4 도메인 반환 오류
— RosLuP
2

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
— 스트리트 스터
소스
— ngn
나는 변환을 적용하는 더 좋은 방법이 있다는 것을 알고 있었다!
— streetster
+ / (| + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA 는 슬프게도 같은 수 ... Gah는 모바일에서 마크 업을 파악할 수 없습니다.
— streetster
백 따옴표가 물건을 엉망으로 만들기 전에 주석-마크 업에 버그가있는 것 같습니다. 공백을 삽입하여 피했습니다.
— ngn
2

루비 , 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, 시계 방향으로 90도 회전합니다 (i, j).

Mr. Xcoder 덕분에 -2 바이트

-6 바이트로 인해 sum

— 메가 톰
소스
1

루비 89 79 바이트

Unihedron 덕분에 -10 바이트 

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

온라인으로 사용해보십시오!

— Asone Tuhid
소스
1
나는 꽤 당신이 대체 할 수있는 확신 .map &:dup과 *1문자를 많이 잘라. array*length새 배열을 만들고 얕은 복제를위한 편리한 방법입니다.
— Unihedron
실제로 n=*m는 더 짧습니다.
— Unihedron
@Unihedron 그 문제입니다, 난 딥 클론해야합니다
— Asone Tuhid
출력에 영향을 미치지 않는 것 같습니다. 나는 당신의 "온라인으로 시도"링크에서 그것을
— 피들 링했고 결과
당신은 맞습니다, 실제로 당신은 심지어 얕은 복제가 필요하지 않습니다, transpose그것을 처리합니다
— Asone Tuhid
1

껍질 , 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]]
— ბიმო
소스
1

작은 입술 , 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이름에 바인딩하는 데 사용하고 싶을 것 입니다. 온라인으로 사용해보십시오!

댓글이없는 언 골프

(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
소스
1

첨부 , 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모든 행렬의 합계를 한 수준 씩 취합니다. 원하는 결과를 제공합니다.

— 코너 오브라이언
소스
1

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

@ceilingcat 덕분에 -2 바이트 .

설명:

온라인으로 사용해보십시오.

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
— 케빈 크루이 센
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.