这种挑战的目的是为了描绘图形平面上，其中，每个步骤的方向散步是由素性确定及其二进制展开的奇偶性。特别，$k$$k$

• 初始方向是固定的，例如北。
• 所有步骤的长度相同。
• 步骤的方向可以是北，西，南或东，并确定如下： $k$
  • 如果不是素数，则方向不会改变。$k$
  • 如果是素数，的二进制展开拥有者的偶数，右转。$k$$k$
  • 如果是素数，的二进制展开具有奇数个1，左转。$k$$k$

作为一个可行的示例，假设初始方向是北。第一步是：

• $k=1$不是素数。因此，我们朝当前方向（北）移动了一步。
• $k=2$是质数，并且其二进制扩展10数具有奇数个。所以我们左转，现在正对着西方。我们朝这个方向迈出了一步。
• $k=3$是质数，它的二进制扩展11数，具有偶数个。因此，我们向右转，现在正对着北方。我们朝这个方向迈出了一步。
• $k=4$不是素数。因此，我们朝当前方向（北）移动了一步。

挑战

输入：正整数。$N$

输出：如上定义的步走的图。$N$

附加规则

• 的初始方向可以自由地选择（不一定北），但应该是全部相同。$N$
• 的转动规则可以是与上述相反，即，右转奇校验并放置甚至; 但是对于所有它必须相同。$N$
• 输出必须是步行的图形描述。例如：
  • 可以用线段绘制步行。
  • 可以使用标记（例如点）来显示访问点；有或没有连接线段。
  • 可以提供两种颜色的光栅图像，一种颜色对应于已访问的点，另一种颜色则用于未访问的点。
• 水平轴和垂直轴的比例不必相同。轴标签和类似元素也是可选的。只要可以清楚地看到步行，该情节就是有效的。
• 请注意，某些点被多次访问。情节对此并不敏感。例如，如果在曲线图中显示了线段，则无论其经过多少次，每个单位段都将显示为相同。
• 该代码应适用于任何N给定的无限资源。如果在实践中N由于时间，内存或数据类型的限制而导致故障很大，则可以接受。
• 输入和输出像往常一样灵活。特别地，可以使用用于输出图像的任何标准装置。
• 以字节为单位的最短代码获胜。

测试用例

下图以北为初始方向。甚至平价向右转；并用线段描绘了步行路线。

N = 7：

N = 3000：

N = 20000：

N = 159000：

N = 1200000：

N = 11000000：

大锤0.4，22 20个字节

⢂⡐⠥⡄⠡⢒⣩⣀⣼⡝⢄⡎⣛⠅⡉⣱⡆⢀⡠⣽

解压缩到此Wolfram语言函数：

