画我（怪异）的单位圈！

20

介绍

您可能知道并喜欢您的普通单位圈子。但是数学家疯了，因此他们把这个概念抽象到可以满足的任何程度x*x+y*y=1。因为密码学家1也很奇怪，所以他们喜欢有限的场，有时还喜欢有限的环（虽然他们没有太多选择），所以让我们结合一下吧！

挑战

输入值

您喜欢的编码中大于1的正整数。我们称这个数字为n。

输出量

您将使用“ X”（大写拉丁字母X）和“”（空格）将单位圆的“图片”（由n个n个字符组成）以ASCII-Art模输入整数。允许使用尾随空格和换行符。

更多细节

您必须从左下到右上跨一个坐标系。只要一个点满足圆方程，就在该位置放置一个X，否则放置一个空格。

将点视为圆形边界一部分的条件是：
mod(x*x+y*y,n)==1。

这里是坐标系的快速说明：

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

如果有帮助，您也可以反转任意轴的方向，但是示例均采用这种方向。

谁赢？

这是代码高尔夫球，因此以字节为单位的最短代码获胜！仅允许使用默认的I / O方法，并且禁止所有标准漏洞。

例子

输入2

X 
 X

输入3

X  
X  
 XX

输入5

X    


X    
 X  X

输入7

X      
  X  X 


  X  X 
X      
 X    X

输入：11

X          

     XX    

   X    X  
   X    X  

     XX    

X          
 X        X

输入：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

1 如果您在这里想知道，我建议您看看我的个人资料。

code-golf  math  ascii-art  abstract-algebra 
— SEJPM
source
我认为如果使用域[0，n]，看起来会更好。这里是具有输入42的示例
— R.甲
“标准I / O”是指默认I / O方法，还是实际的STDIN / STDOUT？我假设是前者，但我认为下面的人将其解释为后者。
— 与Orjan约翰森
@ØrjanJohansen确实是前者。
— SEJPM'4
是否允许前面的换行符？
— fergusq
@fergusq，因为它们（会）以一种可见的方式（极大地）改变输出图形，不。
— SEJPM

Answers:

6

Bash + GNU实用程序，59

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

输入n作为命令行参数给出。y轴反转。

在线尝试。

— 数字创伤
source
4

八度，45 44字节

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

在线尝试！

— 瑕疵
source
这也适用于：@(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']。在某些系统中，八度把角色0视为一个空间
— Luis Mendo
3

Haskell，68个字节

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

在线尝试！y轴被翻转。用法：f 42返回以换行符分隔的字符串。

这是一个嵌套列表推导，其中x和y均来自范围[0..n-1]。last$' ':['X'|mod(x*x+y*y)n==1]是的较短形式if mod(x*x+y*y)n==1 then 'X' else ' '。列表推导计算得出一个字符串列表，该列表将转换为单个换行符，并用分隔字符串unlines。

— 莱科尼
source
3

Mathematica，56 48个字节

编辑：感谢Greg Martin和Martin Ender节省了8个字节。

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

原始解决方案：

Grid@Table[If[Tr[{i-1,j-1}^2]~Mod~#==1,X,],{i,#},{j,#}]&
— 念珠菌病
source
有趣的话：您不需要在逗号后X:)
— Greg Martin
1
我认为您最好选择Array和Norm：Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&
— Martin Ender
2
仍然想得太多... #^2+#2^2最短。
— Martin Ender
@GregMartin因此，如果第一个参数If既不是True或False，你需要的第四个参数，或者保持不计算，但If[False,_]回报率Null。奇怪的。
— ngenisis'4
@MartinEnder我最初尝试过，Array但没有想到将参数设置为变量。
— ngenisis
2

CJam，23个字节

ri:X,2f#_ff{+X%(S'X?}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.
— 马丁·恩德
source
2

JavaScript（ES6），81个字节

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轴是OP的反向。

— 尼尔
source
2

Röda，74个字节

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

在线尝试！

取消高尔夫：

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

果冻，14 13字节

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

x轴反转。

在线尝试！

怎么运行的

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.
— 丹尼斯
source
1

dc，79字节

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

- y轴反转，而- x轴未反转。

在线尝试！

— 卡普
source
1

MATL，13字节

:qU&+G\1=88*c

原点在左上方。因此，与挑战中的示例相比，输出颠倒了。

在线尝试MATL！

说明

:      % 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
— 路易斯·门多
source
1

Python 3，（102 98 95字节）

y轴倒置

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

在线尝试！

  • 保存了4个字节：c =''if（i i + j j）％n-1else'X'中省略了变量c
  • 保存了3个字节：感谢ovs（修改后的打印语句）
— 官方网站
source
1
p(end=' 'if(i*i+j*j)%n-1else'X')为95个字节
— ovs '17
1

Lithp，125个字节

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

换行以提高可读性。

在线尝试！

不是最短的。我想我需要某种速记模块。请参阅“在线试用”链接以获取进一步的说明，非高尔夫版本和一些测试。为了获得最佳结果，请扩展输出窗口以查看更多信息。

— 安德拉基斯
source
1

GNU APL，41个字符，59个字节

读取整数并显示圆。

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

不打高尔夫球

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
— 巨型蘑菇
source
0

Haskell，115个字节

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轴反转。

在线尝试！

所有这些括号都让我很烦。

说明

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
— 通用显示名称
source
您可以将最后map一个替换为<$>，对吗？
— k_g
除非我误解了问题规则，否则我认为您不需要所有I / O-PPCG上的golfing I / O具有特殊的默认设置，以允许尽可能多的语言参与。例如，您的main函数可以使用整数参数并返回字符串。
— 与Orjan约翰森
@k_g是的，谢谢您
— 通用显示名称
@ØrjanJohansen适当注明:)
— 通用显示名称
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.