Gruppen sind eine in der Mathematik weit verbreitete Struktur und finden Anwendung in der Informatik. Bei dieser Code-Herausforderung geht es um die geringste Anzahl von Zeichen, um eine Gruppentabelle für die additive Gruppe Z _n zu erstellen .

Aufbau der Tabelle: Für Z _n sind die Elemente {0, 1, 2, ..., n-1}. Die Tabelle enthält n Zeilen und n Spalten. Für den ij-ten Eintrag der Tabelle ist der Wert i + j mod n. Zum Beispiel ist in Z ₃ der 1-2. Eintrag (2. Zeile, 3. Spalte, wenn Sie die Startzeile / Spalte als 1 zählen) (1 + 2)% 3 = 0 (siehe Beispielausgabe).

Eingabe: eine positive ganze Zahl, n

Ausgabe: Eine Tabelle, die eine Textdarstellung von Z _{n ist} , wie oben beschrieben aufgebaut und wie unten in den Beispielausgaben gezeigt angezeigt wird. Leerzeichen sind optional

Beispieleingabe: 3

Beispielausgabe:

0 1 2
1 2 0
2 0 1

Beispieleingabe: 5

Beispielausgabe:

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)

(Vorausgesetzt, ⎕IO=0es funktioniert standardmäßig mit ngn / apl , andere APLs benötigen in der Regel eine ⎕IO←0erste.)

{⍵|∘.+⍨⍳⍵}

Erläuterung:

• ⍳⍵: die Zahlen [0..⍵)
• ∘.+⍨: Erstellen Sie eine Summentabelle
• ⍵|: Zahlen in der Tabelle mod⍵

GolfScript (13 Zeichen)

Ich verstehe aus Ihrem Kommentar zu Claudius Antwort, dass Leerzeichen zwischen den Elementen einer Zeile nicht erforderlich sind. Nach diesem Verständnis:

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

Online-Demo

Präparation:

~        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

Wenn Leerzeichen erforderlich sind, für 20 Zeichen:

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

Python 2, 66 Bytes

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

Dreht die Liste durch Poppen und erneutes Anhängen.

Python 3, 53 Bytes

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

Verwendet die gleiche Methode wie @ mbomb007, missbraucht jedoch printals Funktion.

05AB1E , 10 8 Bytes

ݨDδ+I%»

Probieren Sie es online aus!

Erläuterung

         # 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       

Vorherige Antwort: 10 Bytes

ݨDvDðý,À}

Probieren Sie es online aus!

Mein erster Golfversuch in 05AB1E.

Erklärung der vorherigen Antwort

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

Gelee , 4

