Tujuan dari tantangan ini adalah untuk menggambarkan secara grafis sebuah jalan di pesawat, di mana arah setiap langkah $k$ ditentukan oleh keutamaan $k$ dan paritas dari ekspansi binernya. Secara khusus,

• Arah awal sudah ditetapkan, katakan Utara.
• Semua langkah memiliki panjang yang sama .
• The arah langkah $k$ dapat Utara, Barat, Selatan atau Timur, dan ditentukan sebagai berikut:
  • Jika $k$ tidak prima, arahnya tidak berubah.
  • Jika $k$ adalah prima dan ekspansi biner dari $k$ memiliki angka genap, belok kanan.
  • Jika $k$ adalah prima dan ekspansi biner dari $k$ memiliki jumlah ganjil, belok kiri.

Sebagai contoh yang berhasil , asumsikan bahwa arah awal adalah Utara. Langkah pertama adalah:

• $k=1$ bukan bilangan prima. Jadi kami bergerak satu langkah ke arah saat ini, yaitu Utara.
• $k=2$ adalah prima, dan ekspansi binernya10,, memiliki dan ganjilnya. Jadi kita belok kiri, dan sekarang menghadap ke Barat. Kami bergerak satu langkah ke arah itu.
• $k=3$ adalah prima, dan ekspansi binernya11,, memiliki dan bahkan sejumlah. Jadi kita belok kanan, dan sekarang menghadap ke Utara. Kami bergerak satu langkah ke arah itu.
• $k=4$ tidak prima. Jadi kami bergerak satu langkah ke arah saat ini, yaitu Utara.

Tantangan

Masukan : positif bilangan bulat $N$ .

Output : plot jalan $N$ -step seperti yang didefinisikan di atas.

Aturan tambahan

• The arah awal dapat dipilih secara bebas (tidak harus Utara), tapi harus sama untuk semua $N$ .
• The Aturan memutar dapat menjadi berlawanan dengan yang dijelaskan di atas, yaitu, belok kanan untuk paritas ganjil dan kiri bahkan; tapi itu harus sama untuk semua $N$ .
• Outputnya harus berupa penggambaran grafis jalan-jalan. Contohnya:
  • Jalan dapat digambar dengan segmen garis.
  • Poin yang dikunjungi dapat ditampilkan dengan spidol, seperti titik; dengan atau tanpa menghubungkan segmen garis.
  • Gambar raster dua warna dapat disediakan, dengan satu warna yang sesuai dengan titik yang dikunjungi dan yang lain untuk yang tidak dikunjungi.
• Timbangan sumbu horizontal dan vertikal tidak harus sama. Juga label sumbu dan elemen serupa adalah opsional. Selama perjalanan dapat dilihat dengan jelas, alur ceritanya sahih.
• Perhatikan bahwa beberapa titik dikunjungi lebih dari satu kali. Plotnya tidak sensitif terhadap ini. Misalnya, jika segmen garis ditampilkan dalam plot, setiap segmen unit ditampilkan sama tidak peduli berapa kali telah dilalui.
• Kode harus bekerja untuk Nsumber daya tak terbatas yang diberikan. Dapat diterima jika dalam praktiknya gagal besar Nkarena keterbatasan waktu, memori atau tipe data.
• Input dan output fleksibel seperti biasa. Secara khusus, salah satu cara standar untuk menghasilkan gambar dapat digunakan.
• Kode terpendek dalam byte menang.

Uji kasus

Plot berikut menggunakan Utara sebagai arah awal; bahkan paritas berbelok ke kanan; dan jalan digambarkan dengan segmen garis.

N = 7:

N = 3000:

N = 20000:

N = 159000:

N = 1200000:

N = 11000000:

Sledgehammer 0.4 , 22 20 byte

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

Dekompresi ke dalam fungsi Bahasa Wolfram ini:

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

Tidak disatukan

Pertama kita mendefinisikan fungsi yang mengembalikan sudut untuk berbelok di setiap langkah:

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

ThueMorseadalah paritas dari jumlah digit biner. Kami menggunakan -1^(...)alih-alih 2*...-1untuk alasan yang sedikit rumit: Bahasa Wolfram secara otomatis mengubah ekspresi aritmatika menjadi bentuk kanonik, sehingga ekspresi seperti 2/xdisimpan sebagai Times[2, Power[x, -1]]. Ini membuat frekuensinya Powersangat tinggi, dan dengan demikian mengompresnya menjadi sangat murah.

(Mengalikan dengan Boole@PrimeQ@sedikit lebih lama, dan Boolecasting Boolean secara implisit belum dilaksanakan pada saat tantangan.)

Dari sini, Mathematica AnglePathdan ListPlotlakukan apa yang kita butuhkan:

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

