Gruplar Matematikte yaygın olarak kullanılan bir yapıdır ve Bilgisayar Bilimlerinde uygulamalara sahiptir. Bu kod zorluğu, Z _n aditif grubu için bir grup tablosu oluşturmak için en az sayıda karakterle ilgilidir .

Tablonun nasıl oluşturulduğu: Z _n için elemanlar {0, 1, 2, ..., n-1} 'dir. Tabloda n satır ve n sütun olacaktır. Tablonun ij-th girişi için, değer i + j mod n'dir. Örneğin, Z ₃ , 1-2nci bir giriş (2 satır, 3 sütun 1 olarak başlangıç satır / sütun sayısı) (örnek çıktı bakınız) (1 + 2)% 3 = 0'dır.

Girdi: pozitif bir tam sayı, n

Çıktı: Z _n'nin metinsel sunumu olan , yukarıda açıklandığı gibi yapılandırılmış ve aşağıda örnek çıktılarında gösterildiği gibi görüntülenen bir tablo . Alanlar isteğe bağlıdır

Örnek giriş: 3

Örnek çıktı:

0 1 2
1 2 0
2 0 1

Örnek giriş: 5

Örnek çıktı:

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)

( Varsayılan ⎕IO=0olarak ngn / apl üzerinde çalışır , diğer APL'lerin bir ⎕IO←0ilke ihtiyacı vardır .)

{⍵|∘.+⍨⍳⍵}

Açıklama:

• ⍳⍵: sayılar [0..⍵)
• ∘.+⍨: bir toplam tablosu oluştur
• ⍵|: tablodaki sayılar mod⍵

GolfScript (13 karakter)

Claudiu'nun cevabı hakkındaki yorumunuzdan, bir satırın elemanları arasındaki boşluk gerekli olmadığını anlıyorum. Bu anlayış üzerine:

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

Çevrimiçi demo

diseksiyon:

~        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

Boşluk gerekiyorsa, 20 karakter için:

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

Python 2, 66 bayt

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

Haşhaş ve yeniden ekleyerek listeyi döndürür.

Python 3, 53 bayt

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

@ Mbomb007 ile aynı yöntemi kullanır, ancak printişlev olarak kötüye kullanılır.

05AB1E , 10 8 bayt

ݨDδ+I%»

Çevrimiçi deneyin!

açıklama

         # 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       

Önceki cevap: 10 bayt

ݨDvDðý,À}

Çevrimiçi deneyin!

05AB1E golf ilk deneyin.

Önceki cevabın açıklaması

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

Jöle , 4

