그룹은 수학에서 널리 사용되는 구조이며 컴퓨터 과학에 응용 프로그램이 있습니다. 이 코드 문제는 추가 그룹 Z _n에 대한 그룹 테이블을 작성하는 문자 수가 가장 적습니다 .

테이블 구성 방법 : Z _n 의 경우 요소는 {0, 1, 2, ..., n-1}입니다. 테이블에는 n 개의 행과 n 개의 열이 있습니다. 테이블의 ij 번째 항목의 경우 값은 i + j mod n입니다. 예를 들어, Z ₃ 에서 1-2 번째 항목 (시작 행 / 열을 1로 계산하는 경우 두 번째 행, 세 번째 열)은 (1 + 2) % 3 = 0입니다 (샘플 출력 참조).

입력 : 양의 정수, n

출력 : Z _n 의 텍스트 표현 인 테이블 로, 위에서 설명한대로 구성되며 샘플 출력에 아래 표시된대로 표시됩니다. 공백은 선택 사항입니다

샘플 입력 : 3

샘플 출력 :

0 1 2
1 2 0
2 0 1

샘플 입력 : 5

샘플 출력 :

0 1 2 3 4
1 2 3 4 0
2 3 4 0 1
3 4 0 1 2
4 0 1 2 3

APL (10)

(가정합니다 ⎕IO=0. 기본적 으로 ngn / apl 에서 작동 하지만 다른 APL은 ⎕IO←0먼저 필요합니다 .)

{⍵|∘.+⍨⍳⍵}

설명:

• ⍳⍵: 숫자 [0..⍵)
• ∘.+⍨: 합계 테이블 만들기
• ⍵|: 표의 숫자 mod⍵

GolfScript (13 자)

Claudiu의 답변에 대한 귀하의 의견을 통해 행 요소 사이의 공백은 필요하지 않습니다. 그 이해에 :

