introduction

Vous connaissez peut-être et aimez votre cercle d'unité normal. Mais les mathématiciens sont fous et ont donc résumé le concept à tout point qui satisfait x*x+y*y=1. Parce que les cryptographes ¹ sont également étranges, ils aiment les champs finis et parfois les anneaux finis (ce n'est pas comme s'ils avaient beaucoup de choix), alors combinons cela!

Le défi

Contribution

Un entier positif supérieur à un dans votre encodage préféré. Appelons ce numéro n.

Production

Vous afficherez l '"image" (qui se compose de n fois n caractères) du cercle unitaire modulo l'entier d'entrée en ASCII-Art en utilisant "X" (X majuscule latin) et "" (un espace). Les espaces de fin et les nouvelles lignes sont autorisés.

Plus de détails

Vous devez étendre un système de coordonnées de bas à gauche à haut à droite. Chaque fois qu'un point remplit l'équation du cercle, placez un X à la position, sinon placez un espace.

La condition d'un point à considérer comme faisant partie de la frontière du cercle est:
mod(x*x+y*y,n)==1.

Voici une illustration rapide du système de coordonnées:

(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 cela vous aide, vous pouvez également inverser la direction de l'un des axes, mais les exemples supposent cette orientation.

Qui gagne?

C'est le code-golf donc le code le plus court en octets gagne! Seules les méthodes d'E / S par défaut sont autorisées et toutes les failles standard sont interdites.

Exemples

Entrée: 2

X 
 X

Entrée: 3

X  
X  
 XX

Entrée: 5

X    


X    
 X  X

Entrée: 7

Entrée: 11

Entrée: 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

¹_{Je vous suggère de jeter un œil à mon profil si vous vous posez la question ici.}

— SEJPM
source

A bien meilleure apparence si vous utilisez le domaine [0, n] à mon avis. Voici un exemple avec l'entrée 42.

— R. Kap

Par «E / S standard», voulez-vous dire les méthodes d'E / S par défaut, ou voulez-vous dire STDIN / STDOUT réel? Je suppose que le premier, mais je pense que quelqu'un ci-dessous l'a interprété comme le dernier.

— Ørjan Johansen

@ ØrjanJohansen en effet l'ancien.

— SEJPM

Les sauts de ligne précédents sont-ils autorisés?

— fergusq

@fergusq comme ils changeraient (radicalement) le chiffre de sortie de manière visible, non.

— SEJPM

6

Utilitaires Bash + GNU, 59

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

Entrée ndonnée comme paramètre de ligne de commande. L'axe des y est inversé.

Essayez-le en ligne .

— Traumatisme numérique
source

4

Octave , 45 44 octets

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

Essayez-le en ligne!

— flawr
source

Cela fonctionne aussi: @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. Dans certains systèmes, Octave traite le personnage 0comme un espace

— Luis Mendo

3

Haskell , 68 octets

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

Essayez-le en ligne! L'axe des y est inversé. Utilisation: f 42renvoie une chaîne délimitée par une nouvelle ligne.

Il s'agit d'une compréhension de liste imbriquée où les deux xet ysont tirés de la plage [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]est une forme plus courte de if mod(x*x+y*y)n==1 then 'X' else ' '. La compréhension de la liste est évaluée en une liste de chaînes qui est transformée en une seule chaîne séparée par un saut de ligne par unlines.

— Laikoni
source

3

Mathematica, 56 48 octets

Edit: Merci à Greg Martin et Martin Ender pour avoir économisé 8 octets.

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

Solution originale:

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

— ngenisis
source

Remarque amusante: vous n'avez pas besoin de la virgule après X:)

— Greg Martin

1

Je pense que vous êtes mieux avec Arrayet Norm:Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

— Martin Ender

2

Y penser encore trop ... #^2+#2^2est le plus court.

— Martin Ender

@GregMartin Donc, si le premier argument de Ifn'est ni Trueou False, vous avez besoin du quatrième argument ou il reste non évalué, mais If[False,_]revient Null. Bizarre.

— ngenisis du

@MartinEnder J'ai d'abord essayé Arraymais je ne pensais pas définir l'argument sur une variable.

— ngenisis

2

CJam , 23 octets

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

Essayez-le en ligne!

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
source

2

JavaScript (ES6), 81 octets

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>

Développer l'extrait

L'axe des Y est l'inverse de l'OP.

— Neil
source

2

Röda , 74 octets

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

Essayez-le en ligne!

Non 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
source

2

Python 3 , 87 83 octets

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

Essayez-le en ligne!

L'axe des y est inversé

— ovs
source

2

Gelée , 14 13 octets

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

L'axe des x est inversé.

Essayez-le en ligne!

Comment ça fonctionne

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
source

1

dc , 79 octets

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

L' yaxe est inversé tandis que lex -axis ne l'est pas.

Essayez-le en ligne!

— R. Kap
source

1

MATL , 13 octets

:qU&+G\1=88*c

L'origine est en haut à gauche. La sortie est donc inversée par rapport aux exemples du défi.

Essayez MATL en ligne!

Explication

:      % 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
source

1

Python 3 , ( 102 98 95 octets)

axe y inversé

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()

Essayez-le en ligne!

4 octets enregistrés: variable omise c dans c = '' if (i i + j j)% n-1else'X '
économisé 3 octets: Merci aux ovs (instruction d'impression modifiée)

— officialaimm
source

1

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

— ovs

1

Lithp , 125 octets

#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")

Saut de ligne pour la lisibilité.

Essayez-le en ligne!

Pas le plus court. Je pense que j'ai besoin d'une sorte de module raccourci. Voir le lien Try it Online pour plus d'explications, une version non golfée et quelques tests. Pour de meilleurs résultats, développez la fenêtre de sortie pour en voir plus.

— Andrakis
source

1

Python 3 , 82 octets

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)))

