Bu meydan amacı grafiksel her adımı yönü düzleminde, yürüyüşe tasvir etmektir bir asallık tarafından belirlenir ve ikili genişleme parite. özellikle,$k$$k$

• İlk yön sabittir, Kuzey diyelim.
• Tüm adımlar aynı uzunluktadır .
• Yön adımı $k$ şöyle Kuzey, Batı, Güney ve Doğu olabilir ve belirlenir:
  • Eğer $k$ asal değildir, yön değiştirmez.
  • Eğer $k$ asal olup ikili genişleme $k$ olanları eşit sayıda, sağa dön.
  • Eğer $k$ asal olup ikili genişleme $k$ olanlar tek sayıda, sola.

Bir şekilde işlenmiş örneğin , ilk yönde Kuzey olduğu varsayılmaktadır. İlk adımlar:

• $k=1$ asal değildir. Bu yüzden şu anki yönde bir adım ilerliyoruz, ki bu kuzeydir.
• $k=2$ asaldır ve ikili genişlemesi10vardır ve tuhaf sayıları vardır. Bu yüzden sola döndük ve şimdi Batı'ya bakıyoruz. Bu yönde bir adım ilerliyoruz.
• $k=3$ asaldır ve ikili genişlemesi vardır,11hatta birkaç tane vardır. Bu yüzden sağa dönüyoruz ve şimdi Kuzey'e bakıyoruz. Bu yönde bir adım ilerliyoruz.
• $k=4$ asal değildir. Bu yüzden şu anki yönde bir adım hareket ediyoruz, ki bu da Kuzey.

Meydan okuma

Giriş : pozitif tamsayı $N$ .

Çıktı : Yukarıda tanımlandığı gibi $N$ adım yürüyüşünün grafiği .

Ek kurallar

• İlk yönde serbestçe (ille Kuzey) seçilebilir, ancak tüm için aynı olması gerekir $N$ .
• Dönüm kuralı sağ garip paritesine açmak ve hatta bırakılır olduğunu yukarıda açıklandığı üzere tersi olabilir; ama bütün için aynı olmak zorunda .$N$
• Çıktı yürüyüşün grafiksel bir gösterimi olmalıdır . Örneğin:
  • Yürüyüş, çizgi parçalarıyla çizilebilir.
  • Ziyaret edilen noktalar, nokta gibi bir işaretleyici ile gösterilebilir; bağlantı parçası segmenti olan veya olmayan.
  • İki renkli tarama görüntüsü sağlanabilir, biri ziyaret edilen noktalara karşılık gelir ve diğeri ziyaret edilmeyenler için.
• Yatay ve dikey eksenlerin ölçekleri aynı olmak zorunda değildir. Ayrıca eksen etiketleri ve benzeri elemanlar isteğe bağlıdır. Yürüyüş açıkça görülebildiği sürece, arsa geçerlidir.
• Bazı noktaların birden fazla kez ziyaret edildiğini unutmayın. Arsa buna duyarlı değildir. Örneğin, eğer çizgi segmentleri arsada gösteriliyorsa, kaç tane travers edilmiş olursa olsun her birim segmenti aynı görüntülenir.
• Kod, Nverilen sınırsız kaynak için çalışmalıdır. Uygulamada Nzaman, hafıza veya veri tipi sınırlamaları nedeniyle büyük ölçüde başarısız olursa kabul edilebilir .
• Giriş ve çıkış her zamanki gibi esnektir. Özellikle, görüntülerin çıkarılması için standart yollardan herhangi biri kullanılabilir.
• Bayt cinsinden en kısa kod kazanır.

Test durumları

Aşağıdaki grafikler Kuzeyi ilk yön olarak kullanıyor; parite bile sağa döner; ve yürüyüş çizgi parçalarıyla gösterilmiştir.

N = 7:

N = 3000:

N = 20000:

N = 159000:

N = 1200000:

N = 11000000:

Balyoz 0.4 , 22 20 bayt

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

