Aynı zamanda bir Gosper eğrisi olarak da bilinen bir Akış Yılanı, basit bir işlemin her bir sıralaması / yinelemesiyle katlanarak büyüyen fraktal bir eğridir. Aşağıda inşaat ile ilgili detaylar ve çeşitli siparişler için birkaç örnek verilmiştir:

Sipariş 1 Flow Snake :

____
\__ \
__/

Sipariş 2 Akış Yılanı :

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

Sipariş 3 Akış Yılan :

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

İnşaat

7 kenar ve 8 köşe içeren bir yoldan oluşturulacak 1 Flow Snake sırasını düşünün (aşağıda etiketlenmiştir. Fizibilite için büyütülmüş):

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

Şimdi sıradaki her bir sipariş için, kenarları basitçe bu orijinal sipariş 1 modelinin döndürülmüş bir versiyonuyla değiştirin. Kenarları değiştirmek için aşağıdaki 3 kuralı kullanın:

1 Yatay bir kenar için, orijinal şekliyle aynı şekilde değiştirin:

________
\       \
 \____   \
     /
____/

2 Bir /kenar için ( 12yukarıdaki yapıda), aşağıdaki döndürülmüş versiyonla değiştirin:

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

3 Bir \kenar için ( 34ve 67üstü), aşağıdaki döndürülmüş versiyonla değiştirin:

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

Örneğin, etiketli sipariş 1'den gelen köşeleri olan 2. sipariş,

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

Şimdi herhangi bir daha yüksek sipariş için, geçerli seviyeyi 1 /, 1 \veya 2 uzunluklarının kenarlarına bölün _ve işlemi tekrarlayın. Değiştirdikten sonra bile, arka arkaya iki kenar arasındaki ortak köşelerin hala çakıştığını unutmayın.

Meydan okuma

• NSTDIN / ARGV / function argümanı veya en yakın eşdeğeri ile tek bir tamsayı alan tam bir programın bir fonksiyonunu yazmanız ve STDOUT'daki NFlow Snake sırasını yazdırmanız gerekir .
• Giriş tamsayı her zaman olduğundan büyük 0.
• Desenin bir parçası olmayan ön boşluklar olmamalıdır.
• Minimum sınırlayıcı dikdörtgeni tamamen doldurmak için deseni doldurmak için hiçbir iz boşluğu veya yeterli iz boşluğu olmamalıdır.
• İzleyen yeni satır isteğe bağlıdır.

Eğlenceli gerçekler

• Akış Yılanları, bu düzen 2. ve daha üst sıralara benzeyen Kar Tanelerinin kelime oyunu.
• Akış ve Yılanlar, kalıp boyunca akan tek bir yoldan oluştuğu için kalıpta bir rol oynar.
• Dikkatli bir şekilde fark ederseniz, 2. sıradaki (ve aynı zamanda daha yüksek) model, geçerli ve önceki kenarın ortak tepe noktasında döndürülen 1. sıradaki dönüşlerden oluşur.
• Burada ve diğer birçok yerde bulunabilen ASCII Olmayan bir Akış Yılanı çeşidi vardır .

Bu kod golf , bayt cinsinden en kısa kod kazanır!

Liderler Sıralaması

Serinin ilk yazı lider tablosu oluşturur.

Yanıtlarınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak her bir başlığa başlıkla başlayın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

CJam, 144 bayt

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*

Kaymayı önlemek için yeni satır eklendi. Çevrimiçi deneyin

Program birkaç adımda çalışır:

1. İlk fraktal (sıra 1), hareket yönünü temsil eden 7 açılı bir sekans (kavramsal olarak 60 ° 'nin katları) olarak kodlanır
2. Fraktal, N fraktal sırasındaki tüm "hareketleri" oluşturmak için yatay bir segmente (sıra 0 fraktal) N kez "uygulanır"
3. [0 0] 'dan başlayarak, hareketler [xy] koordinatlarıyla bir nokta dizisine çevrilir
4. Her bölüm (nokta çifti), x, y koordinatlarında c karakterini temsil eden 1 veya 2 [xyc] üçlülüğe dönüştürülür
5. Sınırlayıcı dikdörtgen belirlenir, koordinatlar ayarlanır ve bir boşluk matrisi oluşturulur
6. Her üçlü için c karakteri matristeki x, y pozisyonuna yerleştirilir ve son matris çıktı için ayarlanır

Python 2, 428 411 388 bayt

Bu oldukça zordu. Desenler, her adımdan sonra oranlarını koruyamaz; bu, önceki selefinden usule uygun bir görüntü üretmenin çok zor olduğu anlamına gelir. Bu kodun yaptığı şey, bazı yoğun matematik golf oyunlarından sonra okunaksız olmasına rağmen, özyinelemeli olarak tanımlanmış Dişlevi kullanarak başlangıçtan bitişe kadar olan çizgiyi çiziyor .

Büyüklük aynı zamanda bir sorun oldu ve sadece bir 5*3**nkenarlı karenin ortasından başladım ve daha sonra bazı şeyleri kırptım, ancak büyüklüğü hesaplamak için daha iyi bir yol bulabilirsem değiştirebilirim.

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

Bu zor bir ...

Her şekil bir yol olarak saklanır. 6 temel yapı taşı vardır (3 + 3 geriye)

• 0diyagonal yukarı soldan aşağı sağa ( 4geri)
• 1çapraz alt soldan yukarı sağa ( 5geri)
• 2yatay soldan sağa ( 6geri)

Her biri için, sırayı arttırırken uygulanacak bir değiştirme adımı vardır:

• 0-> 0645001(geriye 4-> 5441024)
• 1-> 2116501(geriye 5-> 5412556)
• 2-> 2160224(geriye 6-> 0664256)

hdizide önceden doldurulmuş değerler , 4..6 elementleri 0..2 kullanılarak elde edilebilse bile

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

Verilen siparişin şeklini elde etmek için, yol, sübstitüsyonları tekrar tekrar uygulayan p değişkeninde oluşturulur. Ardından ana döngü p değişkeninde yinelenir ve şekli her bir öğenin bir satır olduğu g [] dizisinin içine çizer.
(0,0) pozisyonundan başlayarak her endeks negatif olabilir (yüksek siparişlerde y endeksi). Negatif bir y değeri bulduğumda tüm g dizilerini değiştiren negatif y dizinlerinden kaçınırım. X indeksinin negatif olması umrumda değil, JS negatif indekslerinde izin verildiği gibi yönetimi biraz daha zor.
Son adımda, .map kullanarak ana diziyi tararım, ancak her satır için bulaşılan en az x indeksini tutan değişkeni (<<olacak ) kullanarak açık (;;) bir döngü kullanmam gerekir.
İçindeconsole.log versiyonunda, snippet versiyonunda olduğu gibi 2 satır değiştiren takip eden bir newline yapılabilen kullanışlı bir lider newline var.

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

Test edilecek kullanışlı snippet (Firefox'ta):

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 bayt

(?)=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]]

