กลุ่มเป็นโครงสร้างที่ใช้กันอย่างแพร่หลายในวิชาคณิตศาสตร์และมีการใช้งานในวิทยาการคอมพิวเตอร์ ความท้าทายรหัสนี้เป็นเรื่องเกี่ยวกับ # น้อยที่สุดของตัวละครเพื่อสร้างตารางกลุ่มสำหรับกลุ่มสารเติมแต่ง Z n

วิธีสร้างตาราง: สำหรับ Z _nองค์ประกอบคือ {0, 1, 2, ... , n-1} ตารางจะมี n แถวและคอลัมน์ n สำหรับรายการ ij-th ของตารางค่าคือ i + j mod n ตัวอย่างเช่นใน Z ₃รายการ 1-2 (แถวที่ 2 คอลัมน์ที่ 3 หากคุณนับแถว / คอลัมน์เริ่มต้นเป็น 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}/

Python 2, 66 ไบต์

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

หมุนรายการโดยการ popping และต่อท้ายอีกครั้ง

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

ลองออนไลน์!

Pyth , 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) หมายถึง "hook" ซึ่งเป็นฟังก์ชันคอมโพสิตที่รันอินพุตผ่าน g (ฟังก์ชัน unary) จากนั้นอินพุตและผลลัพธ์ของ g ถึง f (ฟังก์ชันไบนารี) คำตอบคือส้อมมีส่วนประกอบ|(โมดูลัส) +/~@i.และ ส่วนหลังคือ "ตารางผลบวกที่ประกอบด้วย - รายการของดัชนี - จนถึง" ( i.เป็นบิตrangeใน Python)

อ็อกเทฟ 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 ++ ซึ่งส่งผ่าน n ถึง rdi และตัวชี้ไปยังการจัดสรรผ่าน 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ไม่ตรงกันนี้เลื่อนแถวไปทางซ้ายในแต่ละครั้ง สุดท้ายเราต้องกำจัดตัวละครที่ไม่เกี่ยวข้องและเข้าร่วมทุกอย่างด้วยการขึ้นบรรทัดใหม่

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 จากช่วงและผลในช่วง[A1]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 -R5 ไบต์

Æ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

ลองออนไลน์!

Forth (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