ไหลงูยังเป็นที่รู้จักโค้ง Gosperเป็นเส้นโค้งเศษส่วนเติบโตชี้แจงในขนาดที่มีการสั่งซื้อแต่ละ / ทวนของกระบวนการง่ายๆ ด้านล่างนี้เป็นรายละเอียดเกี่ยวกับการก่อสร้างและตัวอย่างบางส่วนสำหรับคำสั่งซื้อต่างๆ:

Order 1 Flow Snake :

____
\__ \
__/

คำสั่งซื้อ 2 Flow Snake :

      ____
 ____ \__ \
 \__ \__/ / __
 __/ ____ \ \ \
/ __ \__ \ \/
\ \ \__/ / __
 \/ ____ \/ /
    \__ \__/
    __/

สั่งงูไหล 3 อัน :

                 ____
            ____ \__ \
            \__ \__/ / __
            __/ ____ \ \ \    ____
           / __ \__ \ \/ / __ \__ \
      ____ \ \ \__/ / __ \/ / __/ / __
 ____ \__ \ \/ ____ \/ / __/ / __ \ \ \
 \__ \__/ / __ \__ \__/ / __ \ \ \ \/
 __/ ____ \ \ \__/ ____ \ \ \ \/ / __
/ __ \__ \ \/ ____ \__ \ \/ / __ \/ /
\ \ \__/ / __ \__ \__/ / __ \ \ \__/
 \/ ____ \/ / __/ ____ \ \ \ \/ ____
    \__ \__/ / __ \__ \ \/ / __ \__ \
    __/ ____ \ \ \__/ / __ \/ / __/ / __
   / __ \__ \ \/ ____ \/ / __/ / __ \/ /
   \/ / __/ / __ \__ \__/ / __ \/ / __/
   __/ / __ \ \ \__/ ____ \ \ \__/ / __
  / __ \ \ \ \/ ____ \__ \ \/ ____ \/ /
  \ \ \ \/ / __ \__ \__/ / __ \__ \__/
   \/ / __ \/ / __/ ____ \ \ \__/
      \ \ \__/ / __ \__ \ \/
       \/      \ \ \__/ / __
                \/ ____ \/ /
                   \__ \__/
                   __/

การก่อสร้าง

พิจารณาลำดับที่ 1 Flow Snake เพื่อสร้างเส้นทางที่มี 7 edge และ 8 vertices (ติดป้ายด้านล่างขยายความเป็นไปได้):

4____5____6
 \         \
 3\____2   7\
       /
0____1/

ตอนนี้สำหรับแต่ละคำสั่งต่อไปคุณเพียงแค่แทนที่ขอบด้วยรูปแบบการหมุนของรูปแบบคำสั่งดั้งเดิม 1 นี้ ใช้กฎ 3 ข้อต่อไปนี้เพื่อแทนที่ขอบ:

1สำหรับขอบแนวนอนให้แทนที่ด้วยรูปร่างเดิมตามที่เป็น:

________
\       \
 \____   \
     /
____/

2สำหรับ/ขอบ ( 12ในโครงสร้างด้านบน) แทนที่ด้วยรุ่นที่หมุนได้ดังต่อไปนี้:

 /
/   ____
\  /   /
 \/   /
     /
____/

3สำหรับ\ขอบ ( 34และ67ด้านบน) ให้แทนที่ด้วยรุ่นที่หมุนต่อไปนี้:

 /
/   ____ 
\   \   \
 \   \   \
  \  /
   \/

ตัวอย่างเช่นลำดับที่ 2 ที่มีจุดยอดจากคำสั่งซื้อที่ 1 จะมีลักษณะดังนี้

            ________
            \       \
  ________   \____   \6
  \       \      /   /
   \____   \5___/   /   ____
       /            \   \   \
  4___/   ________   \   \   \7
 /        \       \   \  /
/   ____   \____   \2  \/
\   \   \      /   /
 \   \   \3___/   /   ____
  \  /            \  /   /
   \/   ________   \/   /
        \       \      /
         \____   \1___/
             /
        0___/

ตอนนี้สำหรับการสั่งซื้อที่สูงขึ้นคุณเพียงแค่แบ่งระดับปัจจุบันเป็นขอบของความยาว 1 /, 1 \หรือ 2 _และทำซ้ำขั้นตอน โปรดทราบว่าแม้หลังจากเปลี่ยนแล้วจุดยอดที่พบบ่อยระหว่างขอบทั้งสองที่ต่อเนื่องกันนั้นยังคงเหมือนกัน

