Giới thiệu

Bạn có thể biết và yêu vòng tròn đơn vị bình thường của bạn. Nhưng các nhà toán học là điên rồ và do đó họ đã trừu tượng hóa khái niệm này đến bất kỳ điểm nào thỏa mãn x*x+y*y=1. Bởi vì Tiền điện tử ¹ cũng kỳ lạ, họ yêu thích các trường hữu hạn và đôi khi là các vòng hữu hạn (mặc dù không có nhiều sự lựa chọn), vì vậy hãy kết hợp điều này!

Các thách thức

Đầu vào

Một số nguyên dương lớn hơn một trong mã hóa yêu thích của bạn. Hãy gọi số này là n.

Đầu ra

Bạn sẽ xuất "hình ảnh" (bao gồm n lần n ký tự) của vòng tròn đơn vị modulo số nguyên đầu vào là ASCII-Art bằng cách sử dụng "X" (chữ hoa chữ thường chữ X) và "" (dấu cách). Không gian lưu trữ và dòng mới được cho phép.

Thêm chi tiết

Bạn phải mở rộng một hệ tọa độ từ dưới cùng bên trái sang trên cùng bên phải. Bất cứ khi nào một điểm hoàn thành phương trình đường tròn, đặt X tại vị trí, nếu không thì đặt một khoảng trắng.

Điều kiện để một điểm được coi là một phần của đường viền vòng tròn là :
mod(x*x+y*y,n)==1.

Dưới đây là một minh họa nhanh về hệ tọa độ:

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

Nếu nó giúp bạn, bạn cũng có thể đảo ngược hướng của bất kỳ trục nào, nhưng các ví dụ giả định hướng này.

Ai thắng?

Đây là mã golf, vì vậy mã ngắn nhất trong byte sẽ thắng! Chỉ cho phép các phương thức I / O mặc định và tất cả các sơ hở tiêu chuẩn đều bị cấm.

Ví dụ

Đầu vào: 2

X 
 X

Đầu vào: 3

X  
X  
 XX

Đầu vào: 5

X    


X    
 X  X

Đầu vào: 7

Đầu vào: 11

Đầu vào: 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

¹_{Tôi đề nghị bạn hãy xem hồ sơ của tôi nếu bạn đang tự hỏi ở đây.}

— THÁNG 9
nguồn

Theo tôi, có vẻ tốt hơn nhiều nếu bạn sử dụng tên miền [0, n]. Dưới đây là một ví dụ với đầu vào 42.

— R. Kap

Theo "I / O tiêu chuẩn", bạn có nghĩa là các phương thức I / O mặc định, hay bạn có nghĩa là STDIN / STDOUT thực tế? Tôi giả sử cái trước, nhưng tôi nghĩ ai đó bên dưới đã hiểu nó là cái sau.

— Ørjan Johansen

@ RjanJohansen thực sự là cựu.

— SEJPM

Là dòng mới trước được phép?

— fergusq

@fergusq vì họ sẽ (quyết liệt) thay đổi con số đầu ra theo cách có thể nhìn thấy, không.

— SEJPM

6

Tiện ích Bash + GNU, 59

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

Đầu vào nđược đưa ra dưới dạng tham số dòng lệnh. Trục y bị đảo ngược.

Hãy thử trực tuyến .

— Chấn thương kỹ thuật số
nguồn

4

Octave , 45 44 byte

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

Hãy thử trực tuyến!

— lỗ hổng
nguồn

Điều này cũng hoạt động : @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. Trong một số hệ thống nhất định, Octave coi nhân vật 0là một khoảng trống

— Luis Mendo

3

Haskell , 68 byte

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

Hãy thử trực tuyến! Trục y được lật. Cách sử dụng: f 42trả về một chuỗi giới hạn dòng mới.

Đây là một sự hiểu biết danh sách lồng nhau trong đó cả hai xvà yđược rút ra từ phạm vi [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]là một hình thức ngắn hơn của if mod(x*x+y*y)n==1 then 'X' else ' '. Việc hiểu danh sách đánh giá thành một danh sách các chuỗi được chuyển thành một chuỗi mới được phân tách bằng một chuỗi unlines.

— Laikoni
nguồn

3

Toán học, 56 48 byte

Chỉnh sửa: Cảm ơn Greg Martin và Martin Ender đã lưu 8 byte.

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

Giải pháp ban đầu:

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

— ngenisis
nguồn

Nhận xét thú vị: bạn không cần dấu phẩy sau X:)

— Greg Martin

1

Tôi nghĩ rằng bạn tốt hơn với Arrayvà Norm:Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

— Martin Ender

2

Vẫn còn suy nghĩ về nó ... #^2+#2^2là ngắn nhất.