Bu Wolfram Dili işlevine sıkıştırmalar:

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

Ungolfed

Öncelikle her adımda dönme açısını döndüren bir fonksiyon tanımlarız:

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

ThueMorseİkili hanelerin toplamının paritesidir. Biraz karmaşık bir sebepten -1^(...)ziyade kullanıyoruz 2*...-1: Wolfram Language otomatik olarak kaynaktaki aritmetik ifadeleri kanonik bir forma dönüştürür, bu yüzden gibi ifadeler 2/xsaklanır Times[2, Power[x, -1]]. Bu, Powerçok yüksek frekansı yapar ve böylece onu çok ucuza sıkar.

(Çarpma işlemi Boole@PrimeQ@biraz daha uzundur ve Boolemeydan okuma sırasında Boolean'ların örtük dökümü gerçekleştirilmemiştir.)

Buradan, Mathematica’ya AnglePathve ListPlottam olarak ihtiyacımız olanı yapın:

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

Etkileşimli uygulamada çıktı, ölçeklenebilir bir vektör Grafik nesnesidir.

MATL , 25 24 21 bayt

Q:qJyZpbB!sEq*^YpYsXG

MATL online olarak deneyin

Sonunda bu 21 byte sürümüne yol açan sohbette güzel bir golf oturumu için @LuisMendo'ya teşekkür ederek Eq*^

açıklama

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

için örnek : $k=12345$

C (gcc) , 179 bayt

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

Çevrimiçi deneyin!

Bir işlev. Birinci argüman N, ikinci argüman en az bayt boyutunda tahsis edilmiş bir arabellektir . Bu tampona kare bir resim yazılır, kenar uzunluğu döndürülür. Görüntüde, beyaz bir piksel, siyah bir pikseldir.$4 n^2 + 4 n + 1$01

C (gcc) , 219 bayt

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

Çevrimiçi deneyin!

Bir işlev. Birinci argüman N, ikinci argüman en az bayt boyutunda tahsis edilmiş bir tampon . Tampona PBM formatında bir kare görüntü yazılır.$4 n^2 + 4 n + 2 \times \lfloor log_{10}(2n+1)\rfloor + 9$

20000 için kırpılmış çıktı:

Her iki versiyon da batı ile başlar ve sağa, teke sola, sağa döner.

20000 ~ 1.5 GB olan ve 150000 ~ 90 GB olacak olan daha büyük testcas'ları ikisiyle de denedim. Program yürütülürken bunların tümü hafızada saklanır.

Üstteki açıklama:

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 Dili (Mathematica) , 98 96 91 77 76 63 bayt

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

-14 bytes: @ lirtosiast'a nasıl kullanıldığınıAnglePath gösterdiğin için teşekkürler ...

-13 bayt: ... ve ThueMorse!

kullanım örneği:

%[20000]

Adım adım açıklama:

• If[PrimeQ@#, 2 ThueMorse@# - 1, 0] &adım indeksini alan ve asal olmayanlar için 0, çiftli asal sayılar için -1 ve tekli asal sayılar için +1 döndüren bir işlevdir. ThueMorse@#önceki çözümün yerine geçiyor Total[#~IntegerDigits~2](aynı, modulo 2).

• Array[Pi/2*%,#]bu fonksiyonun bir listesini 1'den fonksiyon argümanına (örnekte 20000) giden indis yapar ve her elemanı element / 2 ile çarparak bir yön değiştirme açısına (radyan) dönüştürür. Şimdi asal olmayanlar için 0, çiftli asal sayılar için -π / 2 ve tekli asal sayılar için + π / 2 değerine sahibiz.

• AnglePath[%]Bu yön değiştirme açılarının listesini bir yola dönüştürür. Bu talimat önceki çözümün çift kullanımının yerini alır Accumulate.

• ListPlot[%]Konum listesini XY nokta grafiğine dönüştürür. Bir çizgi tercih edilirse, ListLinePlotyerine kullanın. Bu çizim işlevlerinin, arazilerin daha iyi görünmesini sağlamak için birçok seçeneği vardır.

MATL, 31 30 28 26 bayt

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

@LuisMendo sayesinde 3 bayt kurtarıldı

@Sanchises sayesinde 2 bayt kaydedildi

MATL Online'da deneyin

açıklama

Bu çözüm, 2B düzlemin X ve Y bileşenlerini temsil etmek için karmaşık sayılar kullanır

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]

Bu noktada, (0, 1), (-1, 0), (0, -1), (1, 0)karmaşık sayılarla temsil edilen bir dizide dört nokta ( ) var . Bunlar dört ana yöndür. Şimdi bunları "yürümek" için kullanmak istiyoruz.

Esasen, bu işleyiş biçimimiz, sıfırıncı yöne doğru ilerlemeye başlamamızdır (olan dizinin 0'cı elemanı (-1, 0)). Her adım için, bu başlıktaki değişikliği belirlememiz gerekir. Bu değişikliği izlemek için tamsayıları kullanacağız. Eğer "sağa" çevirmek istiyorsak, bu tamsayıyı 1 ( 4-nokta dizisindeki bir sonraki öğeye atıfta bulunurken) ve "sola" gitmek istiyorsak, bu tamsayıyı 1 olan ( önceki öğeye atıfta bulunarak) azaltırız. 4-nokta dizisi). Yolumuza devam etmek istiyorsak, tamsayı değerini sabit tutarız ( 4-nokta dizisindeki aynı öğeye atıfta bulunuruz ).

Kodun bu bölümü olanların hepsi bir dizi oluşturur 0, -1ve 1değerler.

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

Şimdi art arda tamsayılar arasındaki farkların bir dizisine sahibiz, böylece orijinal 4-element dizisindeki her adımda yönü aramak için kullanabileceğimiz endeksleri elde etmek için toplamların toplamını hesaplayabiliriz.

Uygun bir şekilde MATL, endeksleme 5, 4 elemanlı bir dizinin başlangıcına dolanacak şekilde sarmalı indekslemeye sahiptir . Bunu, referans yön dizisinin sadece 4 element olduğu gerçeğinden endişe etmeden bu tam sayıyı artırabilir ve azaltabilmemiz için kullanabiliriz.

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

Şimdi adım attığımız adımların bir dizisine sahibiz, bu yüzden atılan yolu bulmak için bu yönlerin kümülatif toplamını hesaplayabiliriz.

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

Perl 6 , 213 182 bayt

{my @p = [\ +] [\ *] ({{.-prime ??. üssü (2) .comb (~ 1)% 2 ?? i !! - i !! 1 + 0i} (+ + $)} ... *) [^ $ _]; {"<svg viewBox = '{. min xx 2, .elems xx 2}' >>. & {" L {.re} {.im} " }} 'fill =' none 'vuruş =' siyah '/> "} (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)}

Çevrimiçi deneyin!

(Gerçekten bunu aşağılamayı başardı!)

Bu fonksiyon SVG formatında çıkar.

• { -{ .is-prime * .base(2).comb(~1) R** -1 || i }(++$)i } ... *her adım için 1, "aynı yöne devam et" ianlamına gelen "sola dönüş" ve -i"sağa dönüş " anlamına gelen karmaşık sayılar şeklinde sonsuz bir yön dizisidir .
• [^$_] bu sırayı işlevin argümanı olarak verilen adımların sayısıyla sınırlar.
• [\*] bu diziyi (karmaşık) çarpma ile tarar, göreceli yön listesini mutlak yönler listesine dönüştürür.
• [\+]bu diziyi (karmaşık) ilavesiyle tarar , ziyaret edilen koordinatların bir listesini üretir.
• ».reals bu karmaşık sayılar listesini gerçek ve hayali bölümlerinin iki öğeli listelerine dönüştürür.

SVG görüntüsü sadece bir tek pathelemandır.

N = 20000 için çıkış (PNG'ye dönüştürülmüş):

C, 321 bayt

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

Çevrimiçi deneyin!

Diğer C cevabı gönderilmeden önce bunun üzerinde çalışmaya başladım, ama yine de benimkini gönderebileceğimi düşündüm. Bu, çok daha uzun, ancak çıktı görüntüsünü otomatik olarak sonucun boyutlarına da kırpıyor.

Fonksiyon olarak adlandırılır f(n)ve çıktı netpbm formatında stdout olur.

N = 1000 için örnek çıktı:

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

Asal test, Lynn'in Lynn'in teorisine dayanan, farklı bir mücadeleye verdiği cevapta kullanılan testtir .

Eşlik testi, Kernighan'ın bit sayma yönteminin bir uyarlamasını kullanır .

Asal test çok yavaş olduğundan ve algoritma çizilen her piksel için tüm yol oluşturma işlevini yeniden çalıştırır, herhangi bir giriş TIO'da 1000 kat daha yüksektir.

LOGO, 177 171 bayt

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

Kullanım için, böyle bir şey yapmak bu :

reset
pu
fw 100
pd
g 3000

Üzgünüm, ancak örnek çıktıyı yakalayamadım. Açıklama:

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

Bu, parametresindeki her bir ayar biti için 180 ° dönen ve ikili genişlemesinin paritesini etkin bir şekilde hesaplayan özyinelemeli bir işlemdir.

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

Bu çok temel bir asallık testidir. Özel kaplama 1'den sonra, bir faktör bulunursa prosedür erken döner. Bununla birlikte, mevcut değer asal olarak bulunursa, sağa döner ve ardından uygun şekilde sola dönüşe geçmek için yukarıdaki prosedürü kullanır.

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

Bu sadece tüm sayıları nilkelliğe kadar sınamak ve her biri için iki piksel taşımak için basit bir döngüdür .

Jöle , 41 bayt

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

Çevrimiçi deneyin!

Tek bir argüman alır Tam programı ve çıkışı için bir 1 bitlik PBM çıkarmaktadır. @Sanchises MATL cevabından biraz ilham alır . Güneye doğru başlar ve tek bit paritesinde sola döner.$N$

için örnek çıktı :$N=3000$

ASCII Art'a izin verildiyse, işte alternatif bir 29-baytlık değişken ( ):$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 Bayt

CodeGolf'ta ilk kez, başlangıçta ~ 1500 Bayt Kodu ile başladı. Neredeyse üçte birinden fazlasının yarısından daha azına golf oynadı . Golfe devam etmek için çekinmeyin. Sayılan Bayt: bu araç

Prensip:
Girdi olarak değişken strok uzunluğuna ve N ile sabit boyutlu tuval içine çizer.

Düzenlemeler:

-07 Byte - kaçırdıysam kaldırılmasının
if / else değişikliğin anahtarı - -08 Bytes
-28 Bayt - tenary değişiklik if / else
-76 Bayt - kısa asal testi (zamanı / 3)
-22 Byte - kullanmak bu asal işlevi (çalışma zamanı * 4)

Golf Kodu:

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}

Boşluklu kodsuz kod:

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
}

Örnekler:

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

Kod pasajını çalıştırSonuçları gizle

Parçacığı genişlet

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

Kod pasajını çalıştırSonuçları gizle

Parçacığı genişlet

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

Kod pasajını çalıştırSonuçları gizle

Parçacığı genişlet

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

Kod pasajını çalıştırSonuçları gizle

Parçacığı genişlet

Kırmızı , 515 480 471 bayt

Kevin Cruijssen sayesinde -1 bayt!

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]]]]]

Kodun önemli bir kısmı (~ 160 bytes) koordinatların normalleştirilmesiyle ilgilidir, böylece grafikler girişin boyutuna bakılmaksızın tamamen tuval üzerine sığabilir.

İlk yön: Güney.

İşte sonucu n = 3000

n = 20000

İşlem, 140+ bayt

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

Açıkça görülmediği gibi gerçekleşmeyebilir