ท้าทาย

• คุณต้องเขียนฟังก์ชั่นของโปรแกรมเต็มรูปแบบที่ได้รับจำนวนเต็มเดียวNผ่านทางอาร์กิวเมนต์ STDIN / ARGV / function หรือเทียบเท่าที่ใกล้เคียงที่สุดและพิมพ์ลำดับการNไหลของงูบน STDOUT
• จำนวนเต็มอินพุทมากกว่า0เสมอ
• ไม่ควรมีช่องว่างนำหน้าซึ่งไม่ได้เป็นส่วนหนึ่งของรูปแบบ
• ไม่ควรมีช่องว่างต่อท้ายหรือช่องว่างต่อท้ายมากพอที่จะแพทเทิร์นเพื่อเติมสี่เหลี่ยมมุมต่ำสุดที่สมบูรณ์
• ขึ้นบรรทัดใหม่ต่อท้ายเป็นทางเลือก

ข้อเท็จจริงที่สนุกสนาน

• Flow Snakes เป็นคำเล่นของ Snow Flakes ซึ่งรูปแบบนี้คล้ายกับคำสั่งที่ 2 และสูงกว่า
• โฟลว์และงูมีส่วนร่วมในรูปแบบจริง ๆ ตามรูปแบบที่สร้างขึ้นจากเส้นทางเดียวที่ไหลตลอด
• หากคุณสังเกตเห็นอย่างระมัดระวังรูปแบบลำดับ 2 (และสูงกว่า) ประกอบด้วยการหมุนของรูปแบบคำสั่ง 1 หมุนไปที่จุดสุดยอดทั่วไปของกระแสและขอบก่อนหน้า
• มีตัวแปรที่ไม่ใช่ ASCII ของ Flow Snakes ซึ่งสามารถพบได้ที่นี่และที่อื่น ๆ

นี่คือโค้ดกอล์ฟที่สั้นที่สุดในหน่วยไบต์!

ลีดเดอร์บอร์ด

โพสต์แรกของซีรีส์สร้างกระดานผู้นำ

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มต้นทุกคำตอบด้วยพาดหัวโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

# Ruby, <s>104</s> <s>101</s> 96 bytes

CJam, 144 ไบต์

