Mục đích của thử thách này là mô tả bằng đồ họa một bước đi trên mặt phẳng, trong đó hướng của mỗi bước được xác định bởi tính nguyên thủy của và tính chẵn lẻ của khai triển nhị phân của nó. Đặc biệt,$k$$k$

• Hướng ban đầu là cố định, nói Bắc.
• Tất cả các bước có cùng độ dài .
• Các hướng của bước có thể Bắc, Tây, Nam hoặc Đông, và được xác định như sau: $k$
  • Nếu không phải là số nguyên tố thì hướng không thay đổi.$k$
  • Nếu là số nguyên tố và khai triển nhị phân của có số chẵn, hãy rẽ phải.$k$$k$
  • Nếu là số nguyên tố và khai triển nhị phân của có số lẻ, hãy rẽ trái.$k$$k$

Như một ví dụ hoạt động , giả sử rằng hướng ban đầu là hướng Bắc. Các bước đầu tiên là:

• $k=1$ không phải là số nguyên tố. Vì vậy, chúng tôi di chuyển một bước theo hướng hiện tại, đó là Bắc.
• $k=2$ là số nguyên tố, và khai triển nhị phân của nó 10, có và số lẻ. Vì vậy, chúng tôi rẽ trái, và bây giờ phải đối mặt với Tây. Chúng tôi di chuyển một bước theo hướng đó.
• $k=3$ là số nguyên tố, và khai triển nhị phân của nó 11, có và số chẵn. Vì vậy, chúng tôi rẽ phải, và hiện đang đối mặt với Bắc. Chúng tôi di chuyển một bước theo hướng đó.
• $k=4$ không phải là số nguyên tố. Vì vậy, chúng tôi di chuyển một bước theo hướng hiện tại, đó là Bắc.

Các thách thức

Input : tích cực số nguyên .$N$

Đầu ra : âm mưu của bước -step như được xác định ở trên.$N$

Quy tắc bổ sung

• Các hướng ban đầu có thể được tự do lựa chọn (không nhất thiết miền Bắc), nhưng phải giống nhau cho tất cả các .$N$
• Các quy tắc biến có thể là ngược lại với mô tả ở trên, có nghĩa là, rẽ phải cho chẵn lẻ lẻ và rời thậm chí; nhưng nó phải là như nhau cho tất cả .$N$
• Đầu ra phải là một mô tả đồ họa của cuộc đi bộ. Ví dụ:
  • Việc đi bộ có thể được vẽ với các đoạn đường.
  • Các điểm truy cập có thể được hiển thị với một điểm đánh dấu, chẳng hạn như một dấu chấm; có hoặc không có kết nối các phân đoạn dòng.
  • Một hình ảnh raster hai màu có thể được cung cấp, với một màu tương ứng với các điểm đã truy cập và một màu khác cho những người không truy cập.
• Các tỷ lệ của trục ngang và trục dọc không cần phải giống nhau. Ngoài ra nhãn trục và các yếu tố tương tự là tùy chọn. Miễn là đi bộ có thể được nhìn thấy rõ ràng, cốt truyện là hợp lệ.
• Lưu ý rằng một số điểm được truy cập nhiều lần. Cốt truyện không nhạy cảm với điều này. Chẳng hạn, nếu các phân đoạn dòng được hiển thị trong cốt truyện, mỗi phân đoạn đơn vị được hiển thị như nhau cho dù nó đã được duyệt qua bao nhiêu lần.
• Mã phải hoạt động cho bất kỳ Ntài nguyên không giới hạn nhất định. Có thể chấp nhận được nếu trong thực tế, nó bị lỗi lớn Ndo giới hạn thời gian, bộ nhớ hoặc kiểu dữ liệu.
• Đầu vào và đầu ra linh hoạt như bình thường. Đặc biệt, bất kỳ phương tiện tiêu chuẩn nào để xuất hình ảnh đều có thể được sử dụng.
• Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm

