组是数学中广泛使用的结构，并且在计算机科学中具有应用。此代码挑战涉及为累加组Z _n创建组表的最少字符_数。

表格的构造方式：对于Z _n，元素为{0，1，2，...，n-1}。该表将具有n行和n列。对于表的第ij个条目，该值为i + j mod n。例如，在Z _3中，第1-2个条目（如果将起始行/列计算为1，则为第2行，第3列）为（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

杀伤人员地雷（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}/

Python 2，66字节

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

通过弹出并重新添加来旋转列表。

Python 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（一元函数）运行输入，然后通过f（二进制函数）运行g的输入和结果。答案是叉车的组件|（模数）和+/~@i.。后面的部分是“由索引列表组成的总和表”（i.有点像rangePython）。

八度，23

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

Python 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个字节。

基本上，此函数是从C / C ++程序调用的，该程序通过rdi传递n，并通过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╫;

在线尝试！

-2个字节，感谢Jo King

说明

我将使用示例输入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);}}

Golfscript，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字节

匿名VBE立即窗口函数，将输入（作为整数n）从range [A1]输入到range A2.Resize(n,n)。

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

Perl 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 ...然后n，并通过向量的长度n调制矩阵。

在线尝试！

第四（gforth），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