Các nhóm là một cấu trúc được sử dụng rộng rãi trong Toán học và có các ứng dụng trong Khoa học Máy tính. Thử thách mã này là về số ít ký tự nhất để tạo bảng nhóm cho nhóm phụ gia Z _n .

Cách bảng được xây dựng: Đối với Z _n , các phần tử là {0, 1, 2, ..., n-1}. Bảng sẽ có n hàng và n cột. Đối với mục nhập ij-th của bảng, giá trị là i + j mod n. Ví dụ: trong Z ₃ , mục nhập 1-2 (hàng thứ 2, cột thứ 3 nếu bạn tính hàng / cột bắt đầu là 1) là (1 + 2)% 3 = 0 (xem đầu ra mẫu).

Đầu vào: một số nguyên dương, n

Đầu ra: một bảng là bản trình bày văn bản của Z _n , được xây dựng như mô tả ở trên và được hiển thị như bên dưới trong các đầu ra mẫu. Không gian là tùy chọn

Đầu vào mẫu: 3

Đầu ra mẫu:

0 1 2
1 2 0
2 0 1

Đầu vào mẫu: 5

Đầu ra mẫu:

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)

(Giả sử ⎕IO=0. Nó hoạt động trên ngn / apl theo mặc định, các APL khác có xu hướng cần ⎕IO←0trước.)

{⍵|∘.+⍨⍳⍵}

Giải trình:

• ⍳⍵: các số [0..⍵)
• ∘.+⍨: tạo bảng tổng
• ⍵|: Số trong bảng mod⍵

GolfScript (13 ký tự)

Tôi hiểu từ nhận xét của bạn về câu trả lời của Claudiu rằng khoảng trắng giữa các yếu tố của một hàng là không cần thiết. Về sự hiểu biết đó:

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

Bản demo trực tuyến

Mổ xẻ

~        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

Nếu khoảng trắng là cần thiết, trong 20 ký tự:

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

Python 2, 66 byte

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

Xoay danh sách bằng cách xuất hiện và nối lại.

Python 3, 53 byte

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

Sử dụng phương pháp tương tự như @ mbomb007, nhưng lạm dụng printnhư một hàm.

05AB1E , 10 8 byte

ݨDδ+I%»

Hãy thử trực tuyến!

Giải trình

         # 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       

Câu trả lời trước: 10 byte

ݨDvDðý,À}

Hãy thử trực tuyến!

Lần thử đầu tiên của tôi tại sân golf trong 05AB1E.

Giải thích về câu trả lời trước

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

Thạch , 4