Các ô sau đây sử dụng hướng Bắc làm hướng ban đầu; thậm chí chẵn lẻ rẽ phải; và đi bộ được mô tả với các phân đoạn dòng.

N = 7:

N = 3000:

N = 20000:

N = 159000:

N = 1200000:

N = 11000000:

Sledgehammer 0,4 , 22 20 byte

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

Giải nén vào chức năng Ngôn ngữ Wolfram này:

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

Bị đánh cắp

Đầu tiên chúng ta xác định một hàm trả về góc để quay ở mỗi bước:

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

ThueMorselà tính chẵn lẻ của tổng các chữ số nhị phân. Chúng tôi sử dụng -1^(...)thay 2*...-1vì một lý do hơi phức tạp: Ngôn ngữ Wolfram tự động chuyển đổi các biểu thức số học trong nguồn thành dạng chính tắc, vì vậy các biểu thức như 2/xđược lưu trữ dưới dạng Times[2, Power[x, -1]]. Điều này làm cho tần số Powerrất cao, và do đó nén nó rất rẻ.

(Nhân với Boole@PrimeQ@thời gian dài hơn một chút và việc Booletạo Booleans ngầm đã không được thực hiện tại thời điểm thử thách.)

Từ đây, Mathicala's AnglePathvà ListPlotlàm chính xác những gì chúng ta cần:

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

Trong ứng dụng tương tác, đầu ra là một đối tượng Đồ họa vector có thể điều chỉnh lại.

MATL , 25 24 21 byte

Q:qJyZpbB!sEq*^YpYsXG

Dùng thử tại MATL trực tuyến

Cảm ơn @LuisMendo cho một phiên chơi golf tuyệt vời trong trò chuyện mà cuối cùng đã dẫn đến phiên bản 21 byte này, bằng cách đề xuất Eq*^

Giải trình

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

Ví dụ cho : $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;}

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

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

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

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

Cắt đầu ra cho 20000:

Cả hai phiên bản đều bắt đầu bằng hướng tây và rẽ phải, lẻ, chẵn.

Tôi đã thử các bản thử nghiệm lớn hơn với cả hai loại này, vì đầu ra với 20000 là ~ 1,5 GB và 150000 sẽ là ~ 90 GB. Đây là tất cả được lưu trữ trong bộ nhớ trong khi chương trình thực thi.

Giải thích về cái trên:

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

Ngôn ngữ Wolfram (Mathicala) , 98 96 91 77 76 63 byte

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

-14 byte: Cảm ơn @lirtosiast đã chỉ cho tôi cách sử dụngAnglePath ...

-13 byte: ... và ThueMorse!

ví dụ sử dụng:

%[20000]

Giải thích từng bước:

