この課題の目的は、各ステップの方向平面上の歩行グラフィカルに描写することであるの素数によって決定されたとそのバイナリ膨張のパリティ。具体的には、$k$$k$

• 最初の方向は固定されています、たとえば北です。
• すべてのステップの長さは同じです。
• ステップの方向は、北、西、南、または東で、次のように決定されます。 $k$
  • が素数でない場合、方向は変わりません。$k$
  • 場合素数であるとのバイナリ拡張ものの数が偶数の、右折。$k$$k$
  • 場合素数であるとのバイナリ拡張ものの数が奇数を持って、左折。$k$$k$

実際の例として、最初の方向が北であると仮定します。最初の手順は次のとおりです。

• $k=1$は素数ではありません。そこで、現在の方向、つまり北に1ステップ移動します。
• $k=2$は素数であり、そのバイナリ展開10、は1の奇数を持っています。だから私たちは左に曲がり、今西に面しています。その方向に一歩進みます。
• $k=3$は素数であり、そのバイナリ展開、、11および偶数の1です。私たちは右に曲がり、今では北に面しています。その方向に一歩進みます。
• $k=4$は素数ではありません。そこで、現在の方向、つまり北に1ステップ移動します。

挑戦

入力：正の整数。$N$

出力：上記で定義されたウォークのプロット。$N$

追加のルール

• 初期方向は自由に（必ずしも北）選択することができるが、すべてに対して同じであるべきである。$N$
• 旋回ルールは、である、上述したものとは反対である奇数パリティに右折、さらに放置することができます。ただし、すべての同じである必要があります。$N$
• 出力は、歩行のグラフィカルな描写である必要があります。例えば：
  • 歩行は線分で描くことができます。
  • 訪問したポイントは、ドットなどのマーカーで表示できます。接続線セグメントの有無にかかわらず。
  • 2色のラスターイメージを提供できます。1つの色は訪問したポイントに対応し、別の色は訪問していないポイントに対応します。
• 水平軸と垂直軸のスケールは同じである必要はありません。また、軸ラベルと同様の要素はオプションです。歩行がはっきりと見える限り、プロットは有効です。
• 一部のポイントは複数回アクセスされることに注意してください。プロットはこれに敏感ではありません。たとえば、ラインセグメントがプロットに表示される場合、各ユニットセグメントは、何度走査されても同じように表示されます。
• コードは、任意の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
]&

ThueMorse2進数の合計のパリティです。私たちは、使用-1^(...)するのではなく2*...-1、わずかに複雑な理由のために：表現が好きなので、ウォルフラム言語を自動的に、正規の形式にソースの算術式を変換し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$バイト。PBM形式の正方形の画像がバッファに書き込まれます。

20000の出力のトリミング：

どちらのバージョンも西から始まり、奇数で右に曲がり、偶数で左に曲がります。

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]

この時点で、4つのポイント（(0, 1), (-1, 0), (0, -1), (1, 0)複素数で表される配列内に）があります。これらは4つの基本的な方向です。次に、これらを「歩く」ために使用します。

基本的にこれが機能する方法は、0番目の方向（配列の0番目の要素）に向かって開始すること(-1, 0)です。各ステップで、この見出しの変更を決定する必要があります。この変更を追跡するために整数を使用します。「右」にしたい場合は、この整数を1増やします（4ポイント配列の次の要素を参照します）。「左」にしたい場合は、この整数を1減らします（前の要素を参照します） 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 = [\ +] [\ *]（{{..- 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 その複素数のリストをその実部と虚部の2要素リストに変換します。

SVG画像は1つの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形式で標準出力になります。

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

プライムテストは、本質的には、ウィルソンの定理に依存する別の課題に対するリンの回答で使用されるテストです。

パリティテストでは、Kernighanのビットカウント方式を採用しています。

プライムテストは非常に遅く、アルゴリズムは描画されたピクセルごとにパス生成関数全体を再実行するため、TIOで1000回をはるかに超える入力があった場合。

ロゴ、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、素数まですべての数値をテストし、各数値の後に2ピクセル移動するための単純なループです。

ゼリー、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バイトのコードで始まりました。それをGolfed 半分以下の ほとんどよりそれの第三より。ゴルフを続けてください。カウントされたバイト：このツール

原則：
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;);}

はっきりと見たときに満たされない場合がある