Genere la tabla de grupo para Z_n

9

Los grupos son una estructura muy utilizada en matemáticas y tienen aplicaciones en informática. Este desafío de código se trata del menor número de caracteres para crear una tabla de grupo para el grupo aditivo Z n .

Cómo se construye la tabla: para Z n , los elementos son {0, 1, 2, ..., n-1}. La tabla tendrá n filas yn columnas. Para la entrada i-ésima de la tabla, el valor es i + j mod n. Por ejemplo, en Z 3 , la entrada 1-2 (segunda fila, tercera columna si cuenta la fila / columna inicial como 1) es (1 + 2)% 3 = 0 (ver salida de muestra).

Entrada: un entero positivo, n

Salida: una tabla que es una presentación textual de Z n , construida como se describió anteriormente y mostrada como se muestra a continuación en las salidas de muestra. Los espacios son opcionales

Entrada de muestra: 3

Salida de muestra:

0 1 2
1 2 0
2 0 1

Entrada de muestra: 5

Salida de muestra:

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
Ryan
fuente
3
Como el separador es opcional, ¿habrá una entrada superior a 10?
Jo King el
@JoKing basado en codegolf.stackexchange.com/questions/35038/… Supongo que sí
qwr

Respuestas:

10

APL (10)

(Suponiendo ⎕IO=0. Funciona en ngn / apl por defecto, otras APL tienden a necesitar una ⎕IO←0primera).

{⍵|∘.+⍨⍳⍵}

Explicación:

  • ⍳⍵: los números [0..⍵)
  • ∘.+⍨: crea una tabla de suma
  • ⍵|: números en la tabla mod
marinus
fuente
1
¿Puedes hacer ⊢|⍳∘.+⍳o los trenes no funcionaron en la versión de julio de 2014 de ngn?
lirtosiast el
3

GolfScript (13 caracteres)

Por su comentario sobre la respuesta de Claudiu, entiendo que el espacio en blanco entre los elementos de una fila no es necesario. En ese entendimiento:

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

Demostración en línea

Disecció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

Si es necesario un espacio en blanco, para 20 caracteres:

~.,{.(+}@(*]{' '*n}/
Peter Taylor
fuente
Muy buen trabajo en estos!
Ryan
3

Python 2, 66 bytes

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

Rota la lista haciendo estallar y volviendo a agregar.

Python 3, 53 bytes

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

Utiliza el mismo método que @ mbomb007, pero abusa printcomo una función.

Sp3000
fuente
Esa *R,=es una construcción extraña ... ¿Sirve solo para convertir rangela salida de una tupla?
Jonathan Frech
¿Puedes explicar el código de Python 3 por favor? No he visto el uso de*R
tarit goswami
@taritgoswami Se degenera desempacando; rangees un objeto iterable que se puede desempaquetar y volver a empacar, recolectando todo en él R. Debería ser equivalente a R=list(range(n)), siendo el primero más conciso.
Jonathan Frech el
3

05AB1E , 10 8 bytes

ݨDδ+I%»

Pruébalo en línea!

Explicación

         # 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       

Respuesta anterior: 10 bytes

ݨDvDðý,À}

Pruébalo en línea!

Mi primer intento de jugar golf en 05AB1E.

Explicación de la respuesta anterior.

           # 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]]  
Wisław
fuente
1
Buena primera respuesta, y bienvenido! Tengo la sensación de que puede ser más corto, pero aquí hay dos alternativas de 9 bytes: FݨN._ðý,y ݨsGDÀ})»siéntase libre de hacer cualquier pregunta en el chat 05AB1E , y eche un vistazo a la página de consejos 05AB1E si aún no lo ha hecho. :)
Kevin Cruijssen
@KevinCruijssen ¡Gracias! Parece que olvidé encontrar una manera de aprovechar la entrada implícita.
Wisław
1

Pyth , 16

JVQXQjdJ=J+tJ]hJ

Imprime la tabla con espacios en blanco adecuados.

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

Explicación:

                   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]]])
isaacg
fuente
1

J, 20

Lectura de stdin y producción de una matriz 2D (que representa lo mismo que la muestra en la pregunta).

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

Si una función que toma una cuerda basta, (|+/~@i.)@".. Si una función que toma un número entero es suficiente, |+/~@i.debería ser suficiente.

Explicación: f g en J (para las funciones f, g) denota un "gancho", que es una función compuesta que ejecuta la entrada a través de g (una función unaria) y luego la entrada y el resultado de g a través de f (una función binaria). La respuesta es una bifurcación con componentes |(módulo) y +/~@i.. La última parte es "tabla de sumas compuesta con lista de índices hasta" ( i.es un poco como rangeen Python).

Luciérnaga
fuente
Debe actualizar su respuesta a |+/~@i., que debería ser aceptable según las reglas estándar aquí.
Jonás
1

Octava, 23

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

Pitón 2, 67

Pruébalos los dos aquí

Utilizo la división de listas para "rotar" los ntiempos de la lista , imprimiéndolo cada vez. (68 caracteres)

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

Logré obtener un personaje más corto que el anterior con un truco extraño. (67 caracteres)

def f(n):
 l=range(n)
 for i in l:print''.join(`l[i:]+l[:i]`)[1::3]
mbomb007
fuente
Parece que este método es aún más corta en Python 3: def f(n):*R,=range(n);[print(*R[i:]+R[:i])for i in R]. No pensé que el splat realmente funcionaría sin parens.
Sp3000
1

Matlab (28)

