Les groupes sont une structure largement utilisée en mathématiques et ont des applications en informatique. Ce défi de code concerne le moins de caractères pour créer une table de groupe pour le groupe additif Z _n .

Comment le tableau est construit: Pour Z _n , les éléments sont {0, 1, 2, ..., n-1}. Le tableau aura n lignes et n colonnes. Pour l'entrée ij-e du tableau, la valeur est i + j mod n. Par exemple, dans Z ₃ , l'entrée 1-2nd (2e ligne, 3e colonne si vous comptez la ligne / colonne de départ comme 1) est (1 + 2)% 3 = 0 (voir exemple de sortie).

Entrée: un entier positif, n

Sortie: un tableau qui est une présentation textuelle de Z _n , construit comme décrit ci-dessus et affiché comme indiqué ci-dessous dans les exemples de sorties. Les espaces sont facultatifs

Exemple d'entrée: 3

Exemple de sortie:

0 1 2
1 2 0
2 0 1

Exemple d'entrée: 5

Exemple de sortie:

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)

(En supposant que ⎕IO=0cela fonctionne sur ngn / apl par défaut, les autres APL ont généralement besoin d'une ⎕IO←0première.)

{⍵|∘.+⍨⍳⍵}

Explication:

• ⍳⍵: les nombres [0..⍵)
• ∘.+⍨: créer une table de somme
• ⍵|: nombres dans le tableau mod⍵

GolfScript (13 caractères)

Je comprends de votre commentaire sur la réponse de Claudiu que les espaces entre les éléments d'une rangée ne sont pas nécessaires. Sur cette compréhension:

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

Démo en ligne

Dissection:

~        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

Si un espace est nécessaire, pour 20 caractères:

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

Python 2, 66 octets

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

Fait pivoter la liste en éclatant et en rajoutant.

Python 3, 53 octets

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

Utilise la même méthode que @ mbomb007, mais en abusant en printtant que fonction.

05AB1E , 10 8 octets

ݨDδ+I%»

Essayez-le en ligne!

Explication

         # 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       

Réponse précédente: 10 octets

ݨDvDðý,À}

Essayez-le en ligne!

Mon premier essai de golf au 05AB1E.

Explication de la réponse précédente

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

Gelée , 4

Ḷṙ`G

Essayez-le en ligne!

Pyth , 16

JVQXQjdJ=J+tJ]hJ

Imprime la table avec un espace approprié.

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

Explication:

                   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

Lecture à partir de stdin et production d'un tableau 2D (qui est identique à l'échantillon de la question).

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

Si une fonction qui prend une chaîne de suffit, (|+/~@i.)@".. Si une fonction prenant un entier suffit, |+/~@i.devrait être suffisante.

Explication: f g dans J (pour les fonctions f, g) désigne un "crochet", qui est une fonction composite qui exécute l'entrée via g (une fonction unaire) puis l'entrée et le résultat de g via f (une fonction binaire). La réponse est une fourche avec des composants |(module) et +/~@i.. La dernière partie est "une table de sommes composée avec une liste d'indices jusqu'à" ( i.c'est un peu comme rangeen Python).

Octave, 23

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

Python 2, 67

Essayez-les tous les deux ici

J'utilise le fractionnement de liste pour "faire tourner" les ntemps de liste , en l'imprimant à chaque fois. (68 caractères)

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

J'ai réussi à obtenir un caractère plus court que le précédent avec un truc bizarre. (67 caractères)

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)

Code machine x86-64 (Linux), 80 64 octets

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

J'espérais que cette solution ne serait que de quelques octets plus courte pour pouvoir battre certaines des autres soumissions sur ce post. Il y a une possibilité si j'utilise certaines des versions 32 ou 16 bits des registres, je pourrais raser quelques octets. La conversion de nombreux registres en versions d'adressage 32 bits a permis d'économiser 16 octets.

Fondamentalement, cette fonction est appelée à partir d'un programme C / C ++ qui a passé n via rdi et un pointeur vers une allocation via rsi. Le pointeur de rsi est en fait de 1 octet à partir de la fin de l'allocation, car la table est construite à l'envers. Cela facilite la conversion d'un entier en caractères ASCII imprimables (en prenant un certain nombre x mod 10 et en convertissant le résultat en ASII).

Pour voir le code d'encapsuleur C ++ et les commentaires sur l'assembly, consultez mon référentiel .

Pari / GP , 26 octets

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

Essayez-le en ligne!

MathGolf , 10 8 octets

r░y\Åo╫;

Essayez-le en ligne!

-2 octets grâce à Jo King

Explication

Je vais utiliser un exemple d'entrée 3pour l'explication

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)

Vous pouvez également le faire r░y\(Åo╫, ce qui diminue le nombre de boucles de 1 et ignore la suppression après la boucle.

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 caractères

Un travail terriblement paresseux.

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

Exécutez-le ici . (La première ligne consiste à simuler stdin).

Explication :

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

À la fin du programme, la pile contient chacun des tableaux avec des sauts de ligne entre eux. L'interpréteur sort ce qui reste sur la pile, donnant le résultat souhaité.

CJam, 14 caractères

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

Testez-le ici.

Explication

L'idée est de répéter la chaîne de 0à N-1, mais de la diviser en blocs de N+1. Cette incompatibilité déplace la ligne vers la gauche à chaque fois. Enfin, nous devons nous débarrasser du caractère étranger et tout joindre à des nouvelles lignes.

Voici le code éclaté, ainsi que le contenu de la pile pour l'entrée 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"]

Le résultat est imprimé automatiquement à la fin du programme. (Remarque: le contenu de la pile pour l'étape finale est techniquement un tableau mixte contenant des nombres et des caractères de nouvelle ligne, pas une chaîne contenant uniquement des caractères.)

Alternativement, 11 caractères

Avec l'ajout récent ew(c'est plus récent que le défi - il renvoie toutes les sous-chaînes qui se chevauchent de longueur donnée), on pourrait faire 11 octets:

l~,2*))ewN*

Voici comment celui-ci fonctionne:

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 octets

:q&+G\

Essayez-le en ligne!

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

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées, sous forme d'entier, n, de la plage [A1]et les sorties vers la plage A2.Resize(n,n).

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

Perl 6 , 23 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et imprime la matrice dans le format donné avec des espaces. Si nous pouvons simplement renvoyer quelque chose à la place, alors le .putpeut être supprimé.

Explication:

                   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

Fusain , 13 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Remarque: Espace de fin. Explication:

Ｎθ              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 caractères, 30 octets

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

tester:

  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 

ici la langue n'a pas besoin de commentaires ...

Japt -R, 5 octets

ÆZéXn

Essayez-le

Si l'utilisation d'une virgule comme séparateur n'est pas valide, ajoutez un octet pour aucun séparateur:

ÆZ¬éXn

Essayez-le

Ou 2 octets pour utiliser un espace:

ÆZéXn)¸

Essayez-le

R , 37 octets

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

Crée un vecteur de 0 à n-1, et ajoute séquentiellement 1, puis 2 ... puis n, et module la matrice par la longueur du vecteur, qui est n.

Essayez-le en ligne!

Forth (gforth) , 53 octets

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

Essayez-le en ligne!

Explication

Boucle imbriquée qui génère une nouvelle ligne tous les n nombres

Explication du code

: 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