Introducción

Puedes conocer y amar tu círculo de unidad normal. Pero los matemáticos están locos y, por lo tanto, han abstraído el concepto a cualquier punto que les satisfaga x*x+y*y=1. Debido a que los Criptógrafos ¹ también son extraños, les encantan los campos finitos y, a veces, los anillos finitos (aunque no es que tengan muchas opciones), ¡así que combinemos esto!

El reto

Entrada

Un entero positivo mayor que uno en su codificación favorita. Llamemos a este número n.

Salida

Sacará la "imagen" (que consta de n veces n caracteres) del módulo de círculo de la unidad, el entero de entrada como ASCII-Art usando "X" (mayúscula X latina) y "" (un espacio). Se permiten espacios finales y líneas nuevas.

Más detalles

Debe abarcar un sistema de coordenadas de abajo a la izquierda a arriba a la derecha. Siempre que un punto cumpla con la ecuación circular, coloque una X en la posición; de lo contrario, coloque un espacio.

La condición para que un punto para ser considerado parte de la frontera del círculo es:
mod(x*x+y*y,n)==1.

Aquí una ilustración rápida del sistema de coordenadas:

(0,4)(1,4)(2,4)(3,4)(4,4)
(0,3)(1,3)(2,3)(3,3)(4,3)
(0,2)(1,2)(2,2)(3,2)(4,2)
(0,1)(1,1)(2,1)(3,1)(4,1)
(0,0)(1,0)(2,0)(3,0)(4,0)

Si le ayuda, también puede invertir la dirección de cualquiera de los ejes, pero los ejemplos asumen esta orientación.

¿Quién gana?

Este es el código de golf, por lo que gana el código más corto en bytes. Solo se permiten los métodos de E / S predeterminados y se prohíben todas las lagunas estándar.

Ejemplos

Entrada: 2

X 
 X

Entrada: 3

X  
X  
 XX

Entrada: 5

X    


X    
 X  X

Entrada: 7

Entrada: 11

Entrada: 42

X                                         
         X                       X        


            X                 X           
       X                           X      
      X                             X     
                     X                    
  X             X         X             X 


     X             X   X             X    
X                                         
               X           X              
              X             X             
         X                       X        


            X                 X           
                     X                    
        X           X X           X       
                     X                    
            X                 X           


         X                       X        
              X             X             
               X           X              
X                                         
     X             X   X             X    


  X             X         X             X 
                     X                    
      X                             X     
       X                           X      
            X                 X           


         X                       X        
X                                         
 X           X               X           X

¹_{Te sugiero que eches un vistazo a mi perfil si te estás preguntando aquí.}

code-golf math ascii-art abstract-algebra SEJPM
fuente

Se ve mucho mejor si usa el dominio [0, n] en mi opinión. Aquí hay un ejemplo con la entrada 42.

R. Kap

¿Por "E / S estándar" se refiere a los métodos de E / S predeterminados, o se refiere a STDIN / STDOUT real? Asumo lo primero, pero creo que alguien a continuación lo ha interpretado como lo último.

Ørjan Johansen el

@ ØrjanJohansen de hecho el primero.

SEJPM

¿Se permiten líneas nuevas anteriores?

fergusq

@fergusq como alterarían (drásticamente) la cifra de salida de manera visible, no.

SEJPM

6

Bash + GNU Utilities, 59

x={0..$[$1-1]}d*
eval echo $x$x+$1%1-0r^56*32+P|dc|fold -$1

Entrada ndada como un parámetro de línea de comando. El eje y está invertido.

Pruébalo en línea .

Trauma digital
fuente

4

Octava , 45 44 bytes