0_]0a{{_[0X3Y0_5]f+W@#%~}%}ri*{_[YXW0WW]3/If=WI6%2>#f*.+}fI]2ew{$_0=\1f=~-
"__1a /L \2,"S/=(@\+\~.+}%_2f<_:.e>\:.e<:M.-:)~S*a*\{M.-~3$3$=\tt}/zN*

เพิ่มบรรทัดใหม่เพื่อหลีกเลี่ยงการเลื่อน ลองออนไลน์

โปรแกรมทำงานในหลายขั้นตอน:

1. แฟร็กทัลเริ่มต้น (คำสั่งที่ 1) ถูกเข้ารหัสเป็นลำดับของ 7 มุม (ตามแนวคิด, ทวีคูณ 60 °) แทนทิศทางการเคลื่อนที่
2. เศษส่วนคือ "ใช้" กับส่วนแนวนอน (ลำดับ 0 เศษส่วน) N ครั้งเพื่อสร้าง "การเคลื่อนไหว" ทั้งหมดในลำดับ N เศษส่วน
3. เริ่มจาก [0 0] การเคลื่อนไหวจะถูกแปลเป็นลำดับของจุดด้วยพิกัด [xy]
4. แต่ละเซกเมนต์ (คู่ของคะแนน) ถูกแปลงเป็น 1 หรือ 2 [xyc] สามเท่าแทนอักขระ c ที่พิกัด x, y
5. สี่เหลี่ยม bounding ถูกกำหนดพิกัดจะถูกปรับและเมทริกซ์ของช่องว่างถูกสร้างขึ้น
6. สำหรับ triplet แต่ละตัวอักขระ c ถูกวางที่ตำแหน่ง x, y ในเมทริกซ์และเมทริกซ์สุดท้ายจะถูกปรับสำหรับเอาต์พุต

Python 2, 428 411 388 ไบต์

อันนี้ค่อนข้างยุ่งยาก รูปแบบที่ไม่รักษาอัตราส่วนของพวกเขาหลังจากแต่ละขั้นตอนหมายถึงมันยากมากที่จะผลิตภาพจากขั้นตอนก่อนขั้นตอน สิ่งที่รหัสนี้ทำแม้ว่ามันจะไม่สามารถอ่านได้หลังจากเล่นกอล์ฟทางคณิตศาสตร์อย่างรุนแรง แต่จริงๆแล้วเป็นการวาดเส้นตั้งแต่ต้นจนจบโดยใช้Dฟังก์ชั่นที่กำหนดซ้ำ

ขนาดก็เป็นปัญหาเช่นกันและท้ายที่สุดฉันก็เริ่มที่ตรงกลางของ5*3**nสี่เหลี่ยมจัตุรัสข้างและปลูกพืชหลังจากนั้นแม้ว่าฉันจะคิดวิธีที่ดีกว่าในการคำนวณขนาดที่ฉันอาจเปลี่ยน

n=input();s=5*3**n
r=[s*[" "]for i in[0]*s]
def D(n,x,y,t=0):
 if n<1:
    x-=t%2<1;y+=t%3>1;r[y][x]='_/\\'[t/2]
    if t<2:r[y][x+2*t-1]='_'
    return[-1,2,0,1,0,1][t]+x,y-(2<t<5)
 for c in[int(i)^t%2for i in"424050035512124224003"[t/2::3]][::(t^1)-t]:x,y=D(n-1,x,y,c)
 return x,y
D(n,s/2,s/2)
S=[''.join(c).rstrip()for c in r]
for l in[c[min(c.find('\\')%s for c in S):]for c in S if c]:print l

JavaScript ( ES6 ), 356 362 370

นั่นเป็นเรื่องยาก ...

แต่ละรูปร่างถูกเก็บเป็นพา ธ มีการสร้างบล็อคพื้นฐาน 6 รายการ (3 + 3 ย้อนหลัง)

• 0 เส้นทแยงมุมขึ้นจากซ้ายไปล่างขวา4ย้อนกลับ)
• 1 เส้นทแยงมุมล่างซ้ายไปขวาขึ้น5ย้อนกลับ)
• 2แนวนอนจากซ้ายไปขวา ( 6ย้อนกลับ)

สำหรับแต่ละขั้นตอนจะมีขั้นตอนการแทนที่เมื่อเพิ่มลำดับ:

• 0-> 0645001(ย้อนกลับ4->5441024)
• 1-> 2116501(ย้อนกลับ5->5412556)
• 2-> 2160224(ย้อนหลัง6-> 0664256)

ค่า prefilled ในhอาร์เรย์แม้ว่าองค์ประกอบ 4..6 สามารถรับได้จาก 0..2 โดยใช้

;[...h[n]].reverse().map(x=>x^4).join('')

เพื่อให้ได้รูปร่างสำหรับการสั่งซื้อที่กำหนดพา ธ จะถูกสร้างขึ้นในตัวแปร p โดยใช้การแทนที่ซ้ำ ๆ จากนั้นลูปหลักจะวนซ้ำกับตัวแปร p และวาดรูปร่างภายในอาร์เรย์ g [] โดยที่แต่ละองค์ประกอบเป็นแถว
เริ่มต้นที่ตำแหน่ง (0,0) แต่ละดัชนีสามารถกลายเป็นลบ (ดัชนี y ที่คำสั่งซื้อสูง) ฉันหลีกเลี่ยงดัชนี y เชิงลบเลื่อนอาร์เรย์ g ทั้งหมดเมื่อใดก็ตามที่ฉันพบค่าลบ y ฉันไม่สนหรอกว่าดัชนี x จะกลายเป็นลบเช่นเดียวกับที่อนุญาตให้ลบดัชนี JS ได้ยากขึ้นเล็กน้อยในการจัดการ
ในขั้นตอนสุดท้ายฉันสแกนอาร์เรย์หลักโดยใช้. map แต่สำหรับแต่ละแถวฉันจำเป็นต้องใช้ลูปที่ชัดเจนสำหรับ (;;) โดยใช้bตัวแปรที่เก็บค่าดัชนีต่ำสุดที่เข้าถึง (นั่นคือ <0)
ในconsole.log รุ่นมี newline ชั้นนำที่มีประโยชน์ที่สามารถทำขึ้นบรรทัดใหม่ได้อย่างง่ายดายต่อท้ายการแลกเปลี่ยน 2 แถวเช่นเดียวกับในรุ่นตัวอย่าง

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    o+='\n';
    for(x=b;x<r.length;)o+=r[x++]||' '
  },o='');
  console.log(o)
}