(Not: ghc üzerinde 7.10 önce, eklemek gerekir import Control.Applicativeveya değiştirin abs<$>ile map abs$.)

Ideone.com'da çevrimiçi olarak koşun

f n :: Int -> IO ()Seviye nakış yılanı çizer . Çizim, algoritmanın O (n) uzayda (yani çizim boyutunda logaritmik) çalışmasına izin veren eğri boyunca değil bitmap sırayla hesaplanır. Baytlarımın neredeyse yarısı hangi dikdörtgenin çizileceğini hesaplamak için harcanıyor!

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

Standart girişte parametre alındı. Beni test et .

Haskell, 469 419 390 385 365 bayt

f :: Int-> IO () işlevi girdi olarak bir tamsayı alır ve akış yılanını yazdırır

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 bayt

Sanırım Perl ve Haskell adamlarını yenmek yok, ama burada henüz C gönderimi olmadığından:

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

Bir atoi () çağrısında yer kazanmak için, programa iletilen argümanların sayısı seviye için kullanılır.

Program O (n ^ 3) veya daha kötü bir şekilde çalışır; ilk önce min / maks koordinatlarını bulmak için yol bir kez hesaplanır, daha sonra her bir (x, y) çifti için o konumdaki karakteri bulmak için bir defa hesaplanır. Son derece yavaş, ancak bellek yönetimi kaydeder.

Http://codepad.org/ZGc648Xi adresinde çalıştırılan örnek

Python 2, 523 502 475 473 467 450 437 bayt

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 saatimi bana mal etti, ama yapmak eğlenceliydi!

Fikir görevi birden çok adımda bölmektir:

1. Görünüş sırasına göre (0-5 olarak kodlanmış) tüm kenarları hesapla (böylece yılanın başlangıcından sonuna kadar)
2. Kenarların her birinin konumunu hesaplayın (ve x ve y için min ve maks değerlerini kaydedin)
3. Oluştuğu dizeleri oluşturun (ve negatif değerleri almak için min değerlerini dengelemek için kullanın)
4. Dizeleri yazdır

Ungolfed formunda kod İşte:

# 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))

Düzenleme: # 3 cevabımla uyumlu olması için dili python 2 olarak değiştirdim (ve ayrıca 6 bayt daha tasarruf ettim)

Pari / GP, 395

X, y karakterlerinin üzerinde döngü ve yazdırılacak karakterin hesaplanması. Küçültme, beyaz boşlukla puanlama ve yorumların çıkarılması için ılımlı çalışmalar

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

Her karakter bir altıgen hücrenin ilk veya ikinci olduğunu. Bir hücre konumu, b = 2 + w tabanına bölünmüş, z, 0, 1, w ^ 2, ..., w ^ 5, burada w = e ^ (2pi / 6) birliğin 6. kökü olan karmaşık bir sayıdır. Bu rakamlar 1'den 7'ye kadar ayırt edici bir şekilde tutulur ve daha sonra net dönüş için bir durum tablosundan yüksekten düşüğe alınır. Bu Ed Shouten tarafından flowsnake kodunun tarzında (xytoi) fakat yalnızca net dönüş için, yol boyunca "N" endeksine rakam girmeyin. Uzatmalar, şeklin ortasındaki bir orijinli 0 ile ilgilidir. Sınır bir bitiş noktası olmadığı sürece, bunlar 2 karakterlik altıgenlerin ortasıdır ve bu karakterlerden yalnızca 1 tanesine ihtiyaç duyulur. Ancak yılanın başlangıcı ve / veya sonu X limiti olduğunda 2 karaktere ihtiyaç vardır, ki bu k = 0 başlangıç ​​ve k <3'tür. Pari yerleşik sqrt (-3) gibi "dört" lere sahiptir, ancak aynısı gerçek ve hayali parçalarla da yapılabilir.