Einführung

Sie können Ihren normalen Einheitskreis kennen und lieben. Aber Mathematiker sind verrückt und haben das Konzept so weit abstrahiert, dass es befriedigt x*x+y*y=1. Da Kryptographen ¹ auch komisch sind, lieben sie endliche Felder und manchmal endliche Ringe (es ist jedoch nicht so, als hätten sie eine große Auswahl), also kombinieren wir dies!

Die Herausforderung

Eingang

Eine positive ganze Zahl größer als eine in Ihrer Lieblingskodierung. Nennen wir diese Nummer n.

Ausgabe

Sie geben das "Bild" (das aus n mal n Zeichen besteht) des Einheitskreises aus, indem Sie die eingegebene Ganzzahl als ASCII-Art mit "X" (lateinisches Großbuchstaben X) und "" (ein Leerzeichen) modulieren. Leerzeichen und Zeilenumbrüche sind erlaubt.

Mehr Details

Sie müssen ein Koordinatensystem von links unten nach rechts oben überspannen. Wenn ein Punkt die Kreisgleichung erfüllt, platzieren Sie ein X an der Position, andernfalls platzieren Sie ein Leerzeichen.

Die Bedingung für einen Punkt ein Teil der Kreisgrenze betrachtet werden soll:
mod(x*x+y*y,n)==1.

Hier eine kurze Darstellung des Koordinatensystems:

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

Wenn es Ihnen hilft, können Sie auch die Richtung einer der Achsen umkehren, aber die Beispiele nehmen diese Ausrichtung an.

Wer gewinnt?

Das ist Code-Golf, also gewinnt der kürzeste Code in Byte! Es sind nur die Standard-E / A-Methoden zulässig, und alle Standardlücken sind gesperrt.

Beispiele

Eingabe: 2

X 
 X

Eingabe: 3

X  
X  
 XX

Eingabe: 5

X    


X    
 X  X

Eingabe: 7

Eingabe: 11

Eingabe: 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

¹_{Ich schlage vor, Sie werfen einen Blick auf mein Profil, wenn Sie sich hier wundern.}

— SEJPM
quelle

Sieht viel besser aus, wenn Sie meiner Meinung nach die Domain [0, n] verwenden. Hier ist ein Beispiel mit Eingabe 42.

— R. Kap

Mit "Standard-E / A" meinen Sie Standard-E / A-Methoden oder meinen Sie tatsächliche STDIN / STDOUT? Ich nehme das erstere an, aber ich denke, jemand unten hat es als das letztere interpretiert.

— Ørjan Johansen

@ ØrjanJohansen ja erstere.

— SEJPM

Sind vorangestellte Zeilenumbrüche erlaubt?

— Fergusq

@fergusq wie sie (drastisch) die Ausgangszahl auf sichtbare Weise ändern würden, nein.

— SEJPM

6

Bash + GNU Utilities, 59

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

Eingabe nals Befehlszeilenparameter. Die y-Achse ist invertiert.

Probieren Sie es online aus .

— Digitales Trauma
quelle

4

Oktave , 45 44 Bytes

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

Probieren Sie es online!

— fehlerhaft
quelle

Dies funktioniert auch: @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. In bestimmten Systemen behandelt Octave Zeichen 0als Leerzeichen

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

Probieren Sie es online! Die y-Achse ist gespiegelt. Verwendung: f 42Gibt eine durch Zeilenumbrüche getrennte Zeichenfolge zurück.

Dies ist eine verschachtelte Liste Verständnis , wo beide xund ysind aus dem Bereich gezogen [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]ist eine kürzere Form von if mod(x*x+y*y)n==1 then 'X' else ' '. Das Listenverständnis wird zu einer Liste von Zeichenfolgen ausgewertet, die in eine einzelne, durch eine neue Zeile getrennte Zeichenfolge umgewandelt wird unlines.

— Laikoni
quelle

3

Mathematica, 56 48 Bytes

Edit: Danke an Greg Martin und Martin Ender für das Speichern von 8 Bytes.

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

Ursprüngliche Lösung:

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

— Genisis
quelle

Amüsante Bemerkung: Sie brauchen kein Komma nach X:)

— Greg Martin

1

Ich denke, Sie sind besser dran mit Arrayund Norm:Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

— Martin Ender

2

Immer noch überdenken ... #^2+#2^2ist am kürzesten.

— Martin Ender

@GregMartin Wenn das erste Argument Ifweder Trueoder ist False, benötigen Sie das vierte Argument oder es bleibt unbewertet, If[False,_]kehrt aber zurück Null. Seltsam.