Ḷṙ`G

Probieren Sie es online aus!

Pyth , 16

JVQXQjdJ=J+tJ]hJ

Druckt die Tabelle mit dem richtigen Leerzeichen.

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

Erläuterung:

                   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

Lesen von stdin und Erstellen eines 2D-Arrays (das das gleiche wie das Beispiel in der Frage darstellt).

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

Wenn eine Funktion mit einem String ausreicht , (|+/~@i.)@".. Wenn eine Funktion mit einer Ganzzahl ausreicht, |+/~@i.sollte dies ausreichen.

Erläuterung: f g In J (für Funktionen f, g) wird ein "Hook" bezeichnet, bei dem es sich um eine zusammengesetzte Funktion handelt, die die Eingabe durch g (eine unäre Funktion) und dann die Eingabe und das Ergebnis von g bis f (eine Binärfunktion) ausführt. Die Antwort ist eine Gabel mit Komponenten |(Modul) und +/~@i.. Der letzte Teil ist "Tabelle der Summen, die mit einer Liste von Indizes bis zusammengesetzt sind" ( i.ist ein bisschen wie rangein Python).

Oktave, 23

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

Python 2, 67

Probieren Sie beide hier aus

Ich verwende die Listenaufteilung, um die Listenzeiten zu "drehen" nund jedes Mal zu drucken. (68 Zeichen)

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

Ich habe es geschafft, es mit einem seltsamen Trick um einen Charakter kürzer als oben zu machen. (67 Zeichen)

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

Ich hatte gehofft, dass diese Lösung nur ein paar Bytes kürzer ist, um einige der anderen Beiträge in diesem Beitrag schlagen zu können. Wenn ich einige der 32- oder 16-Bit-Versionen der Register verwende, besteht die Möglichkeit, dass ich einige Bytes einspare. Durch das Konvertieren vieler Register in die 32-Bit-Adressierungsversionen wurden 16 Byte eingespart.

Grundsätzlich wird diese Funktion von einem C / C ++ - Programm aufgerufen, das n über rdi und einen Zeiger auf eine Zuordnung über rsi übergeben hat. Der Zeiger, den rsi hat, ist tatsächlich 1 Byte vom Ende der Zuordnung entfernt, da die Tabelle rückwärts erstellt wird. Dies erleichtert die Konvertierung einer Ganzzahl in druckbare ASCII-Zeichen (indem Sie eine Zahl x mod 10 nehmen und das Ergebnis in ASII konvertieren).

Schauen Sie sich mein Repo an , um den C ++ - Wrapper-Code und Kommentare zur Assembly zu sehen .

Pari / GP , 26 Bytes

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

Probieren Sie es online aus!

MathGolf , 10 8 Bytes

r░y\Åo╫;

Probieren Sie es online aus!

-2 Bytes dank Jo King

Erläuterung

Ich werde Beispieleingabe 3für die Erklärung verwenden

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)

Sie können dies auch tun r░y\(Åo╫, wodurch die Anzahl der Schleifen um 1 verringert wird und das Verwerfen nach der Schleife übersprungen wird.

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 Zeichen

Ein schrecklich fauler Job.

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

Führen Sie es hier aus . (Erste Zeile ist die Simulation von stdin).

Erklärung :

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

Wenn das Programm endet, enthält der Stapel jedes der Arrays mit Zeilenumbrüchen dazwischen. Der Interpreter gibt aus, was noch auf dem Stapel ist, und liefert das gewünschte Ergebnis.

CJam, 14 Zeichen

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

Testen Sie es hier.

Erläuterung

Die Idee ist, den String von 0bis zu wiederholen N-1, ihn aber in Blöcke von aufzuteilenN+1 . Diese Nichtübereinstimmung verschiebt die Zeile jedes Mal nach links. Zuletzt müssen wir den fremden Charakter loswerden und alles mit Zeilenumbrüchen verbinden.

Hier ist der explodierte Code zusammen mit dem Stapelinhalt für die Eingabe 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"]

Das Ergebnis wird am Ende des Programms automatisch gedruckt. (Beachten Sie, dass der Stapelinhalt für den letzten Schritt technisch gesehen ein gemischtes Array ist, das Zahlen und Zeilenumbrüche enthält, und keine Zeichenfolge, die nur Zeichen enthält.)

Alternativ 11 Zeichen

Mit der jüngsten Hinzufügung ew(dies ist neuer als die Herausforderung - es werden alle überlappenden Teilzeichenfolgen mit der angegebenen Länge zurückgegeben) könnten 11 Bytes ausgeführt werden:

l~,2*))ewN*

So funktioniert das:

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 Bytes

:q&+G\

Probieren Sie es online aus!

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

Anonyme VBE-Sofortfensterfunktion, die die Eingabe als Ganzzahl n vom Bereich [A1]und die Ausgaben in den Bereich übernimmt A2.Resize(n,n).

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

Perl 6 , 23 Bytes

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

Probieren Sie es online aus!

Anonymer Codeblock, der eine Zahl verwendet und die Matrix im angegebenen Format mit Leerzeichen druckt. Wenn wir stattdessen nur etwas zurückgeben können, .putkann das entfernt werden.

Erläuterung:

                   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

Holzkohle , 13 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Hinweis: Leerzeichen. Erläuterung:

Ｎθ              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 Zeichen, 30 Bytes

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

Prüfung:

  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 

hier braucht die sprache keine kommentare ...

Japt -R, 5 Bytes

ÆZéXn

Versuch es

Wenn die Verwendung eines Kommas als Trennzeichen nicht gültig ist, fügen Sie ein Byte ohne Trennzeichen hinzu:

ÆZ¬éXn

Versuch es

Oder 2 Bytes, um ein Leerzeichen zu verwenden:

ÆZéXn)¸

Versuch es

R , 37 Bytes

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

Erstellt einen Vektor von 0 bis n-1 und addiert nacheinander 1, dann 2 ... dann n und moduliert die Matrix um die Länge des Vektors, der n ist.

Probieren Sie es online aus!

Forth (gforth) , 53 Bytes

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

Probieren Sie es online aus!

Erläuterung

Verschachtelte Schleife, die alle n Zahlen eine neue Zeile ausgibt

Code Erklärung

: 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