— Martin Ender

@GregMartin Vì vậy, nếu đối số đầu tiên Iflà không Truehoặc False, bạn cần đối số thứ tư hoặc nó vẫn không được đánh giá, nhưng If[False,_]trả về Null. Kỳ dị.

— ngenisis

@MartinEnder Ban đầu tôi đã thử Arraynhưng không nghĩ sẽ đặt đối số thành một biến.

— ngenisis

2

CJam , 23 byte

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

Hãy thử trực tuyến!

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
nguồn

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>

Mở rộng đoạn trích

Trục Y là đảo ngược của OP.

— Neil
nguồn

2

Röda , 74 byte

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

Hãy thử trực tuyến!

Ung dung:

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
nguồn

2

Python 3 , 87 83 byte

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

Hãy thử trực tuyến!

Trục y bị đảo ngược

— lò nướng
nguồn

2

Thạch , 14 13 byte

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

Trục x được đảo ngược.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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
nguồn

1

dc , 79 byte

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

Các y-axis được đảo ngược trong khi x-axis thì không.

Hãy thử trực tuyến!

— R. Kap
nguồn

1

MATL , 13 byte

:qU&+G\1=88*c

Nguồn gốc ở trên cùng bên trái. Vì vậy, đầu ra được lật ngược so với các ví dụ trong thử thách.

Hãy thử tại MATL trực tuyến!

Giải trình

:      % 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
nguồn

1

Python 3 , ( 102 98 95 byte)

trục y ngược

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

Hãy thử trực tuyến!

đã lưu 4 byte: bỏ qua biến c trong c = '' if (i i + j j)% n-1else'X '
đã lưu 3 byte: Nhờ có ovs (câu lệnh in được sửa đổi)

— chính thức
nguồn

1

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

— ovs

1

Tiếng Litva , 125 byte

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

Linebreak cho dễ đọc.

Hãy thử trực tuyến!

Không phải là ngắn nhất. Tôi nghĩ rằng tôi cần một số loại mô-đun tốc ký. Xem liên kết Dùng thử trực tuyến để được giải thích thêm, phiên bản không được chỉnh sửa và một số thử nghiệm. Để có kết quả tốt nhất, hãy mở rộng cửa sổ đầu ra để xem thêm.

— Andrakis
nguồn

1

Python 3 , 82 byte

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

Hãy thử trực tuyến!

— Dennis
nguồn

1

GNU APL , 41 ký tự, 59 byte

Đọc một số nguyên và hiển thị vòng tròn.

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

Ung dung

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

— Phòng Megashroom
nguồn

0

Haskell, 115 byte

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

Trục y bị đảo ngược.

Hãy thử trực tuyến!

Tất cả những dấu ngoặc đơn đó đều làm tôi khó chịu ...

Giải trình

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

— Tên hiển thị chung
nguồn

Bạn có thể thay thế cuối cùng mapvới một <$>, phải không?

— k_g

Trừ khi tôi hiểu sai các quy tắc câu hỏi, tôi không nghĩ bạn cần tất cả I / O - I / O chơi gôn trên PPCG có các mặc định đặc biệt để cho phép càng nhiều ngôn ngữ càng tốt để tham gia. Ví dụ, hàm chính của bạn có thể lấy một đối số nguyên và trả về một chuỗi.

— Ørjan Johansen

@k_g vâng cảm ơn bạn

— Tên hiển thị chung

@ RjanJohansen ghi chú hợp lệ :)

— Tên hiển thị chung

0

J , 20 byte

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

Hãy thử trực tuyến!

— Nữ tu bị rò rỉ
nguồn

0

GolfScript , 34 byte

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

Hãy thử trực tuyến!

Tôi thực sự không thích sử dụng các biến ...

— Nữ tu bị rò rỉ
nguồn

Vẽ cho tôi vòng tròn đơn vị (kỳ lạ)!

Giới thiệu

Các thách thức

Đầu vào

Đầu ra

Thêm chi tiết

Ai thắng?

Ví dụ

Tiện ích Bash + GNU, 59

Octave , 45 44 byte

Haskell , 68 byte

Toán học, 56 48 byte

Giải pháp ban đầu:

CJam , 23 byte

JavaScript (ES6), 81 byte

Röda , 74 byte

Python 3 , 87 83 byte

Thạch , 14 13 byte

Làm thế nào nó hoạt động

dc , 79 byte

MATL , 13 byte

Giải trình

Python 3 , ( 102 98 95 byte)

trục y ngược

Tiếng Litva , 125 byte

Python 3 , 82 byte

GNU APL , 41 ký tự, 59 byte

Ung dung

Haskell, 115 byte

Giải trình

J , 20 byte

GolfScript , 34 byte