Ḷṙ`G

Çevrimiçi deneyin!

Pyth , 16

JVQXQjdJ=J+tJ]hJ

Tabloyu uygun boşlukla yazdırır.

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

Açıklama:

                   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'den okuma ve bir 2D dizi üretme (ki bu sorudaki örnekle aynıdır).

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

Dize alan bir işlev yeterliyse (|+/~@i.)@".,. Bir tamsayı alan bir işlev |+/~@i.yeterliyse yeterli olmalıdır.

Açıklama: f g J'de (f, g işlevleri için), girdiyi g (tekli bir işlev) ve daha sonra girdiyi ve g ile f'den (ikili işlev) geçen bir bileşik işlev olan bir "kanca" anlamına gelir. Cevap bileşenleri |(modülü) ve olan bir çatal +/~@i.. Son kısım ise, "endeksler listesi" ile oluşturulmuş toplamlar tablosu "dur ( i.biraz rangePython'da olduğu gibidir).

Oktav, 23

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

Python 2, 67

İkisini de burada deneyin

Liste nsürelerini, her seferinde yazdırmak için liste sürelerini "döndürmek" için kullanıyorum . (68 karakter)

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

Garip bir numara ile yukarıdakinden daha kısa bir karakter elde etmeyi başardım. (67 karakter)

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 Makine Kodu (Linux), 80 64 bayt

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

Bu çözümün, bu gönderideki diğer gönderilerden bazılarını yenebilmek için sadece birkaç bayt daha kısa olmasını umuyordum. Birkaç bayt kapalı tıraş edebileceğim kayıtların 32 veya 16 bitlik sürümlerinden bazılarını kullanmam ihtimalim var. Kayıtların çoğunu 16 bit kaydedilen 32 bit adresleme sürümlerine dönüştürmek.

Temel olarak bu işlev n'den rdi'ye geçen bir C / C ++ programından ve rsi üzerinden bir tahsise işaretçi olarak çağrılır. RSI'nin sahip olduğu işaretçi, tablonun geriye doğru oluşturulduğu için tahsisin sonundan itibaren 1 bayttır. Bu, bir tamsayıyı yazdırılabilir ASCII karakterlerine dönüştürmeyi kolaylaştırır (x mod 10 sayısı alınarak ve sonucu ASII'ye dönüştürerek yapılır).

C ++ sarıcı kodunu ve derlemedeki yorumları görmek için repo'ma göz atın .

Pari / GP , 26 bayt

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

Çevrimiçi deneyin!

MathGolf , 10 8 bayt

r░y\Åo╫;

Çevrimiçi deneyin!

Jo King sayesinde -2 bayt

açıklama

3Açıklama için örnek girdi kullanacağım

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)

Ayrıca r░y\(Åo╫, döngü sayısını 1 azaltır ve döngüden sonra atmayı atlar.

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 karakter

Çok tembel bir iş.

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

Burada çalıştırın . (İlk satır stdin simüle etmektir).

Açıklama :

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

Program sona erdiğinde, yığın aralarında satırsonu olan dizilerin her birini içerir. Yorumlayıcı, istediği sonucu vererek istifin üzerinde kalanları çıkarır.

CJam, 14 karakter

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

Burada test edin.

açıklama

Fikir gelen dize tekrarlamak olduğunu 0için N-1, ancak bloklara bölmek N+1. Bu uyumsuzluk satırı her seferinde sola kaydırır. Son olarak, yabancı karakterden kurtulmamız ve her şeye yeni satırlarla katılmamız gerekiyor.

İşte patlatılmış kod, giriş için yığın içeriği ile birlikte 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"]

Sonuç, programın sonunda otomatik olarak yazdırılır. (Son adımın yığın içeriğinin teknik olarak yalnızca karakter içeren bir dize değil, sayı ve satırsonu karakterlerini içeren karışık bir dizidir.)

Alternatif olarak, 11 karakter

Son eklenenlerle ew (bu meydan okumadan daha - belirli bir uzunluktaki çakışan tüm alt dizeleri döndürür), biri 11 bayt yapabilir:

l~,2*))ewN*

Bunun nasıl çalıştığı:

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 bayt

:q&+G\

Çevrimiçi deneyin!

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

Girdiyi aralıktan [A1]ve çıktılardan aralığa tamsayı olarak n alan anonim VBE anlık pencere işlevi A2.Resize(n,n).

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

Perl 6 , 23 bayt

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

Çevrimiçi deneyin!

Bir sayı alan ve matrisi boşluklarla verilen biçimde yazdıran anonim kod bloğu. Bunun yerine sadece bir şey iade .putedebilirsek, kaldırılabilir.

Açıklama:

                   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

Kömür , 13 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Not: Sondaki boşluk. Açıklama:

Ｎθ              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 karakter, 30 bayt

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

Ölçek:

  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 

burada dilin yoruma ihtiyacı yok ...

Japt -R, 5 bayt

ÆZéXn

Dene

Ayırıcı olarak virgül kullanmak geçerli değilse, ayırıcı olmadan bayt ekleyin:

ÆZ¬éXn

Dene

Veya bir boşluk kullanmak için 2 bayt:

ÆZéXn)¸

Dene

R , 37 bayt

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

0 ila n-1 arasında bir vektör oluşturur ve sırayla 1, sonra 2 ... sonra n ekler ve matrisi vektörün uzunluğu olan n'ye göre modüle eder.

Çevrimiçi deneyin!

İleri (gforth) , 53 bayt

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

Çevrimiçi deneyin!

açıklama

Her n numarada yeni satır çıktısı veren iç içe döngü

Kod Açıklaması

: 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