ListPlot[AnglePath[Array[If[PrimeQ@#, ArcSin[(-1)^ThueMorse@#], 0] &, #]]]

不打高尔夫球

首先，我们定义一个函数，该函数返回在每一步旋转的角度：

If[PrimeQ[#],
    ArcSin[(-1)^ThueMorse@#],
    0
]&

ThueMorse是二进制数字总和的奇偶校验。我们使用-1^(...)而不是2*...-1出于一个稍微复杂的原因：Wolfram语言自动将源中的算术表达式转换为规范形式，因此将诸如之类2/x的表达式存储为Times[2, Power[x, -1]]。这使得频率Power非常高，因此将其压缩非常便宜。

（乘以Boole@PrimeQ@稍长，并且Boole在挑战之时尚未实现对布尔值的隐式转换。）

从这里，Mathematica的AnglePath和ListPlot做的正是我们所需要的：

ListPlot[AnglePath[Array[%, #]]]&

在交互式应用程序中，输出是可缩放矢量图形对象。

MATL，25 24 21字节

Q:qJyZpbB!sEq*^YpYsXG

在MATL在线尝试

感谢@LuisMendo在聊天中进行了一场不错的高尔夫练习，通过提出建议最终导致了这个21字节的版本 Eq*^

说明

Q:q % Push 0:n
J   % Push 1i for later use.
y   % Duplicate 0:n from below
Zp  % Vector result of isprime()
b   % Bubble 0:n from bottom of stack
B!s % Sum of bits in binary representation
Eq  % Double minus one to get an odd number
*   % Multiply by isprime result to get either zero or aforementioned odd number
^   % Exponentiate 1i by an odd number or zero to get -i, 1 or i (corresponding to left turn, straight ahead, right turn).
Yp  % Cumulative product to get a vector of directions
Ys  % Cumulative sum to get vector of positions
XG  % Plot

$k=12345$

C（gcc），179字节

o;i;d;k;h;f(n,p)char*p;{h=2*n+1;memset(p,0,h*h);p+=h--*n+n;*p=1;for(d=k=0;k++<n;){for(i=1;k%++i%k;);for(o=k;o/2;o=o/2^o&1);i==k?d+=o*2+3:0;p+=(d%2*h+1)*((d&2)-1);*p=1;}return++h;}

在线尝试！

$4 n^2 + 4 n + 1$01

C（gcc），219字节

o;i;d;k;h;f(n,p)char*p;{h=2*n+1;p+=sprintf(p,"P1 %d %d ",h,h);memset(p,48,h*h);k=h--*n+n;*(p+2*k+1)=0;p+=k;*p=49;for(d=k=0;k++<n;){for(i=1;k%++i%k;);for(o=k;o/2;o=o/2^o&1);i==k?d+=o*2+3:0;p+=(d%2*h+1)*((d&2)-1);*p=49;}}

在线尝试！

$4 n^2 + 4 n + 2 \times \lfloor log_{10}(2n+1)\rfloor + 9$

20000的裁剪输出：

两种版本均以west开头，右转为奇数，左转为偶数。

我尝试了两个都不用的大型测试用例，因为20000的输出约为1.5 GB，而150000的输出约为90GB。程序执行时，所有这些都存储在内存中。

上一个的解释：

o;         /* Temporary variable for calculating parity */
i;         /* Temporary variable for primality test */
d;         /* d % 4 = direction */
k;         /* Step */
h;         /* height/width of image */
f(n,p)char*p;{ /* Function taking int and char pointer */
  h=2*n+1;     /* Image sidelength = 2 * N + 1, so N in each direction */
  memset(p,0,h*h); /* Reset buffer */
  p+=h--*n+n;  /* Position p at image center; decrement h */
  *p=1;        /* Put a dot at center */
  for(d=k=0;   /* Set direction and step to 0 */
    k++<n;){   /* Loop over [1..N] */
    for(i=1;k%++i%k;); /* Primality test */
    for(o=k;o/2;o=o/2^o&1); /* Parity test */
    i==k?d+=o*2+3:0; /* Change direction if necessary */
    p+=(d%2*h+1)*((d&2)-1); /* Move according to direction */
    *p=1; /* Set pixel to black */
  }
  return++h; /* Add 1 back to h and return */
}

Wolfram语言（Mathematica），98 96 91 77 76 63字节

ListPlot@AnglePath@Array[Pi/2If[PrimeQ@#,2ThueMorse@#-1,0]&,#]&

-14个字节：感谢@lirtosiast向我展示了如何使用AnglePath ...

-13个字节：...和ThueMorse！

用法示例：

%[20000]

分步说明：

• If[PrimeQ@#, 2 ThueMorse@# - 1, 0] &是一个函数，它获取步长索引，对于非素数返回0，对于偶数二元素返回-1，对于奇数二元素返回+1。ThueMorse@#替换先前的解决方案Total[#~IntegerDigits~2]（相同，取模2）。

• Array[Pi/2*%,#]列出此函数的列表，索引从1到函数参数（在示例中为20000），然后将每个元素乘以π/ 2使其变为方向改变角（弧度）。现在，非素数为0，偶数素数为-π/ 2，奇数二进制素数为+π/ 2。

• AnglePath[%]将此方向改变角度列表转换为路径。该指令替代了先前解决方案的重复使用Accumulate。

• ListPlot[%]将位置列表转换为XY点图。如果首选一行，请ListLinePlot改用。这些绘图功能具有许多选项，可以使绘图看起来更好。

MATL，31 30 28 26字节

J4:^0i:Zpl_G:B!s^*hYs)YsXG

@LuisMendo节省了3个字节

@Sanchises节省了2个字节

在MATL Online上尝试

说明

该解决方案使用复数来表示2D平面的X和Y分量

J      % Push the literal complex number 0 + 1j to the stack
4:     % Create the array [1, 2, 3, 4]
^      % Raise 0 + 1j to each power in the array, [1, 2, 3, 4]

至此，我们(0, 1), (-1, 0), (0, -1), (1, 0)在由复数表示的数组中有四个点（）。这是四个主要方向。现在我们要使用它们来“行走”。

本质上，这种工作方式是从第0个方向开始（数组的第0个元素为(-1, 0)）。对于每一步，我们都需要确定此标题中的更改。我们将使用整数来跟踪此更改。如果要向右转，则将这个整数加1（参考4点数组中的下一个元素），如果要向左转，则将这个整数减1（引用到4点数组中的前一个元素）。 4点数组）。如果我们要继续前进，我们将整数值保持不变（引用4点数组中的同一元素）。

的这部分代码创建所有那些的阵列0，-1和1的值。

0      % Push a literal 0 to the stack (the starting point)
i      % Explicitly grab the input (N)
:      % Create an array from 1...N
Zp     % Determine if each element is a prime (1) or not (0)
l_     % Push the literal -1 to the stack
G      % Explicitly grab the input again (N)
:      % Create an array from 1...N
B      % Convert to binary representation (each row is the binary representation of
       % each element in the vector)
!      % Transpose
s      % Sum down the columns to count number of 1's
^      % Raise the -1 to each element. For odd number of 1's in the
       % binary expansion this yields -1, and even yields 1

*      % Multiply this -1 or 1 by the result of the prime check (element-wise). 
       % For non-primes this yields a 0, for primes with an even number of 1's in 
       % the binary representation this is a 1, and for primes 
       % with an odd number of 1's in

h      % Horizontally concatenate with the initial 0

现在我们有了一个连续整数之间的差的数组，因此我们可以计算它们的累加总和，以获得索引，然后可以使用这些索引来查找原始4元素数组中每一步的方向。

便利地，MATL具有环绕索引，因此索引5环绕到4元素数组的开头。我们可以利用它的优势，以便我们可以递增和递减该整数，而不必担心参考方向数组只有4个元素的事实。

Ys     % Compute the cumulative sum
)      % Use this to modularly index into the original array of four points

现在，我们有了一个步骤采取方向的数组，因此我们可以计算这些方向的累积总和以找出采取的路径。

Ys     % Compute the cumulative sum
XG     % Plot as a 2D plot

Perl 6的，213 ×182字节

{my @p = [\ +] [\ *]（{{。is-prime ??。base（2）.comb（〜1）％2 ?? i !!-i !! 1 + 0i}（+ + $）} ... *）[^ $ _]; {“ <svg viewBox ='{。min xx 2，.elems xx 2}'>>。＆{” L {.re} {.im}“ }}'fill ='none'stroke ='black'/>“”（minmax | @p».reals）}

{{"<svg viewBox='{{.min,.min,+$_,+$_}(.minmax)}'><path d='{"L"X~$_}' fill='none' stroke='red'/></svg>"}(([\+] [\*]({-{.is-prime*.base(2).comb(~1)R**-1||i}(++$)i}...*)[^$_])».reals)}

在线尝试！

（确实设法减少了这一步！）

该功能以SVG格式输出。

• { -{ .is-prime * .base(2).comb(~1) R** -1 || i }(++$)i } ... *是每一步方向变化的无穷顺序，以复数的形式表示，其中1“沿同一方向继续”，i“向左转”和-i“向右转” 表示。
• [^$_] 将序列限制为作为函数参数提供的步骤数。
• [\*] 使用（复数）乘法扫描该序列，将相对方向更改列表转换为绝对方向列表。
• [\+]使用（复杂）加法来扫描该序列，从而生成已访问坐标的列表。
• ».reals 将该复数列表转换为其实部和虚部的两个元素的列表。

SVG图像只是一个path元素。

N = 20000的输出（转换为PNG）：

C，321字节

a,b,A,B,k,p,e,i,t,r;g(n,c,d,x,y,X,Y){x=y=Y=r=0;X=1;for(k=0;k++<=n;){r|=x==c&y==d;a=x<a?x:a;A=x>A?x:A;b=y<b?y:b;B=y>B?y:B;for(p=1,i=k;--i;p=p*i*i%k);for(e=1,i=k;i;e=-e)i&=i-1;if(p)t=X,X=-e*Y,Y=e*t;x+=X;y+=Y;}}f(n,x,y){A=a=B=b=0;g(n);printf("P1%d %d ",A-a+1,B-b+1);for(y=b;y<=B;++y)for(x=a;x<=A;++x)g(n,x,y),putchar(48+r);}

在线尝试！

我在发布其他C答案之前就开始进行此工作，但我认为无论如何我也应该发布我的作品。这是更长的时间，但它也会自动将输出图像裁剪为结果的尺寸。

函数称为f(n)，输出以netpbm格式输出到stdout。

n = 1000的示例输出：

a,b,A,B,          // used to store x range [a,A] and y range [b,B]
k,p,e,i,t,        // temp variables used in g
r;g(n,c,d,        // takes n + coordinates, sets r to whether (c,d) is visited
x,y,X,Y){         // temp variables - position (x,y) and velocity (X,Y)
x=y=Y=r=0;X=1;    // initialization
for(k=0;k++<=n;){ // loops k over the step number
r|=x==c&y==d;     // set r to 1 if current coordinate is the requested one
a=x<a?x:a;A=x>A?x:A;b=y<b?y:b;B=y>B?y:B;    // update bounds
for(p=1,i=k;--i;p=p*i*i%k);                 // prime test
for(e=1,i=k;i;e=-e)i&=i-1;                  // parity test
if(p)t=X,X=-e*Y,Y=e*t;                      // if prime, turn accordingly
x+=X;y+=Y;}}      // move position in direction of velocity
f(n,x,y){         // main function; x and y are temp variables
A=a=B=b=0;g(n);   // obtain accurate bounds
printf("P1 %d %d\n",A-a+1,B-b+1);           // output netpbm header
for(y=b;y<=B;++y)for(x=a;x<=A;++x)          // loop through all coordinates
g(n,x,y),putchar(48+r);}                    // output 1 if visited, 0 otherwise

质数检验本质上是林恩（Lynn）回答另一个挑战所使用的检验，它依赖于威尔逊定理。

奇偶校验测试使用Kernighan的位计数方法的一种改编。

由于素数测试非常慢，并且该算法针对绘制的每个像素重新运行整个路径生成功能，因此任何输入都比TIO高出1000倍。

LOGO，177171字节

to d:c
if :c%2[rt 180
make"c:c-1]if:c<1[stop]d:c/2
end
to p
if:c>1[make"f 2
repeat:c-2[if:c%:f<1[stop]make"f:f+1]rt 90
d:c]end
to g:n
make"c 1
repeat:n[p
fw 2
make"c:c+1]end

要使用，请执行以下操作：

reset
pu
fw 100
pd
g 3000

抱歉，但是我无法捕获示例输出。说明：

to d:c
if :c%2[rt 180
make"c:c-1]if:c<1[stop]d:c/2
end

这是一个递归过程，其参数中的每个设置位都会旋转180°，从而有效地计算其二进制扩展的奇偶校验。

to p
if:c>1[make"f 2
repeat:c-2[if:c%:f<1[stop]make"f:f+1]rt 90
d:c]end

这是一个非常基本的素数测试。在特殊情况1之后，如果找到一个因数，该过程将尽早返回。但是，如果发现当前值是质数，它将向右转，然后使用上述过程将其适当地更改为左转。

to g:n
make"c 1
repeat:n[p
fw 2
make"c:c+1]end

这只是一个简单的循环，可以测试所有数字n的素数，并在每个数字之后移动两个像素。

果冻，41个字节

B§ḂḤ’×ıµ1Ẓ?€×\ÄŻÆiZ_Ṃ$€Z‘ḞŒṬµẈḢ⁾P1,;Lṭ@FK

在线尝试！

$N$

$N=3000$

$N=300$

0000000000000000000000111110000000000
0000000000000000000000100010000000000
0000001110000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000000000100010000000000
0000001010000000111111111010000000000
0000001010000000100000101010000000000
0000001111111110100000101010000000000
0000000000100010100000101010000000000
0000000000111111100000101010001111111
0000000000000010000000101010001000001
0000000000000011100010101010001000001
0000000000000000100010101010001000001
0000111111100000100011111111111111111
0100100000100000100010001010001000001
0110100000111111100011111111111000111
0010100000000000000010101010000000101
1111100000000000000010101110000000101
1010000000000000000010100000000000101
1010000000000000000011111111111011101
1010000000000000000000100000001010101
1110000000000000000000111111101111101
0000000000000000000000000000100010101
0000000000000000000000000000100010101
0000000000000000000000000000100010101
0000000000000000000000000000111111111
0000000000000000000000000000000010100
0000000000000000000000000000000010100
0000000000000000000000000000000010100
0000000000000000000000000000000011100

JavaScript的- 675 668 660 632 556 534个字节

第一次使用CodeGolf时，最初是以〜1500字节代码开始的。打高尔夫球到不到一半， 几乎超过三分之一。随时继续打高尔夫球。使用此工具计算的字节数

原理：
使用N和可变笔​​画长度作为输入绘制到固定大小的画布中。

编辑：

-07字节-删除丢失的
-08字节-切换到if / else
-28字节-更改为次要if / else
-76字节-较短的素数测试（运行时/ 3）
-22字节-使用此素数功能（运行时* 4）

高尔夫球代码：

function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

带有空格的无代码的代码：

function f(e,r){
    for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){

        // prime and odd/even check
        n=iP(a)?iO(a)?1:2:0;

        var u=i,c=f;

        t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));

        o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),
        i=u,f=c // renew old cords
    }
}

// check prime
function iP(h){
    for(i=n=h;n%--i;);
    return(1==i)
}

// check binary expression even/odd
function iO(e){
    for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)
        "1"==r[n]&&t++;
    return t%2!=0
}

例子：

N = 7-长度= 60

f(7, 60);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

运行代码段隐藏结果

展开摘要

N = 3000-长度= 4

f(3000, 4);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

运行代码段隐藏结果

展开摘要

N = 20000-长度= 2

f(20000, 2);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

运行代码段隐藏结果

展开摘要

N = 159000-长度= 1

f(159000, 1);
function f(e,r){for(var t=0,n=0,i=950,f=450,o=document.getElementById("d").getContext("2d"),a=1;a<=e;a++){n=iP(a)?iO(a)?1:2:0;var u=i,c=f;t==0?(t=0==n?(c=f-r,0):1==n?(u=i-r,1):(u=i+r,3)):t==1?(t=0==n?(u=i-r,1):1==n?(c=f+r,2):(c=f-r,0)):t==2?(t=0==n?(c=f+r,2):1==n?(u=i+r,3):(u=i-r,1)):(t=0==n?(u=i+r,3):1==n?(c=f-r,0):(c=f+r,2));o.beginPath(),o.moveTo(i,f),o.lineTo(u,c),o.stroke(),i=u,f=c}}function iP(h){for(i=n=h;n%--i;);return(1==i)}function iO(e){for(var r=(e>>>0).toString(2),t=0,n=0;n<r.length;n++)"1"==r[n]&&t++;return t%2!=0}

<canvas id="d" width="1900" height="900"/> 

运行代码段隐藏结果

展开摘要

红，515个 480 471字节

-1个字节感谢Kevin Cruijssen！

func[n][a: 270 x: t: u: v: w: 0 y: 1
b: copy[line 0x0 0x1]repeat i n - 1[p: on
j: i + 1 repeat k i / 2[if j%(k + 1)= 0[p: off]]if p[s: 0
until[if j% 2 = 1[s: s + 1](j: j / 2)< 1]a: a + pick[-90 90]s% 2 + 1]append b 'line 
append b as-pair x y x: x + cosine a y: y - sine a append b as-pair x y t: min x t
u: max x u v: min y v w: max y w]c: 500 /(max u - t w - v)view[base white 502x500
draw collect[foreach k b[keep either pair? k[as-pair k/1 - t * c k/2 - v * c][k]]]]]

代码的很大一部分（〜160字节）用于规范化坐标，以使图形完全适合画布，而不管输入的大小如何。

最初的方向：南。

这是结果 n = 3000

n = 20000

处理中，140+字节

void f(int N){for(int x,y,i,l,d,k=d=y=x=0;k++<N;d+=i<l?0:Integer.bitCount(k)%2*2-1,d&=3,point(x-=~-d%2,y+=(d-2)%2))for(i=1,l=k;0<l%++i%l;);}

可能无法实现清晰可见