— ngenisis

@MartinEnder Ich habe anfangs versucht Array, aber nicht daran gedacht, das Argument auf eine Variable zu setzen.

— Genisis

2

CJam , 23 Bytes

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

Probieren Sie es online!

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
quelle

2

JavaScript (ES6), 81 Byte

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>

Erweitern Sie das Snippet

Die Y-Achse ist die Umkehrung des OP.

— Neil
quelle

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[" "]}_;["
"]}_}

Probieren Sie es online!

Ungolfed:

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
quelle

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

Probieren Sie es online!

Die y-Achse ist invertiert

— ovs
quelle

2

Jelly , 14 13 Bytes

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

Die x-Achse ist invertiert.

Probieren Sie es online!

Wie es funktioniert

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
quelle

1

Gleichstrom , 79 Bytes

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

Die y-Achse ist invertiert, die x-Achse nicht.

Probieren Sie es online!

— R. Kap
quelle

1

MATL , 13 Bytes

:qU&+G\1=88*c

Der Ursprung ist oben links. Die Ausgabe wird also im Vergleich zu den Beispielen in der Challenge auf den Kopf gestellt.

Probiere es bei MATL online aus!

Erläuterung

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

1

Python 3 ( 102 98 95 Byte)

y-Achse invertiert

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

Probieren Sie es online!

4 Bytes gespart: Variable c in c weggelassen = '' if (i i + j j)% n-1else'X '
3 Bytes gespart: Dank ovs (modifizierte Druckanweisung)

— officialaimm
quelle

1

p(end=' 'if(i*i+j*j)%n-1else'X')für 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")

Zeilenumbruch zur besseren Lesbarkeit.

Probieren Sie es online!

Nicht die kürzeste. Ich glaube, ich brauche eine Art Shorthand-Modul. Weitere Erklärungen, die ungolfed Version und einige Tests finden Sie unter dem Link Online testen. Erweitern Sie für optimale Ergebnisse das Ausgabefenster, um mehr zu sehen.

— Andrakis
quelle

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

Probieren Sie es online!

— Dennis
quelle

1

GNU APL , 41 Zeichen, 59 Bytes

Liest eine Ganzzahl und zeigt den Kreis an.

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

Ungolfed

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

— Mega-Pilz
quelle

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

Die y-Achse ist invertiert.

Probieren Sie es online!

All diese Klammern nerven mich irgendwie ...

Erläuterung

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

— Generischer Anzeigename
quelle

Du kannst den letzten mapdurch einen ersetzen <$>, oder?

— k_g

Sofern ich die Fragenregeln nicht falsch interpretiere, brauche ich nicht alles, was ich brauche. Golf-I / O bei PPCG hat spezielle Standardeinstellungen , damit so viele Sprachen wie möglich teilnehmen können. Beispielsweise kann Ihre Hauptfunktion ein ganzzahliges Argument annehmen und eine Zeichenfolge zurückgeben.

— Ørjan Johansen

@ k_g ja danke

— Generischer Anzeigename

@ ØrjanJohansen ordnungsgemäß zur Kenntnis genommen :)

— Generischer Anzeigename

0

J , 20 Bytes

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

Probieren Sie es online!

— Undichte Nonne
quelle

0

GolfScript , 34 Bytes

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

Probieren Sie es online!

Ich mag es wirklich nicht, Variablen zu benutzen ...

— Undichte Nonne
quelle

Zeichne mir den (seltsamen) Einheitskreis!

Einführung

Die Herausforderung

Eingang

Ausgabe

Mehr Details

Wer gewinnt?

Beispiele

Bash + GNU Utilities, 59

Oktave , 45 44 Bytes

Haskell , 68 Bytes

Mathematica, 56 48 Bytes

Ursprüngliche Lösung:

CJam , 23 Bytes

JavaScript (ES6), 81 Byte

Röda , 74 Bytes

Python 3 , 87 83 Bytes

Jelly , 14 13 Bytes

Wie es funktioniert

Gleichstrom , 79 Bytes

MATL , 13 Bytes

Erläuterung

Python 3 ( 102 98 95 Byte)

y-Achse invertiert

Lithp , 125 Bytes

Python 3 , 82 Bytes

GNU APL , 41 Zeichen, 59 Bytes

Ungolfed

Haskell, 115 Bytes

Erläuterung

J , 20 Bytes

GolfScript , 34 Bytes