Dalam aplikasi interaktif, output adalah objek Graphics vektor yang dapat didaur ulang.

MATL , 25 24 21 byte

Q:qJyZpbB!sEq*^YpYsXG

Cobalah di MATL online

Terima kasih @LuisMendo untuk sesi golf yang bagus di chat yang akhirnya mengarah ke versi 21 byte ini, dengan menyarankan Eq*^

Penjelasan

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 byte

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;}

Cobalah online!

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

C (gcc) , 219 byte

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;}}

Cobalah online!

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

Output yang dipotong untuk 20000:

Kedua versi dimulai dengan barat dan belok kanan ke ganjil, ke kiri genap.

Saya mencoba testcases yang lebih besar dengan keduanya, karena output dengan 20000 ~ 1,5 GB, dan 150000 ~ 90GB. Ini semua disimpan dalam memori saat program dijalankan.

Penjelasan dari yang atas:

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 */
}

Bahasa Wolfram (Mathematica) , 98 96 91 77 76 63 byte

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

-14 byte: Terima kasih kepada @lirtosiast karena menunjukkan kepada saya cara menggunakanAnglePath ...

-13 byte: ... dan ThueMorse!

contoh penggunaan:

%[20000]

Penjelasan langkah demi langkah:

• If[PrimeQ@#, 2 ThueMorse@# - 1, 0] &adalah fungsi yang mengambil langkah indeks dan mengembalikan 0 untuk bilangan prima, -1 untuk bilangan prima bilangan biner, dan +1 untuk bilangan prima bilangan biner. ThueMorse@#menggantikan solusi sebelumnya Total[#~IntegerDigits~2](yang sama, modulo 2).

• Array[Pi/2*%,#]membuat daftar fungsi ini dengan indeks dari 1 ke argumen fungsi (20000 dalam contoh), dan mengalikan setiap elemen dengan π / 2 untuk membuatnya menjadi sudut perubahan arah (radian). Kami sekarang memiliki 0 untuk bilangan prima non-prima, -π / 2 untuk bilangan prima biner, dan + π / 2 untuk bilangan prima biner ganjil.

• AnglePath[%]mengubah daftar ini dari arah perubahan sudut menjadi jalan. Instruksi ini menggantikan penggunaan dua kali solusi sebelumnya Accumulate.

• ListPlot[%]mengubah daftar posisi menjadi plot titik XY. Jika garis lebih disukai, gunakan ListLinePlotsaja. Fungsi-fungsi plot ini memiliki banyak opsi untuk membuat plot terlihat lebih baik.

MATL, 31 30 28 26 byte

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

3 Bytes disimpan berkat @LuisMendo

2 Bytes disimpan berkat @Sanchises

Cobalah di MATL Online

Penjelasan

Solusi ini menggunakan bilangan kompleks untuk mewakili komponen X dan Y dari bidang 2D

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]

Pada titik ini, kami memiliki empat titik ( (0, 1), (-1, 0), (0, -1), (1, 0)) dalam array yang diwakili oleh bilangan kompleks. Ini adalah empat arah mata angin. Sekarang kita ingin menggunakan ini untuk "berjalan".

Pada dasarnya cara kerjanya adalah kita mulai menuju ke arah zero'th (elemen ke-0 dari array yang ada (-1, 0)). Untuk setiap langkah, kita perlu menentukan perubahan dalam tajuk ini. Kami akan menggunakan bilangan bulat untuk melacak perubahan ini. Jika kita ingin berbelok ke "kanan", kita menambah bilangan bulat ini dengan 1 (merujuk elemen berikutnya dalam array 4-point) dan jika kita ingin pergi "kiri", kita mengurangi bilangan bulat ini dengan 1 (merujuk elemen sebelumnya di 4-point array). Jika kita ingin melanjutkan jalur kita, kita menjaga nilai integer konstan (merujuk elemen yang sama dalam array 4-point).

Ini bagian dari kode menciptakan sebuah array dari semua orang 0, -1dan 1nilai-nilai.

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

Sekarang kita memiliki array perbedaan antara integer berturut-turut sehingga kita dapat menghitung jumlah kumulatif dari mereka untuk mendapatkan indeks yang kemudian dapat kita gunakan untuk mencari arah pada setiap langkah dalam array 4-elemen asli.

Dengan mudah, MATL memiliki pengindeksan melingkar sedemikian sehingga indeks 5membungkus ke awal array 4-elemen. Kita dapat menggunakan ini untuk keuntungan kita sehingga kita dapat menambah dan mengurangi bilangan bulat ini tanpa khawatir tentang fakta bahwa array arah referensi hanya 4 elemen.

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

Sekarang kita memiliki berbagai arahan langkah yang diambil, sehingga kita dapat menghitung jumlah kumulatif arahan ini untuk melacak jalur yang telah diambil.

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

Perl 6 , 213 182 byte

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

Cobalah online!

(Benar-benar berhasil mengurangi yang satu ini!)

Fungsi ini menghasilkan dalam format SVG.

• { -{ .is-prime * .base(2).comb(~1) R** -1 || i }(++$)i } ... *adalah urutan perubahan arah tanpa batas untuk setiap langkah, dalam bentuk bilangan kompleks, di mana 1berarti "terus ke arah yang sama," iberarti "belok kiri," dan -iberarti "belok kanan."
• [^$_] membatasi urutan itu ke jumlah langkah yang disediakan sebagai argumen fungsi.
• [\*] memindai urutan itu dengan perkalian (kompleks), mengubah daftar perubahan arah relatif menjadi daftar arah absolut.
• [\+]scan yang urutan dengan (kompleks) Selain itu, menghasilkan daftar koordinat dikunjungi.
• ».reals mengubah daftar bilangan kompleks menjadi daftar dua elemen dari bagian nyata dan imajinernya.

Gambar SVG hanyalah satu pathelemen tunggal .

Output (dikonversi ke PNG) untuk N = 20000:

C, 321 byte

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

Cobalah online!

Saya mulai mengerjakan ini sebelum jawaban C yang lain diposting, tetapi saya pikir saya mungkin juga memposting jawaban saya juga. Yang ini jauh lebih lama, tetapi juga memotong gambar output ke dimensi hasil secara otomatis.

Fungsi disebut sebagai f(n), dan output adalah stdout dalam format netpbm.

Contoh output untuk 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

Tes utama pada dasarnya adalah yang digunakan dalam jawaban Lynn untuk tantangan yang berbeda , yang bergantung pada teorema Wilson .

Tes paritas menggunakan adaptasi dari metode penghitungan bit Kernighan .

Karena tes prima sangat lambat, dan algoritma menjalankan kembali fungsi pembuatan jalur keseluruhan untuk setiap piksel yang diambil, setiap input jauh lebih tinggi dari 1000 kali pada TIO.

LOGO, 177 171 byte

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

Untuk menggunakan, lakukan sesuatu seperti ini :

reset
pu
fw 100
pd
g 3000

Maaf, tetapi saya tidak dapat menangkap output sampel. Penjelasan:

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

Ini adalah prosedur rekursif yang berputar 180 ° untuk setiap bit dalam parameternya, yang secara efektif menghitung paritas ekspansi binernya.

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

Ini adalah tes primality yang sangat mendasar. Setelah casing-1 khusus, prosedur akan kembali lebih awal jika suatu faktor ditemukan. Namun jika nilai saat ini ditemukan prima, belok kanan, dan kemudian menggunakan prosedur di atas untuk mengubahnya menjadi belok kiri yang sesuai.

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

Ini hanya sebuah loop sederhana untuk menguji semua angka hingga nuntuk primality dan untuk memindahkan dua piksel setelah masing-masing.

Jelly , 41 byte

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

Cobalah online!

$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 Bytes

Pertama kali di sini di CodeGolf, awalnya dimulai dengan ~ 1500 Bytes Code. Golf itu kurang dari setengah hampir lebih dari sepertiga darinya. Jangan ragu untuk terus bermain golf. Bytes Dihitung dengan: alat ini

Prinsip:
Menarik ke kanvas ukuran tetap dengan N dan panjang stroke variabel sebagai input.

Suntingan:

-07 Bytes - hapus yang terlewat jika
-08 Bytes - ubah alihkan ke jika / else
-28 Bytes - ubah ke tenary jika / else
-76 Bytes - tes utama lebih pendek (runtime / 3)
-22 Bytes - gunakan fungsi utama ini (runtime * 4)

Kode Golf:

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}

Kode tidak digabungkan dengan spasi putih:

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
}

Contoh:

N = 7 - Panjang = 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"/> 

Jalankan cuplikan kodeSembunyikan hasil

Luaskan cuplikan

N = 3000 - Panjang = 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"/> 

Jalankan cuplikan kodeSembunyikan hasil

Luaskan cuplikan

N = 20000 - Panjang = 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"/> 

Jalankan cuplikan kodeSembunyikan hasil

Luaskan cuplikan

N = 159000 - Panjang = 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"/> 

Jalankan cuplikan kodeSembunyikan hasil

Luaskan cuplikan

Merah , 515 480 471 byte

-1 byte terima kasih kepada 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]]]]]

Bagian penting dari kode (~ 160 byte) berkaitan dengan normalisasi koordinat sehingga gambar sepenuhnya pas di kanvas terlepas dari ukuran input.

Arah awal: Selatan.

Inilah hasilnya untuk n = 3000

n = 20000

Memproses, 140+ byte

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

Mungkin tidak memenuhi terlihat jelas