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

X      
  X  X 


  X  X 
X      
 X    X

Entrada: 11

X          

     XX    

   X    X  
   X    X  

     XX    

X          
 X        X

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í.}

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 .

Octava , 45 44 bytes

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

Pruébalo en línea!

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.

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,#}]&

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.

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>

El eje Y es el reverso del OP.

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
}

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

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.

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!

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

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)

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.

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!

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

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

J , 20 bytes

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

Pruébalo en línea!

GolfScript , 34 bytes

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

Pruébalo en línea!

Realmente no me gusta usar variables ...