~.,{.n\(+}@(*

온라인 데모

해부:

~        Parse the input into an integer
.,       Duplicate it, turn the second into an array [0,...,n-1]
{        Loop: top of stack is the previous row
  .n\    Push a newline and a copy of the previous row
  (+     Rotate the first element to the end to get the new row
}@(*     Perform loop n-1 times

공백이 필요한 경우 20 자 :

~.,{.(+}@(*]{' '*n}/

파이썬 2, 66 바이트

def f(n):R=range(n);exec"print''.join(map(str,R));R+=R.pop(0),;"*n

팝업하고 다시 추가하여 목록을 회전시킵니다.

파이썬 3, 53 바이트

def f(n):*R,=range(n);[print(*R[i:]+R[:i])for i in R]

@ mbomb007과 동일한 방법을 사용하지만 print함수로 남용 합니다.

05AB1E , 10 8 바이트

ݨDδ+I%»

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

설명

         # Implicit input n = 3                  [3]
Ý        # Push range(0,3)                       [[0,1,2,3]]
 ¨       # Pop last element                      [[0,1,2]]
  D      # Duplicate                             [[0,1,2],[0,1,2]]
   δ     # Apply next operation double vectorized
    +    # Vectorized addition                   [[[0,1,2],[1,2,3],[2,3,4]]]
     I   # Push input                            [[[0,1,2],[1,2,3],[2,3,4]],3]
      %  # Elementwise modulo 3                  [[[0,1,2],[1,2,0],[2,0,1]]]
       » # " ".join(x) followed by newline       ["0 1 2\n1 2 0\n2 0 1\n"]
           for every x in list       

이전 답변 : 10 바이트

ݨDvDðý,À}

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

05AB1E에서 골프를 처음 시도했습니다.

이전 답변에 대한 설명

           # Implicit input n = 3                   [3]
Ý          # Push range(0,3)                        [[0,1,2,3]]
 ¨         # Pop last element.                      [[0,1,2]]
  D        # Duplicate                              [[0,1,2],[0,1,2]]
   v     } # Pop list and loop through elements     [[0,1,2]]
    D      # Duplicate                              [[0,1,2],[0,1,2]]
     ð     # Push space char                        [[0,1,2],[0,1,2], " "]
      ý    # Pop list a and push string a.join(" ") [[0,1,2],"0 1 2"]
       ,   # Print string with trailing newline     [[0,1,2]] Print: "0 1 2"
        À  # Rotate list                            [[1,2,0]]  

젤리 , 4

Ḷṙ`G

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

피 이스 , 16

JVQXQjdJ=J+tJ]hJ

적절한 공백으로 테이블을 인쇄합니다.

./pyth.py -c "JVQXQjdJ=J+tJ]hJ" <<< 5
0 1 2 3 4
1 2 3 4 0
2 3 4 0 1
3 4 0 1 2
4 0 1 2 3

설명:

                   Automatic: Q=eval(input())
JVQ                J = range(Q)
XQ                 repeat Q times
  jdJ              print J, joined on " "
  =J               J =
    +tJ]hJ             tail(J) + [head(J)] (J[1:] + [J[-1]]])

J, 20

stdin에서 읽고 2D 배열을 생성합니다 (문제의 샘플과 동일하게 렌더링 됨).

(|+/~@i.)@".}:1!:1]3

문자열을받는 함수가 충분하면 (|+/~@i.)@".. 정수를 사용하는 함수이면 |+/~@i.충분합니다.

설명 : f g J (함수 f, g의 경우)는 "후크"를 나타냅니다. 이는 "g"(단항 함수)를 통해 입력을 실행 한 다음 g와 f (2 진 함수)를 통해 입력 및 결과를 실행하는 복합 함수입니다. 답은 구성 요소 |(모듈러스)와가 있는 포크입니다 +/~@i.. 후자는 "인덱스 목록으로 구성된 합계 테이블"입니다 ( 파이썬에서 i.약간 비슷 함 range).

옥타브, 23

@(n)mod((r=0:n-1)'+r,n)

파이썬 2, 67

둘 다 여기에서 시도하십시오

목록 분할을 사용하여 목록을 "회전"하여 n매번 인쇄합니다. (68 자)

def f(n):
 l=range(n)
 for i in l:print''.join(map(str,l[i:]+l[:i]))

이상한 트릭으로 위의 문자보다 짧은 문자를 얻을 수있었습니다. (67 자)

def f(n):
 l=range(n)
 for i in l:print''.join(`l[i:]+l[:i]`)[1::3]

MATLAB (28)

k=exp(0:n-1)
mod(log(k'*k),n)

x86-64 머신 코드 (Linux), 80 64 바이트

0000000000000000 <zn_asm>:
   0:   6a 0a                   pushq  $0xa
   2:   89 f9                   mov    %edi,%ecx
   4:   ff c9                   dec    %ecx

0000000000000006 <zn_asm.l1>:
   6:   c6 06 0a                movb   $0xa,(%rsi)
   9:   48 ff ce                dec    %rsi
   c:   89 fb                   mov    %edi,%ebx
   e:   ff cb                   dec    %ebx

0000000000000010 <zn_asm.l2>:
  10:   89 c8                   mov    %ecx,%eax
  12:   01 d8                   add    %ebx,%eax
  14:   31 d2                   xor    %edx,%edx
  16:   f7 f7                   div    %edi
  18:   89 d0                   mov    %edx,%eax

000000000000001a <zn_asm.l3>:
  1a:   31 d2                   xor    %edx,%edx
  1c:   48 f7 34 24             divq   (%rsp)
  20:   83 c2 30                add    $0x30,%edx
  23:   88 16                   mov    %dl,(%rsi)
  25:   48 ff ce                dec    %rsi
  28:   85 c0                   test   %eax,%eax
  2a:   75 ee                   jne    1a <zn_asm.l3>
  2c:   ff cb                   dec    %ebx
  2e:   85 db                   test   %ebx,%ebx
  30:   7d de                   jge    10 <zn_asm.l2>
  32:   ff c9                   dec    %ecx
  34:   85 c9                   test   %ecx,%ecx
  36:   7d ce                   jge    6 <zn_asm.l1>
  38:   58                      pop    %rax
  39:   48 89 f0                mov    %rsi,%rax
  3c:   48 ff c0                inc    %rax
  3f:   c3                      retq

이 솔루션 이이 게시물의 다른 제출물을 이길 수 있기 위해 몇 바이트 더 짧아지기를 바랐습니다. 32 비트 또는 16 비트 버전의 레지스터 중 일부를 사용하면 몇 바이트를 줄일 수 있습니다. 많은 레지스터를 32 비트 주소 지정 버전으로 변환하면 16 바이트가 절약되었습니다.

기본적으로이 함수는 n을 rdi를 통해 전달한 C / C ++ 프로그램과 rsi를 통한 할당에 대한 포인터에서 호출됩니다. rsi가 가진 포인터는 테이블이 거꾸로 지어 졌기 때문에 실제로 할당 끝에서 1 바이트입니다. 이를 통해 정수를 인쇄 가능한 ASCII 문자로 쉽게 변환 할 수 있습니다 (일부 숫자 x mod 10을 사용하고 결과를 ASII로 변환하여 수행됨).

C ++ 래퍼 코드와 어셈블리에 대한 주석을 보려면 내 repo를 확인하십시오 .

Pari / GP , 26 바이트

n->matrix(n,n,x,y,x+y-2)%n

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

MathGolf , 10 8 바이트

r░y\Åo╫;

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

Jo King 덕분에 -2 바이트

설명

3설명을 위해 예제 입력 을 사용하겠습니다.

r          range(0, n) ([0, 1, 2])
 ░         convert to string (implicit map) (['0', '1', '2'])
  y        join array without separator to string or number ('012')
   \       swap top elements ('012', 3)
    Å      start block of length 2 (for-loop, loops 3 times ('012'))
     o     print TOS without popping
      ╫    left-rotate bits in int, list/str ('012' => '120' => '201' => '012')
       ;   discard TOS (prevents final print)

또한 r░y\(Åo╫루프 수를 1만큼 줄이고 루프 후 삭제를 건너 뜁니다.

C-96

void g(int k){int i;for(i=0;i<k*k;i++){if(i&&!(i%k))puts("\n");printf("%i ",((i/k)+(i%k))%k);}}

골프 스크립트, 20 자

정말 게으른 직업.

~:j,{:x;j,{x+j%}%n}/

여기에서 실행하십시오 . (첫 번째 줄은 stdin을 시뮬레이션하는 것입니다).

설명 :

~                     # evaluate input (turn string "5" into number 5)
:j                    # store into variable j
,                     # turn top of stack into range(top), e.g. 5 --> [0, 1, 2, 3, 4]
{...}/                # for each element in the array... 
  :x;                 # store the element into x and pop from the stack
  j,                  # put range(j) on the stack ([0, 1, 2, 3, 4] again)
  {...}%              # map the array with the following:
      x+j%            # add x and mod the resulting sum by j
  n                   # put a newline on the stack

프로그램이 종료되면 스택에는 개행이있는 각 배열이 포함됩니다. 인터프리터는 스택에 남은 내용을 출력하여 원하는 결과를 제공합니다.

CJam, 14 자

l~_)_@,*/Wf<N*

여기에서 테스트하십시오.

설명

아이디어에서 문자열을 반복하는 것입니다 0으로 N-1만 블록으로 분할 N+1. 이 불일치는 매번 행을 왼쪽으로 이동시킵니다. 마지막으로, 우리는 관계없는 성격을 제거하고 개행으로 모든 것을 결합해야합니다.

다음은 input의 스택 내용과 함께 분해 된 코드 3입니다.

l~              "Read and eval input."; [3]
  _             "Duplicate.";           [3 3]
   )            "Increment.";           [3 4]
    _           "Duplicate.";           [3 4 4]
     @          "Rotate.";              [4 4 3]
      ,         "Get range.";           [4 4 [0 1 2]]
       *        "Repeat.";              [4 [0 1 2 0 1 2 0 1 2 0 1 2]
        /       "Split.";               [[[0 1 2 0] [1 2 0 1] [2 0 1 2]]
         Wf<    "Truncate each line.";  [[[0 1 2] [1 2 0] [2 0 1]]
            N*  "Join with newlines.";  ["012
                                          120
                                          201"]

프로그램이 끝나면 결과가 자동으로 인쇄됩니다. (마지막 단계의 스택 내용은 기술적으로 문자 만 포함하는 문자열이 아니라 숫자와 개행 문자를 포함하는 혼합 배열입니다.)

또는 11 자

최근의 추가 ew(이것은 도전보다 새로운 것입니다-주어진 길이의 모든 겹치는 부분 문자열을 반환합니다)로 11 바이트를 할 수 있습니다

l~,2*))ewN*

이 방법은 다음과 같습니다.

l~           "Read and eval input."; [3]
  ,          "Get range.";           [[0 1 2]]
   2*        "Repeat twice.";        [[0 1 2 0 1 2]]
     )       "Pop last.";            [[0 1 2 0 1] 2]
      )      "Increment.";           [[0 1 2 0 1] 3]
       ew    "Get substrings.";      [[[0 1 2] [1 2 0] [2 0 1]]
         N*  "Join with newlines.";  ["012
                                       120
                                       201"]

MATL , 6 바이트

:q&+G\

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

    # implicit input, say n = 3
:   # range
    # stack: [1, 2, 3]
q   # decrement
    # stack: [0, 1, 2]
&+  # sum with itself and transpose with broadcast
    # stack:
    # [0 1 2
    #  1 2 3
    #  2 3 4]
G   # paste input
    # stack: [0 1 2; 1 2 3; 2 3 4], 3
\   # elementwise modulo
    # implicit output with spaces

Excel VBA, 77 바이트

범위 [A1]에서 출력을 정수로 입력하고 범위 로 출력하는 익명의 VBE 즉시 창 함수입니다 A2.Resize(n,n).

[A2:IU255]="=IF(MAX(ROW()-1,COLUMN())-1<$A$1,MOD(ROW()+COLUMN()-3,$A$1),"""")

펄 6 , 23 바이트

{.rotate(.all).put}o|^*

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

숫자를 가져와 주어진 형식으로 공백과 함께 행렬을 인쇄하는 익명 코드 블록입니다. 대신 무언가를 반환 .put할 수 있다면 제거 할 수 있습니다.

설명:

                   o|^*    # Transform the input into the range 0..input-1
{                 }        # And pass it into the function
 .rotate                   # Rotate the range by
        (.all)             # Each of the range
              .put         # And print each of them separated by spaces

숯 , 13 바이트

ＮθＥθ⪫Ｅθ﹪⁺ιλθ 

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 참고 : 후행 공간. 설명:

Ｎθ              Input `n` as a number into variable
   θ            `n`
  Ｅ             Map over implicit range
      θ         `n`
     Ｅ          Map over implicit range
         ι      Current row
        ⁺       Plus
          λ     Current column
       ﹪        Modulo
           θ    `n`
    ⪫           Cast row to string and join with spaces
                Implicitly print each row on its own line

APL (NARS), 15 자, 30 바이트

{⊃{⍵⌽k}¨k←0..⍵}

테스트:

  f←{⊃{⍵⌽k}¨k←0..⍵}
  f 4
0 1 2 3 4
1 2 3 4 0
2 3 4 0 1
3 4 0 1 2
4 0 1 2 3
  f 3
0 1 2 3
1 2 3 0
2 3 0 1
3 0 1 2
  f 2
0 1 2
1 2 0
2 0 1
  f 1
0 1
1 0
  f 0
0 

여기에 언어는 의견이 필요하지 않습니다 ...

Japt -R, 5 바이트

ÆZéXn

시도 해봐

구분자로 쉼표를 사용할 수없는 경우 구분 기호가없는 바이트를 추가하십시오.

ÆZ¬éXn

시도 해봐

또는 공백을 사용하려면 2 바이트 :

ÆZéXn)¸

시도 해봐

R , 37 바이트

sapply(x<-1:scan()-1,`+`,x)%%sum(x|1)

0부터 n-1까지의 벡터를 만들고 1, 2, 2를 차례로 더한 다음 벡터의 길이 (n)로 행렬을 변조합니다.

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

4 번째 (2 번째) , 53 바이트

: f dup 0 do cr dup 0 do i j + over mod . loop loop ;

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

설명

n 개의 숫자마다 개행을 출력하는 중첩 루프

코드 설명

: f             \ start new word definition
  dup 0 do      \ set loop parameters and loop from 0 to n-1
    cr          \ output a newline
    dup 0 do    \ loop from 0 to n-1 again
      i j +     \ get the sum of the row and column number
      over mod  \ modulo with n
      .         \ print (with space)
    loop        \ end inner loop
  loop          \ end outer loop
;               \ end word definition