@(n)[(mod((x=(0:n-1).^2)+x',n)==1)*56+32,'']

Pruébalo en línea!

falla
fuente

Esto también funciona: @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. En ciertos sistemas, Octave trata al personaje 0como un espacio

Luis Mendo

3

Haskell , 68 bytes

f n|r<-[0..n-1]=unlines[[last$' ':['X'|mod(x*x+y*y)n==1]|y<-r]|x<-r]

Pruébalo en línea! El eje y se voltea. Uso: f 42devuelve una cadena delimitada de nueva línea.

Esta es una lista de comprensión anidada donde ambos xy yse extraen del rango [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]es una forma más corta de if mod(x*x+y*y)n==1 then 'X' else ' '. La comprensión de la lista se evalúa como una lista de cadenas que se convierte en una sola cadena separada por una nueva línea unlines.

Laikoni
fuente

3

Mathematica, 56 48 bytes

Editar: Gracias a Greg Martin y Martin Ender por guardar 8 bytes.

Grid@Array[If[Mod[#^2+#2^2,x]==1,X]&,{x=#,#},0]&

Solución original:

Grid@Table[If[Tr[{i-1,j-1}^2]~Mod~#==1,X,],{i,#},{j,#}]&

ngenisis
fuente

Comentario divertido: no necesitas la coma después X:)

Greg Martin

1

Creo que estás mejor con Arrayy Norm:Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

Martin Ender

2

Todavía pensarlo demasiado ... #^2+#2^2es el más corto.

Martin Ender

@GregMartin Entonces, si el primer argumento para Ifes none Trueo False, necesita el cuarto argumento o permanece sin evaluar, pero If[False,_]regresa Null. Extraño.

ngenisis

@MartinEnder Inicialmente intenté Arraypero no pensé establecer el argumento en una variable.

ngenisis

2

CJam , 23 bytes

ri:X,2f#_ff{+X%(S'X?}N*

Pruébalo en línea!

ri:X    e# Read input, convert to integer, store in X.
,       e# Turn into range [0 1 ... X-1].
2f#     e# Square each value in the range.
_ff{    e# 2D map over all pairs from that list.
  +     e#   Add the two values in the current pair.
  X%    e#   Take the sum modulo X.
  (     e#   Decrement, so that x^2+y^2==1 becomes 0 (falsy) and everything
        e#   else becomes truthy.
  S'X?  e#   Select space of 'X' accordingly.
}
N*      e# Join rows with linefeeds.

Martin Ender
fuente

2

JavaScript (ES6), 81 bytes

f=
n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>(x*x+y*y)%n-1?` `:`X`).join``).join`
`

<input type=number oninput=o.textContent=f(+this.value)><pre id=o>

Expandir fragmento

El eje Y es el reverso del OP.

Neil
fuente

2

Röda , 74 bytes

f n{seq n-1,0|{|y|seq 0,n-1|{|x|["X"]if[(x^2+y^2)%n=1]else[" "]}_;["
"]}_}

Pruébalo en línea!

Sin golf:

function f(n) {
    seq(n-1, 0) | for y do
        seq(0, n-1) | for x do
            if [ (x^2 + y^2) % n = 1 ] do
                push("X")
            else
                push(" ")
            done
        done
        print("")
    done
}

fergusq
fuente

2

Python 3 , 87 83 bytes

lambda n:"\n".join("".join(" X"[(y*y+x*x)%n==1]for x in range(n))for y in range(n))

Pruébalo en línea!

El eje y está invertido

ovs
fuente

2

Jalea , 14 13 bytes

R²+þ`%=1ị⁾X Y

El eje x está invertido.

Pruébalo en línea!

Cómo funciona

R²+þ`%=1ị⁾X Y  Main link. Argument: n

R              Range; yield [1, ..., n].
 ²             Square; yield [1², ..., n²].
  +þ`          Self table addition; compute x+y for all x and y in [1², ..., n²],
               grouping by the values of y.
     %         Take all sums modulo n.
      =1       Compare them with 1, yielding 1 or 0.
        ị⁾X    Index into "X ".
            Y  Separate by linefeeds.

Dennis
fuente

1

cc , 79 bytes

?dsRsQ[88P]sl[32P]sH[0sM[lM2^lR2^+lQ%d1=l1!=HlM1+dsMlQ>c]dscx10PlR1-dsR0<S]dsSx

El yeje se invierte mientras que elx eje no.

Pruébalo en línea!

R. Kap
fuente

1

MATL , 13 bytes

:qU&+G\1=88*c

El origen está en la parte superior izquierda. Por lo tanto, la salida se invierte en comparación con los ejemplos en el desafío.

Probar en MATL en línea!

Explicación

:      % Input n implicitly. Push [1 2 ... n]
q      % Subtract one (element-wise)
U      % Square (element-wise)
&+     % Matrix of pairwise sums
G      % Push n
\      % Modulo
1=     % Equal to 1? (element-wise)
88*    % Multiply by 88 (ASCII code of 'X')
c      % Convert to char. Char 0 will be displayed as a space
       % Display implicitly

Luis Mendo
fuente

1

Python 3 , ( 102 98 95 bytes)

eje y invertido

n=int(input());r=range(n);p=print
for i in r:
 for j in r:p(end=' 'if(i*i+j*j)%n-1else'X')
 p()

Pruébalo en línea!

4 bytes guardados: variable omitida c en c = '' if (i i + j j)% n-1else'X '
guardado 3 bytes: Gracias a los ovs (declaración de impresión modificada)

officialaimm
fuente

1

p(end=' 'if(i*i+j*j)%n-1else'X')por 95 bytes

ovs

1

Lithp , 125 bytes

#N::((join(map(seq(- N 1)0)(scope #Y::((join(map(seq 0(- N 1))(scope #X::
((?(== 1(@(+(* X X)(* Y Y))N))"X" " "))))""))))"\n")

Salto de línea para facilitar la lectura.

Pruébalo en línea!

No es el más corto. Creo que necesito algún tipo de módulo abreviado. Consulte el enlace Pruébelo en línea para obtener más explicaciones, una versión no adaptada y algunas pruebas. Para obtener mejores resultados, expanda la ventana de salida para ver más.

Andrakis
fuente

1

Python 3 , 82 bytes

f=lambda n,k=0:k<n>f(n,k+1)!=print(''.join(' X'[(k*k+j*j)%n==1]for j in range(n)))

Pruébalo en línea!

Dennis
fuente

1

GNU APL , 41 caracteres, 59 bytes

Lee un número entero y muestra el círculo.

N←⎕◊⌽{(⍵+1)⊃' ' 'X'}¨{1=(N|(+/⍵*2))}¨⍳N N

Sin golf

N←⎕
⌽                           ⍝ flip the X axis so 0,0 is bottom left
{
    (⍵+1) ⊃ ' ' 'X'         ⍝ substitute space for 0, X for 1
} ¨ {
    1=(N|(+/⍵*2))           ⍝ mod(x*x+y*y, 1)==1
} ¨ ⍳N N                    ⍝ generate an NxN grid of coordinates

Megashroom
fuente

0

Haskell, 115 bytes

n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])

El eje y está invertido.

Pruébalo en línea!

Todos esos paréntesis me molestan ...

Explicación

n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
n#(a,b)                                 --Operator #, takes a number n and a tuple (a,b)
       |mod(a*a+b*b)n==1                --Test if the mod equals 1
                        ='X'            --If so, return 'X'
                            |1>0=' '    --Otherwise, return ' '

m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])
m n=                                                                           --Make a new function m with argument n
                                 (replicate n[0..n-1])                         --Make a list of [[0,1,2,3..n-1],[0,1,2,3..n-1],(n times)]
                                                      (replicate n<$>[0..n-1]) --Make a list of [[0,0,0(n times)],[1,1,1(n times)]..[n-1,n-1,n-1(n times)]
              zipWith(zipWith(,))                                              --Combine them into a list of list of tuples
    map(n#)<$>                                                                 --Apply the # operator to every tuple in the list with the argument n

Nombre de visualización genérico
fuente

Puedes reemplazar el último mapcon un <$>, ¿verdad?

k_g

A menos que esté malinterpretando las reglas de la pregunta, no creo que necesite toda esa E / S: la E / S de golf en PPCG tiene valores predeterminados especiales para permitir la participación de tantos idiomas como sea posible. Por ejemplo, su función principal puede tomar un argumento entero y devolver una cadena.

Ørjan Johansen el

@k_g sí, gracias

Nombre genérico para mostrar

@ ØrjanJohansen debidamente anotado :)

Nombre de visualización genérico

0

J , 20 bytes

' x'{~1=[|+/~@:*:@i.

Pruébalo en línea!

Monja permeable
fuente

0

GolfScript , 34 bytes

~:c,{.*}%:a{:b;a{b+c%1=' x'=}%}%n*

Pruébalo en línea!

Realmente no me gusta usar variables ...

Monja permeable
fuente

¡Dibujame el círculo de unidades (extraño)!

Introducción

El reto

Entrada

Salida

Más detalles

¿Quién gana?

Ejemplos

Respuestas:

Bash + GNU Utilities, 59

Octava , 45 44 bytes

Haskell , 68 bytes

Mathematica, 56 48 bytes

Solución original:

CJam , 23 bytes

JavaScript (ES6), 81 bytes

Röda , 74 bytes

Python 3 , 87 83 bytes

Jalea , 14 13 bytes

Cómo funciona

cc , 79 bytes

MATL , 13 bytes

Explicación

Python 3 , ( 102 98 95 bytes)

eje y invertido

Lithp , 125 bytes

Python 3 , 82 bytes

GNU APL , 41 caracteres, 59 bytes

Sin golf

Haskell, 115 bytes

Explicación

J , 20 bytes

GolfScript , 34 bytes