Giriş

Normal birim çemberinizi bilebilir ve sevebilirsiniz. Ancak matematikçiler çılgındır ve bu nedenle kavramı tatmin edici herhangi bir noktaya soyutlamışlardır x*x+y*y=1. Kriptograflar ¹ de garip olduğundan, sonlu alanları ve bazen sonlu halkaları severler (yine de çok fazla seçeneğe sahip değiller), bu yüzden bunu birleştirelim!

Meydan okuma

Giriş

En sevdiğiniz kodlamada birden büyük pozitif tam sayı. Bu numaraya n diyelim.

Çıktı

"X" (büyük harf latin X) ve "" (boşluk) kullanarak, birim çemberinin "resim" (n kez n karakterden oluşur) giriş tamsayısını ASCII-Art olarak göndereceksiniz. Sondaki boşluklara ve yeni satırlara izin verilir.

Daha fazla detay

Bir koordinat sistemini sol alttan sağ üste yaymanız gerekir. Bir nokta, daire denklemini her yerine getirdiğinde, bir X'i konuma yerleştirin, aksi takdirde bir boşluk yerleştirin.

Bir nokta için koşul daire sınırın bir parçası olarak kabul edilmelidir:
mod(x*x+y*y,n)==1.

İşte koordinat sisteminin kısa bir açıklaması:

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

Size yardımcı olursa, eksenlerden herhangi birinin yönünü de tersine çevirebilirsiniz, ancak örnekler bu yönlendirmeyi varsayar.

Kim kazanır?

Bu kod golf yani bayt kısa kodu kazanır! Yalnızca varsayılan G / Ç yöntemlerine izin verilir ve tüm standart boşluklar yasaklanır.

Örnekler

Giriş: 2

X 
 X

Giriş: 3

X  
X  
 XX

Giriş: 5

X    


X    
 X  X

Giriş: 7

X      
  X  X 


  X  X 
X      
 X    X

Giriş: 11

X          

     XX    

   X    X  
   X    X  

     XX    

X          
 X        X

Giriş: 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

¹ _{Eğer merak ediyorsanız profilime bir göz atmanızı öneririm.}

Bash + GNU Araçları, 59

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

nKomut satırı parametresi olarak verilen girdi . Y ekseni ters çevrilir.

Çevrimiçi deneyin .

Oktav , 45 44 bayt

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

Çevrimiçi deneyin!

Haskell , 68 bayt

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

Çevrimiçi deneyin! Y ekseni çevrilir. Kullanım: f 42satırsonu ile ayrılmış bir dize döndürür.

Bu, hem bir iç listedir anlama olduğunu xve yaralığından çizilir [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]daha kısa bir biçimidir if mod(x*x+y*y)n==1 then 'X' else ' '. Liste kavrama, tek satırdan ayrı yeni bir dize haline dönüştürülen dizelerin bir listesi olarak değerlendirilir unlines.

Mathematica, 56 48 bayt

Düzenleme: 8 bayt tasarruf için Greg Martin ve Martin Ender'e teşekkürler.

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

Orijinal çözüm:

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

CJam , 23 bayt

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

Çevrimiçi deneyin!

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 bayt

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>

Y ekseni OP'nin tersidir.

Röda , 74 bayt

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

Çevrimiçi deneyin!

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
}

Python 3 , 87 83 bayt

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

Çevrimiçi deneyin!

Y ekseni ters çevrilir

Jöle , 14 13 bayt

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

X ekseni ters çevrilir.

Çevrimiçi deneyin!

Nasıl çalışır

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.

dc , 79 bayt

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

y-Axis ise ters çevrilirx -Axis değildir.

Çevrimiçi deneyin!

MATL , 13 bayt

:qU&+G\1=88*c

Kökeni sol üst köşede. Böylece çıktı, meydan okumadaki örneklerle karşılaştırıldığında baş aşağı çevrilir.

Çevrimiçi MATL'de deneyin !

açıklama

:      % 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 bayt)

y ekseni ters çevrildi

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

Çevrimiçi deneyin!

• 4 bayt kaydedildi: (i i + j j)% n-1else'X ' ise c =' 'değişkenindeki c değişkeni atlandı
• 3 bayt kaydedildi: ovs sayesinde (değiştirilmiş baskı bildirimi)

Lithp , 125 bayt

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

Okunabilirlik için linebreak.

Çevrimiçi deneyin!

En kısa değil. Sanırım bir çeşit stenografi modülüne ihtiyacım var. Daha fazla açıklama, çözülmemiş sürüm ve bazı testler için Çevrimiçi Deneyin bağlantısına bakın. En iyi sonuçlar için daha fazlasını görmek üzere çıktı penceresini genişletin.

Python 3 , 82 bayt

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

Çevrimiçi deneyin!

GNU APL , 41 karakter, 59 bayt

Bir tamsayıyı okur ve daireyi görüntüler.

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

Haskell, 115 bayt

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

Y ekseni ters çevrilir.

Çevrimiçi deneyin!

Bütün bu parantezler beni rahatsız ediyor ...

açıklama

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 bayt

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

Çevrimiçi deneyin!

GolfScript , 34 bayt

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

Çevrimiçi deneyin!

Değişkenleri kullanmaktan gerçekten hoşlanmıyorum ...