I gruppi sono una struttura ampiamente usata in matematica e hanno applicazioni in informatica. Questa sfida al codice riguarda il minor numero di caratteri per creare una tabella di gruppo per il gruppo additivo Z _n .

Come viene costruita la tabella: per Z _n , gli elementi sono {0, 1, 2, ..., n-1}. La tabella avrà n righe e n colonne. Per l'i-esima voce della tabella, il valore è i + j mod n. Ad esempio, in Z ₃ , la 1-2a voce (2a riga, 3a colonna se si considera la riga / colonna iniziale come 1) è (1 + 2)% 3 = 0 (vedere l'output di esempio).

Input: un numero intero positivo, n

Output: una tabella che è una presentazione testuale di Z _n , costruita come descritto sopra e visualizzata come mostrato di seguito negli output di esempio. Gli spazi sono opzionali

Input di esempio: 3

Uscita campione:

0 1 2
1 2 0
2 0 1

Input di esempio: 5

Uscita campione:

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)

(Supponendo ⎕IO=0. Funziona su ngn / apl di default, altri APL tendono ad avere bisogno di un ⎕IO←0primo.)

{⍵|∘.+⍨⍳⍵}

Spiegazione:

• ⍳⍵: i numeri [0..⍵)
• ∘.+⍨: crea una tabella di somma
• ⍵|: numeri nella tabella mod⍵

GolfScript (13 caratteri)

Capisco dal tuo commento sulla risposta di Claudiu che gli spazi bianchi tra gli elementi di una riga non sono necessari. Su questa comprensione:

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

Demo online

Dissezione:

~        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

Se è necessario uno spazio, per 20 caratteri:

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

Python 2, 66 byte

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

Ruota l'elenco spuntando e aggiungendo nuovamente.

Python 3, 53 byte

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

Utilizza lo stesso metodo di @ mbomb007, ma abusa printcome funzione.

05AB1E , 10 8 byte

ݨDδ+I%»

Provalo online!

Spiegazione

         # 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       

Risposta precedente: 10 byte

ݨDvDðý,À}

Provalo online!

Il mio primo tentativo di giocare a golf nel 05AB1E.

Spiegazione della risposta precedente

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

Jelly , 4

Ḷṙ`G

Provalo online!

Pyth , 16

JVQXQjdJ=J+tJ]hJ

Stampa la tabella con spazi bianchi adeguati.

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

Spiegazione:

                   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

Lettura da stdin e produzione di un array 2D (che rende lo stesso del campione nella domanda).

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

Se una funzione prendendo un sufficiente uno stringa, (|+/~@i.)@".. Se una funzione che accetta un numero intero è sufficiente, |+/~@i.dovrebbe essere sufficiente.

Spiegazione: f g in J (per le funzioni f, g) indica un "hook", che è una funzione composita che esegue l'input attraverso g (una funzione unaria) e quindi l'input e il risultato di g attraverso f (una funzione binaria). La risposta è una forcella con componenti |(modulo) e +/~@i.. L'ultima parte è "tabella di somme composte con lista di indici-fino a" ( i.è un po 'come rangein Python).

Ottava, 23

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

Python 2, 67

Provali entrambi qui

Uso la suddivisione dell'elenco per "ruotare" i ntempi dell'elenco , stampandolo ogni volta. (68 caratteri)

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

Sono riuscito a ottenere un personaggio più corto di quello sopra con uno strano trucco. (67 caratteri)

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 Codice macchina (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

Speravo che questa soluzione fosse più corta di pochi byte per poter battere alcune delle altre osservazioni su questo post. C'è una possibilità se uso alcune delle versioni a 32 o 16 bit dei registri, potrei radere qualche byte.La conversione di molti registri nelle versioni di indirizzamento a 32 bit ha consentito di risparmiare 16 byte.

Fondamentalmente questa funzione viene chiamata da un programma C / C ++ che ha passato da n a rdi e da un puntatore a un'allocazione tramite rsi. Il puntatore che ha rsi è in realtà 1 byte dalla fine dell'allocazione, poiché la tabella è costruita all'indietro. Ciò semplifica la conversione di un numero intero in caratteri ASCII stampabili (fatto prendendo un numero x mod 10 e convertendo il risultato in ASII).

Per vedere il codice wrapper C ++ e i commenti sull'assembly, dai un'occhiata al mio repository .

Pari / GP , 26 byte

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

Provalo online!

MathGolf , 10 8 byte

r░y\Åo╫;

Provalo online!

-2 byte grazie a Jo King

Spiegazione

Userò l'input di esempio 3per la spiegazione

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)

Si potrebbe anche fare r░y\(Åo╫, il che riduce il numero di loop di 1 e salta lo scarto dopo il loop.

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 caratteri

Un lavoro terribilmente pigro.

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

Eseguilo qui . (La prima riga è simulare lo stdin).

Spiegazione :

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

Al termine del programma, lo stack contiene ciascuno degli array con una nuova riga tra di essi. L'interprete emette ciò che resta nello stack, dando il risultato desiderato.

CJam, 14 caratteri

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

Provalo qui.

Spiegazione

L'idea è di ripetere la stringa da 0a N-1, ma dividerla in blocchi di N+1. Questa mancata corrispondenza sposta la riga a sinistra ogni volta. Infine, dobbiamo liberarci del carattere estraneo e unire tutto con le nuove linee.

Ecco il codice esploso, insieme al contenuto dello stack per l'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"]

Il risultato viene stampato automaticamente alla fine del programma. (Nota, i contenuti dello stack per il passaggio finale sono tecnicamente un array misto contenente numeri e caratteri di nuova riga, non una stringa contenente solo caratteri.)

In alternativa, 11 caratteri

Con la recente aggiunta ew(questa è più recente della sfida - restituisce tutte le sottostringhe sovrapposte di una determinata lunghezza), si potrebbero fare 11 byte:

l~,2*))ewN*

Ecco come funziona:

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\

Provalo online!

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

Funzione finestra immediata VBE immediata che accetta input, come numero intero, n, dall'intervallo [A1]e output all'intervallo 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|^*

Provalo online!

Blocco di codice anonimo che accetta un numero e stampa la matrice nel formato specificato con spazi. Se invece possiamo semplicemente restituire qualcosa, è .putpossibile rimuoverlo.

Spiegazione:

                   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

Carbone , 13 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: spazio finale. Spiegazione:

Ｎθ              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 caratteri, 30 byte

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

test:

  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 

qui la lingua non ha bisogno di commenti ...

Japt -R, 5 byte

ÆZéXn

Provalo

Se l'utilizzo di una virgola come separatore non è valido, aggiungere un byte per nessun separatore:

ÆZ¬éXn

Provalo

O 2 byte per utilizzare uno spazio:

ÆZéXn)¸

Provalo

R , 37 byte

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

Crea un vettore da 0 a n-1 e aggiunge in sequenza 1, quindi 2 ... quindi n e modula la matrice per la lunghezza del vettore, che è n.

Provalo online!

Forth (gforth) , 53 byte

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

Provalo online!

Spiegazione

Ciclo nidificato che genera una nuova riga ogni n numeri

Spiegazione del codice

: 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