Ḷṙ`G

Hãy thử trực tuyến!

Bình thường , 16

JVQXQjdJ=J+tJ]hJ

In bảng với khoảng trắng thích hợp.

./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

Giải trình:

                   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

Đọc từ stdin và tạo ra một mảng 2D (biểu hiện giống như mẫu trong câu hỏi).

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

Nếu một hàm lấy một chuỗi đủ (|+/~@i.)@".. Nếu một hàm lấy một số nguyên đủ, |+/~@i.nên là đủ.

Giải thích: f g trong J (đối với các hàm f, g) biểu thị một "hook", là một hàm tổng hợp chạy đầu vào thông qua g (một hàm unary) và sau đó là đầu vào và kết quả của g qua f (một hàm nhị phân). Câu trả lời là một ngã ba với các thành phần |(mô đun) và +/~@i.. Phần sau là "bảng tổng hợp được soạn thảo với danh sách các chỉ số-upto" ( i.hơi giống rangevới Python).

Tháng mười, 23

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

Con trăn 2, 67

Hãy thử cả hai ở đây

Tôi sử dụng chia tách danh sách để "xoay" nthời gian danh sách , in mỗi lần. (68 ký tự)

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

Tôi đã xoay sở để có được một nhân vật ngắn hơn những nhân vật trên với một mánh khóe kỳ lạ. (67 ký tự)

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)

Mã máy x86-64 (Linux), 80 64 byte

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

Tôi đã hy vọng giải pháp này chỉ ngắn hơn một vài byte để có thể đánh bại một số bài nộp khác trên bài đăng này. Có khả năng nếu tôi sử dụng một số phiên bản 32 hoặc 16 bit của các thanh ghi tôi có thể tắt một vài byte. Chuyển đổi rất nhiều thanh ghi thành các phiên bản địa chỉ 32 bit được lưu 16 byte.

Về cơ bản, hàm này được gọi từ chương trình C / C ++, truyền n qua rdi và con trỏ tới cấp phát qua rsi. Con trỏ mà rsi có thực sự là 1 byte từ cuối phân bổ, do bảng được xây dựng ngược. Điều này giúp dễ dàng chuyển đổi một số nguyên thành các ký tự ASCII có thể in được (được thực hiện bằng cách lấy một số số x mod 10 và chuyển đổi kết quả thành ASII).

Để xem mã trình bao bọc C ++ và nhận xét về hội đồng, hãy xem repo của tôi .

Pari / GP , 26 byte

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

Hãy thử trực tuyến!

MathGolf , 10 8 byte

r░y\Åo╫;

Hãy thử trực tuyến!

-2 byte nhờ Jo King

Giải trình

Tôi sẽ sử dụng ví dụ đầu vào 3để giải thích

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)

Bạn cũng có thể làm r░y\(Åo╫, điều này làm giảm số vòng lặp đi 1 và bỏ qua phần bỏ đi sau vòng lặp.

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

Golf, 20 ký tự

Một công việc lười biếng khủng khiếp.

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

Chạy nó ở đây . (Dòng đầu tiên là mô phỏng stdin).

Giải thích :

~                     # 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

Khi chương trình kết thúc, ngăn xếp chứa từng mảng với các dòng mới giữa chúng. Trình thông dịch xuất ra những gì còn lại trên ngăn xếp, cho kết quả mong muốn.

CJam, 14 ký tự

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

Kiểm tra nó ở đây.

Giải trình

Ý tưởng là lặp lại chuỗi từ 0đến N-1, nhưng chia nó thành các khối N+1. Sự không phù hợp này làm dịch chuyển hàng sang trái mỗi lần. Cuối cùng, chúng ta cần loại bỏ nhân vật ngoại lai và tham gia mọi thứ với dòng mới.

Đây là mã đã nổ, cùng với nội dung ngăn xếp cho đầu vào 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"]

Kết quả được in tự động vào cuối chương trình. (Lưu ý, nội dung ngăn xếp cho bước cuối cùng về mặt kỹ thuật là một mảng hỗn hợp chứa các số và ký tự dòng mới, không phải là một chuỗi chỉ chứa các ký tự.)

Ngoài ra, 11 ký tự

Với sự bổ sung gần đây ew(điều này mới hơn thử thách - nó trả về tất cả các chuỗi con chồng chéo có độ dài cho trước), người ta có thể thực hiện 11 byte:

l~,2*))ewN*

Đây là cách cái này hoạt động:

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 byte

:q&+G\

Hãy thử trực tuyến!

    # 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

VBA Excel, 77 byte

Hàm cửa sổ ngay lập tức VBE ẩn danh nhận đầu vào, dưới dạng số nguyên, n, từ phạm vi [A1]và đầu ra cho phạm vi A2.Resize(n,n).

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

Perl 6 , 23 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một số và in ma trận theo định dạng đã cho bằng dấu cách. Nếu chúng ta chỉ có thể trả lại một cái gì đó thay vào đó, thì .putcó thể được gỡ bỏ.

Giải trình:

                   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

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lưu ý: Không gian lưu trữ. Giải trình:

Ｎθ              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 ký tự, 30 byte

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

kiểm tra:

  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 

ở đây ngôn ngữ không cần bình luận ...

Japt -R, 5 byte

ÆZéXn

Thử nó

Nếu sử dụng dấu phẩy làm dấu phân cách không hợp lệ thì hãy thêm một byte cho không có dấu phân cách:

ÆZ¬éXn

Thử nó

Hoặc 2 byte để sử dụng một khoảng trắng:

ÆZéXn)¸

Thử nó

R , 37 byte

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

Tạo một vectơ từ 0 đến n-1 và tuần tự thêm 1, rồi 2 ... rồi n và điều chỉnh ma trận theo độ dài của vectơ, là n.

Hãy thử trực tuyến!

Forth (gforth) , 53 byte

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

Hãy thử trực tuyến!

Giải trình

Vòng lặp lồng nhau tạo ra một dòng mới mỗi n số

Giải thích mã

: 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