• If[PrimeQ@#, 2 ThueMorse@# - 1, 0] &là một hàm lấy chỉ số bước và trả về 0 cho các số nguyên tố không phải là số nguyên tố, -1 cho các số nguyên tố nhị phân chẵn và +1 cho các số nguyên tố nhị phân lẻ. ThueMorse@#thay thế các giải pháp trước đó Total[#~IntegerDigits~2](giống như vậy, modulo 2).

• Array[Pi/2*%,#]lập danh sách hàm này với chỉ số đi từ 1 đến đối số hàm (ví dụ 20000) và nhân mọi phần tử với π / 2 để biến nó thành góc thay đổi hướng (radian). Bây giờ chúng ta có 0 cho các số nguyên tố không phải số nguyên tố, -π / 2 cho các số nguyên tố nhị phân chẵn và + π / 2 cho các số nguyên tố nhị phân lẻ.

• AnglePath[%]chuyển đổi danh sách các góc thay đổi hướng này thành một đường dẫn. Hướng dẫn này thay thế cho việc sử dụng hai lần của giải pháp trước đó Accumulate.

• ListPlot[%]chuyển đổi danh sách các vị trí thành một ô chấm XY. Nếu một dòng được ưa thích, sử dụng ListLinePlotthay thế. Các hàm vẽ này có rất nhiều tùy chọn để làm cho các ô trông đẹp hơn.

MATL, 31 30 28 26 byte

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

3 byte được lưu nhờ vào @LuisMendo

2 byte được lưu nhờ vào @Sanchises

Dùng thử tại MATL Online

Giải trình

Giải pháp này sử dụng số phức để biểu diễn các thành phần X và Y của mặt phẳng 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]

Tại thời điểm này, chúng ta có bốn điểm ( (0, 1), (-1, 0), (0, -1), (1, 0)) trong một mảng được biểu thị bằng số phức. Đây là bốn hướng hồng y. Bây giờ chúng tôi muốn sử dụng chúng để "đi bộ".

Về cơ bản, cách thức này hoạt động là chúng ta bắt đầu đi theo hướng số 0 (phần tử thứ 0 của mảng (-1, 0)). Đối với mỗi bước, chúng ta cần xác định sự thay đổi trong nhóm này. Chúng tôi sẽ sử dụng số nguyên để theo dõi sự thay đổi này. Nếu chúng ta muốn biến "phải", chúng ta tăng số nguyên này lên 1 (tham chiếu phần tử tiếp theo trong mảng 4 điểm) và nếu chúng ta muốn đi "bên trái", chúng ta sẽ giảm số nguyên này thêm 1 (tham chiếu phần tử trước đó trong Mảng 4 điểm). Nếu chúng ta muốn tiếp tục trên đường dẫn của mình, chúng ta sẽ giữ giá trị nguyên không đổi (tham chiếu cùng một phần tử trong mảng 4 điểm).

Đây là một phần của mã tạo ra một mảng của tất cả những người 0, -1và 1giá trị.

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

Bây giờ chúng ta có một mảng các khác biệt giữa các số nguyên liên tiếp để chúng ta có thể tính tổng tích lũy của các số đó để lấy các chỉ số mà sau đó chúng ta có thể sử dụng để tra cứu hướng ở mỗi bước trong mảng 4 phần tử ban đầu.

Thuận tiện, MATL có lập chỉ mục bao quanh sao cho chỉ mục 5bao quanh phần đầu của mảng 4 phần tử. Chúng ta có thể sử dụng điều này cho lợi thế của mình để có thể tăng và giảm số nguyên này mà không phải lo lắng về thực tế là mảng hướng tham chiếu chỉ có 4 phần tử.

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

Bây giờ chúng ta có một loạt các hướng của các bước cần thực hiện, vì vậy chúng ta có thể tính tổng tích lũy của các hướng này để tìm ra đường dẫn đã được thực hiện.

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

Perl 6 , 213 182 byte

{my @p = [\ +] [\ *] ({{. is-Prime ??. cơ sở (2) .comb (~ 1)% 2 ?? i !! - i !! 1 + 0i} (+ + $)} ... *) [^ $ _]; {"<svg viewBox = '{. min xx 2, .elems xx 2}' >>. & {" L {.re} {.im} " }} 'fill =' none 'Stro =' 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)}

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

(Thực sự quản lý để giảm cái này xuống!)

Hàm này xuất ra ở định dạng SVG.

• { -{ .is-prime * .base(2).comb(~1) R** -1 || i }(++$)i } ... *là một chuỗi vô tận các thay đổi hướng cho mỗi bước, dưới dạng số phức, trong đó 1có nghĩa là "tiếp tục theo cùng một hướng", icó nghĩa là "rẽ trái" và -icó nghĩa là "rẽ phải".
• [^$_] giới hạn chuỗi đó đến số bước được cung cấp làm đối số của hàm.
• [\*] quét chuỗi đó với phép nhân (phức tạp), biến danh sách các hướng thay đổi tương đối thành một danh sách các hướng tuyệt đối.
• [\+]quét chuỗi đó với phép cộng (phức tạp), tạo ra một danh sách các tọa độ được truy cập.
• ».reals chuyển đổi danh sách các số phức thành danh sách hai phần tử của phần thực và phần ảo của nó.

Hình ảnh SVG chỉ là một pathyếu tố duy nhất .

Đầu ra (được chuyển đổi thành PNG) cho 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);}

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

Tôi đã bắt đầu làm việc này trước khi câu trả lời C khác được đăng, nhưng tôi đoán rằng dù sao tôi cũng có thể đăng bài của mình. Cái này dài hơn rất nhiều, nhưng nó cũng tự động cắt hình ảnh đầu ra theo kích thước của kết quả.

Hàm được gọi là f(n), và đầu ra là xuất chuẩn ở định dạng netpbm.

Ví dụ đầu ra cho 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

Bài kiểm tra cơ bản về cơ bản là bài kiểm tra được sử dụng trong câu trả lời của Lynn cho một thử thách khác , dựa trên định lý của Wilson .

Bài kiểm tra chẵn lẻ sử dụng phương pháp đếm bit của Kernighan .

Do kiểm tra chính rất chậm và thuật toán chạy lại toàn bộ chức năng tạo đường dẫn cho mỗi pixel được vẽ, bất kỳ đầu vào nào cao hơn 1000 lần so với 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

Để sử dụng, hãy làm một cái gì đó như thế này :

reset
pu
fw 100
pd
g 3000

Xin lỗi, nhưng tôi không thể chụp đầu ra mẫu. Giải trình:

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

Đây là một thủ tục đệ quy xoay 180 ° cho mỗi bit set trong tham số của nó, tính toán hiệu quả tính chẵn lẻ của khai triển nhị phân của nó.

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

Đây là một bài kiểm tra nguyên thủy rất cơ bản. Sau khi đặc biệt 1, thủ tục trả về sớm nếu tìm thấy một yếu tố. Tuy nhiên, nếu giá trị hiện tại được tìm thấy là số nguyên tố, nó sẽ rẽ phải, và sau đó sử dụng quy trình trên để thay đổi giá trị đó thành rẽ trái khi thích hợp.

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

Đây chỉ là một vòng lặp đơn giản để kiểm tra tất cả các số có ntính nguyên thủy và để di chuyển hai pixel sau mỗi pixel.

Thạch , 41 byte

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

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

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

Lần đầu tiên ở đây trên CodeGolf, ban đầu bắt đầu với ~ 1500 Byte Code. Chơi gôn đến chưa đến một nửa gần một phần ba. Hãy tiếp tục chơi golf. Số byte được tính với: công cụ này

Nguyên tắc:
Vẽ vào khung có kích thước cố định với N và chiều dài hành trình thay đổi làm đầu vào.

Chỉnh sửa:

-07 Byte - loại bỏ bỏ lỡ nếu
-08 Byte - thay đổi công tắc thành if /
other -28 Byte - thay đổi thành tenary if / other
-76 Byte - kiểm tra số nguyên tố ngắn hơn (runtime / 3)
-22 Byte - sử dụng chức năng chính này (thời gian chạy * 4)

Mã đánh gôn:

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}

Mã Ungolfed với khoảng trắng:

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
}

Ví dụ:

N = 7 - Chiều dài = 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"/> 

Chạy đoạn mãẨn kết quả

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

N = 3000 - Chiều dài = 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"/> 

Chạy đoạn mãẨn kết quả

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

N = 20000 - Chiều dài = 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"/> 

Chạy đoạn mãẨn kết quả

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

N = 159000 - Chiều dài = 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"/> 

Chạy đoạn mãẨn kết quả

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

Đỏ , 515 480 471 byte

-1 byte nhờ 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]]]]]

Một phần quan trọng của mã (~ 160 byte) liên quan đến việc chuẩn hóa tọa độ sao cho đồ họa hoàn toàn nằm trong khung vẽ bất kể kích thước của đầu vào.

Hướng ban đầu: Nam.

Đây là kết quả cho n = 3000

n = 20000

Đang xử lý, hơn 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;);}

Có thể không hoàn thành rõ ràng nhìn thấy