ตัวอย่างที่มีประโยชน์ในการทดสอบ (ใน Firefox):

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    for(x=b;x<r.length;)o+=r[x++]||' ';
    o+='\n'
  },o='');
  return o
}

// TEST

fs=9;
O.style.fontSize=fs+'px'

function zoom(d) { 
  d += fs;
  if (d > 1 && d < 40)
    fs=d, O.style.fontSize=d+'px'
}

#O {
  font-size: 9px;
  line-height: 1em;
}

<input id=I value=3><button onclick='O.innerHTML=f(I.value)'>-></button>
<button onclick="zoom(2)">Zoom +</button><button onclick="zoom(-2)">Zoom -</button>
<br>
<pre id=O></pre>

Haskell, 265 ไบต์

(?)=div
(%)=mod
t[a,b]=[3*a+b,2*b-a]
_#[0,0]=0
0#_=3
n#p=[352,6497,2466,-1]!!((n-1)#t[(s+3)?7|s<-p])?(4^p!!0%7)%4
0&_=0
n&p=(n-1)&t p+maximum(abs<$>sum p:p)
n!b=n&[1,-b]
f n=putStr$unlines[["__ \\/   "!!(2*n#t[a?2,-b]+a%2)|a<-[b-n!2+1..b+n!2+0^n?3]]|b<-[-n!0..n!0]]

(หมายเหตุ: ใน GHC ก่อน 7.10 คุณจะต้องเพิ่มimport Control.Applicativeหรือแทนที่abs<$>ด้วยmap abs$)

ทำงานออนไลน์ที่ Ideone.com

f n :: Int -> IO ()ดึงระดับnflownake การวาดภาพถูกคำนวณตามลำดับบิตแมปแทนที่จะเป็นแนวโค้งซึ่งทำให้อัลกอริทึมสามารถทำงานในพื้นที่ O (n) (นั่นคือลอการิทึมในขนาดการวาดภาพ) เกือบครึ่งหนึ่งของไบต์ของฉันถูกใช้ไปกับการคำนวณซึ่งสี่เหลี่ยมผืนผ้าวาด!

Perl, 334 316 309

$_=2;eval's/./(map{($_,"\1"x7^reverse)}2003140,2034225,4351440)[$&]/ge;'x($s=<>);
s/2|3/$&$&/g;$x=$y=3**$s-1;s!.!'$r{'.qw($y--,$x++ ++$y,--$x $y,$x++ $y,--$x
$y--,--$x ++$y,$x++)[$&]."}=$&+1"!eeg;y!1-6!//__\\!,s/^$x//,s/ *$/
/,print for
grep{/^ */;$x&=$&;$'}map{/^/;$x=join'',map$r{$',$_}||$",@f}@f=0..3**$s*2

พารามิเตอร์ที่ใช้กับอินพุตมาตรฐาน ทดสอบฉัน

Haskell, 469 419 390 385 365 ไบต์

ฟังก์ชั่น f :: Int-> IO () ใช้จำนวนเต็มเป็นอินพุตและพิมพ์งูไหล

e 0=[0,0];e 5=[5,5];e x=[x]
f n=putStr.t$e=<<g n[0]
k=map$(53-).fromEnum
g 0=id
g n=g(n-1).(=<<)(k.(words"5402553 5440124 1334253 2031224 1345110 2003510"!!))
x=s$k"444666555666"
y=s$k"564645554545"
r l=[minimum l..maximum l]
s _[]=[];s w(x:y)=w!!(x+6):map(+w!!x)(s w y)
t w=unlines[["_/\\\\/_ "!!(last$6:[z|(c,d,z)<-zip3(x w)(y w)w,c==i&&d==j])|i<-r.x$w]|j<-r.y$w]

C, 479 474 468 427 ไบต์

ยังไม่มีการตีพวก Perl และ Haskell ฉันเดา แต่เนื่องจากยังไม่มีการส่ง C ที่นี่:

#define C char
C *q="053400121154012150223433102343124450553245";X,Y,K,L,M,N,i,c,x,y,o;F(C*p,
int l,C d){if(d){l*=7;C s[l];for(i=0;i<l;i++)s[i]=q[(p[i/7]%8)*7+i%7];return F
(s,l,d-1);}x=0;y=0;o=32;while(l--){c=*p++%8;for(i=!(c%3)+1;i--;) {K=x<K?x:K;L=
y<L?y:L;M=x>M?x:M;N=y>N?y:N;y+=c&&c<3;x-=c%5>1;if(x==X&y==Y)o="_\\/"[c%3];y-=c
>3;x+=c%5<2;}}return X<M?o:10;}main(l){F(q,7,l);for(Y=L;Y<N;Y++)for(X=K;X<=M;X
++)putchar(F(q,7,l));}

เพื่อประหยัดพื้นที่ในการเรียกใช้ atoi () จำนวนข้อโต้แย้งที่ส่งผ่านไปยังโปรแกรมจะใช้สำหรับระดับ

โปรแกรมทำงานใน O (n ^ 3) หรือแย่กว่านั้น ก่อนอื่นเส้นทางจะถูกคำนวณหนึ่งครั้งเพื่อหาพิกัด min / max สูงสุดจากนั้นสำหรับแต่ละคู่ (x, y) จะมีการคำนวณหนึ่งครั้งเพื่อค้นหาอักขระในตำแหน่งที่ระบุนั้น ช้ามาก แต่บันทึกในการจัดการหน่วยความจำ

ตัวอย่างทำงานที่http://codepad.org/ZGc648Xi

Python 2, 523 502 475 473 467 450 437 ไบต์

l=[0]
for _ in l*input():l=sum([map(int,'004545112323312312531204045045050445212331'[t::6])for t in l],[])
p=[]
x=y=q=w=Q=W=0
for t in l:T=t|4==5;c=t in{2,4};C=t<3;q=min(q,x);Q=max(Q,x+C);w=min(w,y);W=max(W,y);a=C*2-1;a*=2-(t%3!=0);b=(1-T&c,-1)[T&1-c];x+=(a,0)[C];y+=(0,b)[c];p+=[(x,y)];x+=(0,a)[C];y+=(b,0)[c]
s=[[' ']*(Q-q)for _ in[0]*(W-w+1)]
for t,(x,y)in zip(l,p):x-=q;s[y-w][x:x+1+(t%3<1)]='_/\_'[t%3::3]
for S in s:print''.join(S)

Pffft ทำให้ฉันใช้เวลา 3 ชั่วโมง แต่ก็สนุกที่จะทำ!

แนวคิดคือการแบ่งงานออกเป็นหลายขั้นตอน:

1. คำนวณขอบทั้งหมด (เข้ารหัสเป็น 0-5) ตามลำดับที่ปรากฏ (ตั้งแต่เริ่มต้นจนถึงปลายงู)
2. คำนวณตำแหน่งสำหรับแต่ละขอบ (และบันทึกค่า min และ max สำหรับ x และ y)
3. สร้างสตริงที่ประกอบด้วย (และใช้ค่าขั้นต่ำเพื่อชดเชยเพื่อให้เราไม่ได้รับดัชนีติดลบ)
4. พิมพ์สตริง

นี่คือรหัสในรูปแบบ ungolfed:

# The input
n = int(input())

# The idea:
# Use a series of types (_, /, \, %), and positions (x, y)
# Forwards:   0: __  1: /  2: \
# Backwards:  3: __  4: /  5: \

# The parts
pieces = [
    "0135002",
    "0113451",
    "4221502",
    "5332043",
    "4210443",
    "5324551"
]
# The final types list
types = [0]
for _ in range(n):
    old = types
    types = []
    for t in old:
        types.extend(map(int,pieces[t]))

# Calculate the list of positions (and store the mins and max')
pos = []
top = False
x = 0
y = 0
minX = 0
minY = 0
maxX = 0
maxY = 0
for t in types:
    # Calculate dx
    dx = 1 if t < 3 else -1
    if t%3==0:
        dx *= 2         # If it's an underscore, double the horizontal size
    # Calculate dy
    top = t in {1, 5}
    dy = 0
    if top and t in {0, 3, 1, 5}:
        dy = -1
    if not top and t in {2, 4}:
        dy = 1
    # If backwards, add dx before adding the position to the list
    if t>2:
        x += dx
    # If top to bottom, add dy before adding the position to the list
    if t in {2,4}:
        y += dy
    # Add the current position to the list
    pos += [(x, y)]
    # In the normal cases (going forward and up) modify the x and y after changing the position
    if t<3:
        x += dx
    if t not in {2, 4}:
        y += dy
    # Store the max and min vars
    minX = min(minX, x)
    maxX = max(maxX, x + (t<3)) # For forward chars, add one to the length (we never end with __'s)
    minY = min(minY, y)
    maxY = max(maxY, y)

# Create the string (a grid of charachters)
s = [[' '] * (maxX - minX) for _ in range(maxY - minY + 1)]
for k, (x, y) in enumerate(pos):
    x -= minX
    y -= minY
    t = types[k]
    char = '/'
    if t % 3 == 0:
        char = '__'
    if t % 3 == 2:
        char = '\\'
    s[y][x : x + len(char)] = char

# Print the string
for printString in s:
    print("".join(printString))

แก้ไข:ฉันเปลี่ยนภาษาเป็น python 2 เพื่อให้เข้ากันได้กับคำตอบของฉันสำหรับ # 3 (และยังประหยัดอีก 6 ไบต์)

Pari / GP, 395

วนรอบตำแหน่ง x, y อักขระและคำนวณสิ่งที่จะพิมพ์ พยายามปานกลางในการย่อให้เล็กสุดทำเครื่องหมายด้วยช่องว่างและความคิดเห็นถูกปล้น

k=3;
{
  S = quadgen(-12);  \\ sqrt(-3)
  w = (1 + S)/2;     \\ sixth root of unity
  b = 2 + w;         \\ base

  \\ base b low digit position under 2*Re+4*Im mod 7 index
  P = [0, w^2, 1, w, w^4, w^3, w^5];
  \\ rotation state table
  T = 7*[0,0,1,0,0,1,2, 1,2,1,0,1,1,2, 2,2,2,0,0,1,2];
  C = ["_","_",  " ","\\",  "/"," "];

  \\ extents
  X = 2*sum(i=0,k-1, vecmax(real(b^i*P)));
  Y = 2*sum(i=0,k-1, vecmax(imag(b^i*P)));

  for(y = -Y, Y,
     for(x = -X+!!k, X+(k<3),  \\ adjusted when endpoint is X limit
        z = (x- (o = (x+y)%2) - y*S)/2;
        v = vector(k,i,
                   z = (z - P[ d = (2*real(z) + 4*imag(z)) % 7 + 1 ])/b;
                   d);
        print1( C[if(z,3,
                     r = 0;
                     forstep(i=#v,1, -1, r = T[r+v[i]];);
                     r%5 + o + 1)]) );  \\ r=0,7,14 mod 5 is 0,2,4
     print())
}

ถ่านแต่ละตัวเป็นเซลล์ที่หนึ่งหรือสองของเซลล์หกเหลี่ยม ตำแหน่งเซลล์คือจำนวนเชิงซ้อน z ที่แบ่งออกเป็นฐาน b = 2 + w ด้วยตัวเลข 0, 1, w ^ 2, ... , w ^ 5 โดยที่ w = e ^ (2pi / 6) รากที่หกของความสามัคคี ตัวเลขเหล่านั้นจะถูกเก็บไว้เช่นเดียวกับความแตกต่าง 1 ถึง 7 จากนั้นนำสูงไปต่ำผ่านตารางสถานะสำหรับการหมุนสุทธิ นี่คือรูปแบบของรหัส flownake โดย Ed Shouten (xytoi) แต่ใช้สำหรับการหมุนสุทธิเท่านั้นโดยไม่สร้างตัวเลขในดัชนี "N" ตามเส้นทาง extents สัมพันธ์กับจุดเริ่มต้น 0 ที่กึ่งกลางของรูปร่าง ตราบใดที่ข้อ จำกัด ไม่ใช่จุดสิ้นสุดสิ่งเหล่านี้จะอยู่ตรงกลางของรูปหกเหลี่ยม 2 ตัวและจำเป็นต้องใช้ตัวอักษร 1 ตัวเท่านั้น แต่เมื่องูเริ่มต้นและ / หรือสิ้นสุดจะต้องใช้ตัวอักษร X limit 2 ซึ่งก็คือ k = 0 start และ k <3 end Pari มี "ล่าม" เช่น sqrt (-3) builtin แต่สามารถทำได้ด้วยชิ้นส่วนจริงและจินตภาพแยกกัน