k=exp(0:n-1)
mod(log(k'*k),n)
falla
fuente
1

Código de máquina x86-64 (Linux), 80 64 bytes

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

Esperaba que esta solución fuera solo unos pocos bytes más corta para poder superar algunas de las otras presentaciones en esta publicación. Existe la posibilidad de que si uso algunas de las versiones de 32 o 16 bits de los registros, pueda eliminar algunos bytes. La conversión de muchos de los registros a las versiones de direccionamiento de 32 bits ahorró 16 bytes.

Básicamente, esta función se llama desde un programa C / C ++ que pasó n a través de rdi, y un puntero a una asignación a través de rsi. El puntero que tiene rsi es en realidad 1 byte desde el final de la asignación, ya que la tabla está construida al revés. Esto facilita la conversión de un número entero en caracteres ASCII imprimibles (hecho tomando un número x mod 10 y convirtiendo el resultado a ASII).

Para ver el código del contenedor C ++ y los comentarios sobre el ensamblaje, consulte mi repositorio .

davey
fuente
1

Pari / GP , 26 bytes

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

Pruébalo en línea!

alephalpha
fuente
¿Quién inicializó x, y a qué?
RosLuP
@RosLuP matrix(m,n,X,Y,expr)genera una mXnmatriz de expresión expr, la variable de fila Xva de 1a my la variable de columna Yva de 1a n.
alephalpha
1

MathGolf , 10 8 bytes

r░y\Åo╫;

Pruébalo en línea!

-2 bytes gracias a Jo King

Explicación

Usaré una entrada de ejemplo 3para la explicación

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)

También podría hacerlo r░y\(Åo╫, lo que disminuye el número de bucles en 1 y omite el descarte después del bucle.

maxb
fuente
9 bytes
Jo King
@JoKing eso es inteligente! ¿Quizás podría usar qpara eliminar la duplicación?
maxb
Me refería o. Aunque lo mejor que pude entender de esa manera fue esto . También podría ser de 10 bytes, pero estoy en el móvil.
maxb
Dado que el separador es opcional, 8 bytes deberían funcionar
Jo King
0

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);}}
LemonBoy
fuente
0

Golfscript, 20 caracteres

Un trabajo terriblemente perezoso.

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

Ejecútalo aquí . (La primera línea es simular stdin).

Explicacion :

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

Cuando finaliza el programa, la pila contiene cada una de las matrices con nuevas líneas entre ellas. El intérprete emite lo que queda en la pila, dando el resultado deseado.

Claudiu
fuente
1
¡Agradable! Aunque los espacios entre elementos no eran necesarios, puede ser útil cuando tenemos elementos de valor> = 10 (es decir, cuando n> = 11).
Ryan
¿Puedes por favor exponer tu código? Para mí, leer golfscript es peor que leer la expresión regular de otra persona. (casi =)
flawr
@flawr: Ja, claro, es bastante sencillo
Claudiu
0

CJam, 14 caracteres

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

Pruébalo aquí.

Explicación

La idea es repetir la cadena de 0a N-1, pero dividirla en bloques de N+1. Este desajuste desplaza la fila a la izquierda cada vez. Por último, necesitamos deshacernos del personaje extraño y unir todo con nuevas líneas.

Aquí está el código explotado, junto con el contenido de la pila para la entrada 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"]

El resultado se imprime automáticamente al final del programa. (Tenga en cuenta que el contenido de la pila para el paso final es técnicamente una matriz mixta que contiene números y caracteres de nueva línea, no una cadena que contiene solo caracteres).

Alternativamente, 11 caracteres

Con la adición reciente ew(esto es más nuevo que el desafío: devuelve todas las subcadenas superpuestas de una longitud dada), uno podría hacer 11 bytes:

l~,2*))ewN*

Así es como funciona este:

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"]
Martin Ender
fuente
Alternativos 14 bytes: l~_,\{_(+N\}*;. Sin embargo, me pregunto si podemos hacerlo mejor con esto .
Sp3000
Sí, pero eso es esencialmente un puerto de la respuesta de Peter, y pensé que preferiría presentar un enfoque diferente. ewpodría funcionar pero es más nuevo que el desafío.
Martin Ender
0

MATL , 6 bytes

:q&+G\

Pruébalo en línea!

    # 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
Giuseppe
fuente
0

Excel VBA, 77 bytes

Función de ventana inmediata anónima VBE que toma entrada, como entero, n, del rango [A1]y salidas al rango A2.Resize(n,n).

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

Perl 6 , 23 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número e imprime la matriz en el formato dado con espacios. Si podemos devolver algo, entonces .putse puede eliminar.

Explicación:

                   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
Jo King
fuente
0

Carbón , 13 bytes

NθEθ⪫Eθ﹪⁺ιλθ 

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: espacio final. Explicación:

Nθ              Input `n` as a number into variable
   θ            `n`
  E             Map over implicit range
      θ         `n`
     E          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
Neil
fuente
0

APL (NARS), 15 caracteres, 30 bytes

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

prueba:

  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 

aquí el idioma no necesita comentarios ...

RosLuP
fuente
0

Japt -R, 5 bytes

ÆZéXn

Intentalo

Si el uso de una coma como separador no es válido, agregue un byte para ningún separador:

ÆZ¬éXn

Intentalo

O 2 bytes para usar un espacio:

ÆZéXn)¸

Intentalo

Lanudo
fuente
0

R , 37 bytes

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

Crea un vector de 0 a n-1, y agrega secuencialmente 1, luego 2 ... luego n, y modula la matriz por la longitud del vector, que es n.

Pruébalo en línea!

Sumner18
fuente
0

Adelante (gforth) , 53 bytes

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

Pruébalo en línea!

Explicación

Bucle anidado que genera una nueva línea cada n números

Explicación del código

: 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
reffu
fuente