이 과제의 목적은 평면에서의 보행을 그래픽으로 묘사하는 것입니다. 각 단계 $k$ 의 방향 은 $k$ 우선 성과 ​​이진 확장의 패리티에 의해 결정됩니다 . 구체적으로

• 초기 방향은 고정되어 있습니다 (예 : 북쪽).
• 모든 단계의 길이 는 같습니다 .
• 단계 k 의 방향 은 북쪽, 서쪽, 남쪽 또는 동쪽 일 수 있으며 다음과 같이 결정됩니다. $k$
  • $k$ 가 소수가 아닌 경우 방향이 변경되지 않습니다.
  • 경우 $k$ 소수와의 바이너리 확장 $k$ 사람의 짝수 번호가 우회전.
  • 경우 $k$ 소수와의 바이너리 확장 $k$ 사람의 홀수 번호가, 좌회전합니다.

A와 가공 한 예를 들어 , 초기 방향이 북한이라고 가정합니다. 첫 단계는 다음과 같습니다.

• $k=1$ 은 소수가 아닙니다. 따라서 현재 방향 인 북쪽으로 한 단계 이동합니다.
• $k=2$ 는 소수이고 이진 확장10은이며 홀수입니다. 그래서 우리는 좌회전하여 이제 서쪽을 향하고 있습니다. 우리는 그 방향으로 한 걸음 움직입니다.
• $k=3$ 은 소수이고 이진 확장11은이며 짝수입니다. 우린 우회전하고 이제 북쪽을 향하고 있습니다 우리는 그 방향으로 한 걸음 움직입니다.
• $k=4$ 는 소수가 아닙니다. 따라서 현재 방향 인 북쪽으로 한 단계 이동합니다.

도전

입력 : 양의 정수 $N$ .

출력 : 위에서 정의 된 $N$ 스텝 보행 플롯 .

추가 규칙

• 초기 방향을 자유롭게 (반드시 노스) 선택 될 수 있지만, 모두 동일해야 $N$ .
• 선회 규칙 오른쪽 홀수 패리티 설정과 심지어 방치이라고 상술과 반대 일 수있다; 그러나 모든 $N$ 대해 동일해야합니다 .
• 출력은 보행을 그래픽으로 보여야 합니다. 예를 들어 :
  • 선분으로 보행을 그릴 수 있습니다.
  • 방문 지점은 점과 같은 마커로 표시 될 수 있습니다. 선 세그먼트 연결 유무에 관계없이.
  • 방문한 지점에 해당하는 색상과 방문하지 않은 다른 색상으로 2 색 래스터 이미지를 제공 할 수 있습니다.
• 가로 축과 세로 축의 축척이 같을 필요는 없습니다. 또한 축 레이블 및 유사한 요소는 선택 사항입니다. 보행을 명확하게 볼 수있는 한 음모가 유효합니다.
• 일부 포인트는 두 번 이상 방문합니다. 줄거리는 이것에 민감하지 않습니다. 예를 들어, 선분이 플롯에 표시되면 각 단위 선분은 횡단 횟수에 관계없이 동일하게 표시됩니다.
• 코드는 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 Language는 소스의 산술 표현식을 표준 형식으로 자동 변환하므로 다음과 같은 표현식은 2/x로 저장됩니다 Times[2, Power[x, -1]]. 이것은 주파수를 Power매우 높게하여 매우 저렴하게 압축합니다.

(곱하기 Boole@PrimeQ@는 약간 길며, Boole챌린지시 부울의 암시 적 캐스팅은 구현되지 않았습니다.)

여기에서, 매스 매 티카의 AnglePath와 ListPlot우리가 필요로하는 무엇을 정확하게 :

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

대화 형 앱에서 출력은 크기 조정 가능한 벡터 그래픽스 객체입니다.

MATL , 25 24 21 바이트

Q:qJyZpbB!sEq*^YpYsXG

MATL 온라인에서 사용해보십시오

채팅에서 멋진 골프 세션을 보내 주신 @LuisMendo에게 감사드립니다. 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.5GB이고 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 Language (Mathematica) , 98 96 91 77 76 63 바이트

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

-14 바이트 : 사용 방법을AnglePath 보여 준 @lirtosiast 덕분에 ...

-13 바이트 : ... and 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 점 배열에서 요소 ).

코드의 이러한 부분은 이들의 배열 생성 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

펄 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 복소수 목록을 실수 부와 허수 부의 2 요소 목록으로 변환합니다.

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의 답변 에서 사용되는 테스트이며 , 이는 Wilson의 정리 에 의존합니다. .

패리티 테스트는 Kernighan의 비트 카운팅 방법의 적응을 사용합니다. .

프라임 테스트가 매우 느리고 알고리즘이 그려진 각 픽셀에 대해 전체 경로 생성 기능을 다시 실행하므로 TIO에서 1000보다 훨씬 높은 입력이 시간 초과됩니다.

로고, 177 171 바이트

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

자바 스크립트 - 675 668 660 632 556 534 바이트

CodeGolf에서 처음으로 ~ 1500 바이트 코드로 시작했습니다. 에 Golfed 절반 이하로 거의 더 그것의 1/3 이상. 골프를 계속하십시오. 바이트 수 : 이 도구

원리 :
입력으로 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}

공백이있는 ungolfed 코드 :

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 바이트

Kevin Cruijssen 덕분에 -1 바이트!

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

명확하게 보이지 않을 수 있습니다