Essayez-le en ligne!

— Dennis
source

1

GNU APL , 41 caractères, 59 octets

Lit un entier et affiche le cercle.

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

Non 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
source

0

Haskell, 115 octets

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

L'axe y est inversé.

Essayez-le en ligne!

Toutes ces parenthèses me gênent un peu ...

Explication

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

— Nom d'affichage générique
source

Vous pouvez remplacer le dernier mappar un <$>, non?

— k_g

À moins que j'interprète mal les règles de la question, je ne pense pas que vous ayez besoin de tout ce que les E / S - les E / S de golf sur PPCG ont des valeurs par défaut spéciales pour permettre à autant de langues que possible de participer. Par exemple, votre fonction principale peut prendre un argument entier et renvoyer une chaîne.

— Ørjan Johansen

@k_g oui merci

— Nom d'affichage générique

@ ØrjanJohansen dûment noté :)

— Nom d'affichage générique

0

J , 20 octets

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

Essayez-le en ligne!

— Leaky Nun
source

0

GolfScript , 34 octets

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

Essayez-le en ligne!

Je n'aime vraiment pas utiliser des variables ...

— Leaky Nun
source

Dessine-moi le cercle unitaire (bizarre)!

introduction

Le défi

Contribution

Production

Plus de détails

Qui gagne?

Exemples

Utilitaires Bash + GNU, 59

Octave , 45 44 octets

Haskell , 68 octets

Mathematica, 56 48 octets

Solution originale:

CJam , 23 octets

JavaScript (ES6), 81 octets

Röda , 74 octets

Python 3 , 87 83 octets

Gelée , 14 13 octets

Comment ça fonctionne

dc , 79 octets

MATL , 13 octets

Explication

Python 3 , ( 102 98 95 octets)

axe y inversé

Lithp , 125 octets

Python 3 , 82 octets

GNU APL , 41 caractères, 59 octets

Non golfé

Haskell, 115 octets

Explication

J , 20 octets

GolfScript , 34 octets