Kaos Oyun fraktalları oluşturmak için basit bir yöntemdir. Bir başlangıç ​​noktası, bir uzunluk oranı r ve bir 2B nokta kümesi verildiğinde, aşağıdakileri tekrarlayın:

• Noktalardan, rastgele (düzgün bir şekilde) birini seçin.
• Ortalama olarak bu nokta ve son çizilen nokta (veya başlangıç ​​noktası) r ve 1 - r ağırlıklarını kullanarak (yani r = 0 başlangıç ​​noktasını aldığınızı gösterir, r = 1 rasgele noktayı aldığınızı ve r = 0.5 ise aradaki noktayı bul.)
• Sonuç noktasını çizin.

Örneğin, bir eşkenar üçgenin ve r = 0.5'in köşelerini seçtiyseniz , çizilen noktalar bir Sierpinski üçgeni çizer:

^{Wikipedia'da bulunan resim}

Bir fraktal yaratmak için kaos oyununu "oynayan" bir program veya işlev yazacaksınız.

Giriş

Bir program veya fonksiyon yazabilir ve ARGV, STDIN veya fonksiyon argümanı ile aşağıdaki girişleri alabilirsiniz:

• Çizilecek nokta sayısı.
• Başlangıç ​​koordinatı (bunun da çizilmesi gerekiyor!).
• Aralıktaki ortalama ağırlık r [0,1] .
• Seçilebilecek noktaların listesi.

Çıktı

Ekranda görüntüleyebilir veya bir görüntü dosyası yazabilirsiniz. Sonuç rasterleştirilirse, her iki tarafta en az 600 piksel olması gerekir, tüm noktalar tuval üzerinde olmalı ve görüntünün yatay ve dikey boyutunun en az% 75'i noktalar için kullanılmalıdır (bu "gerçekten çok uzaklaştı" diyen tek bir siyah pikselli cevaplar. X ve Y ekseni aynı ölçek üzerinde olmalıdır (edilene 0,0 (hat) (1,1) 45 derecelik bir açı ile olmalıdır) ve kaos oyunda çizilen her nokta bir şekilde temsil edilmelidir piksel (eğer çizim metodunuz noktaya anti-alias yaparsa, 2x2 piksele yayılmış olabilir).

Renkler sizin seçiminiz, ancak en az iki farklı renge ihtiyacınız var: biri arka plan için diğeri de kaos oyunu sırasında çizilen noktalar için. Giriş noktalarını çizmeniz gerekmeyebilir.

Lütfen cevabınıza üç ilginç örnek çıktı ekleyin.

puanlama

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Düzenleme: Zaten tek nokta olarak gerçekten görünmediklerinden giriş noktalarını çizmenize artık gerek yok.

Mathematica, 89

f[n_,s_,r_,p_]:=Graphics@{AbsolutePointSize@1,Point@NestList[#-r#+r RandomChoice@p&,s,n]}

f[10000, {0, 0}, .5, {{-(1/2), Sqrt[3]/2}, {-(1/2), -(Sqrt[3]/2)}, {1, 0}}]

Nasıl çalışır

Mathematica'da Graphics[]işlev ölçeklenebilir grafikler üretir, resim köşelerini sürükleyerek istediğiniz boyutta görüntülersiniz. Aslında, görüntülenen tüm grafiklerin başlangıç ​​boyutu 600 olarak veya istediğiniz herhangi bir değerde ayarlayabileceğiniz bir ".ini" ayarıdır. Dolayısıyla 600x600 gereksinimi için özel bir şey yapmaya gerek yoktur.

Önemli AbsolutePointSize[]olan nokta boyutunu, resim boyutunu büyüterek değiştirilmeyeceğini belirtir.

Çekirdek yapı

 NestList[#-r#+r RandomChoice@p&,s,n]

ya da golf oynamayan sahte kodda:

 NestList[(previous point)*(1-r) + (random vertex point)*(r), (start point), (iterations)]

Tekrar tekrar (start point), ilk argümandaki (vektörel) işlevden başlayarak ve uygulayan her bir ardışık noktaya bir liste hazırlar ve son olarak tarafından çizilen tüm hesaplanmış noktaların listesini döndürür.Point[]

Bazı kendi kendini çoğaltma örnekleri:

Grid@Partition[Table[
   pts = N@{Re@#, Im@#} & /@ Table[E^(2 I Pi r/n), {r, 0, n - 1}];
   Framed@f[10000, {0, 0}, 1/n^(1/n), pts], {n, 3, 11}], 3]

Java: 246 253 447

Bir fonksiyon olarak m():

void m(float[]a){new java.awt.Frame(){public void paint(java.awt.Graphics g){int i=0,x=i,y=i,v;for(setSize(832,864),x+=a[1],y+=a[2];i++<=a[0];v=a.length/2-2,v*=Math.random(),x+=(a[v+=v+4]-x)*a[3],y+=(a[v+1]-y)*a[3])g.drawLine(x,y,x,y);}}.show();}

Satır sonları (kullanımı göstermek için bir programın içinde):

class P{
    public static void main(String[]a){
        new P().m(new float[]{1000000,            // iterations
                              416,432,            // start
                              0.6f,               // r
                              416,32,16,432,      // point list...
                              416,832,816,432,
                              366,382,366,482,
                              466,382,466,482});
    }

    void m(float[]a){
        new java.awt.Frame(){
            public void paint(java.awt.Graphics g){
                int i=0,x=i,y=i,v;
                for(setSize(832,864),x+=a[1],y+=a[2];
                    i++<=a[0];
                    v=a.length/2-2,v*=Math.random(),
                    x+=(a[v+=v+4]-x)*a[3],
                    y+=(a[v+1]-y)*a[3])
                    g.drawLine(x,y,x,y);
            }
        }.show();
    }
}

Çizim giriş noktaları gereksinimlerden çıkarıldı (yay 80 bayt!). Hala aşağıdaki eski ekran görüntülerinde gösteriliyorlar, ancak çalıştırırsanız görünmeyecekler. İlgileniyorsanız revizyon geçmişine bakın.

Girişler bir dizi yüzer olarak verilir. İlk tekrarlar, sonraki iki başlıyor x y. Dördüncüsü, rson olarak da x1 y1 x2 y2 ...modada koordinatların listesi geliyor .

Ninja yıldızı

1000000 400 400 0.6 400 0 0 400 400 800 800 400 350 350 350 450 450 350 450 450

Çapraz

1000000 400 400 0.8 300 0 500 0 500 300 800 300 800 500 500 500 500 800 300 800 300 500 0 500 0 300 300 300

Octochains

1000000 400 400 0.75 200 0 600 0 800 200 800 600 600 800 200 800 0 600 0 200

JavaScript (E6) + Html 173 176 193

Düzenleme: büyük kesim, William Barbosa sayesinde

Düzenleme: 3 bayt daha az, DocMax sayesinde

173 bayt işlevi ve çıktıyı göstermek için gereken tuval öğesi sayıyor.

Html dosyası olarak kaydetme testi yapın ve FireFox'ta açın.

JSFiddle

<canvas id=C>
<script>
F=(n,x,y,r,p)=>{
  for(t=C.getContext("2d"),C.width=C.height=600;n--;x-=(x-p[i])*r,y-=(y-p[i+1])*r)
    i=Math.random(t.fillRect(x,y,1,1))*p.length&~1      
}
F(100000, 300, 300, 0.66, [100,500, 500,100, 500,500, 100,100, 300,150, 150,300, 300,450, 450,300]) // Function call, not counted
</script>

Python - 200 189

import os,random as v
def a(n,s,r,z):
    p=[255]*360000
    for i in[1]*(n+1):
        p[600*s[0]+s[1]]=0;k=v.choice(z);s=[int(k[i]*r+s[i]*(1-r))for i in(0,1)]
    os.write(1,b'P5 600 600 255 '+bytes(p))

Girdileri işlev argümanları olarak a alır, sonucu stdout'a pgm dosyası olarak yazar. nYinelemeler, sbaşlangıç ​​noktası, rr, zgiriş noktaları listesidir.

Düzenleme: Artık giriş noktalarını gri çizmez.

İlginç çıktılar:

Iterations: 100000
Starting Point: (200, 200)
r: 0.8
Points: [(0, 0), (0, 599), (599, 0), (599, 599), (300, 300)]

Iterations: 100000
Starting Point: (100, 300)
r: 0.6
Points: [(0, 0), (0, 599), (599, 0), (300, 0), (300, 300), (0, 300)]

Iterations: 100000
Starting Point: (450, 599)
r: 0.75
Points: [(0, 0), (0, 300), (0, 599), (300, 0), (599, 300), (150, 450)]

SüperAyarcı - 106

SuperCollider müzik üretmek için kullanılan bir dildir, ancak bir tutam grafikler yapabilir.

f={|n,p,r,l|Window().front.drawHook_({{Pen.addRect(Rect(x(p=l.choose*(1-r)+(p*r)),p.y,1,1))}!n;Pen.fill})}

Birkaç bayttan tasarruf etmek için bazı belirsiz sözdizimi kısayolları kullandım - daha okunaklı ve daha hafıza açısından verimli

f={|n,p,r,l|Window().front.drawHook_({n.do{Pen.addRect(Rect(p.x,p.y,1,1));p=l.choose*(1-r)+(p*r)};Pen.fill})}

109 karakterde.

Mathematica örneğinde olduğu gibi, 600x600 piksel elde etmek için pencereyi manuel olarak yeniden boyutlandırmanız gerekir. Bunu yaparken yeniden çizilmesi için beklemeniz gerekir.

Bu, temel bir Sierpinsky üçgeni oluşturur (daha önce gördüğünüz için gösterilmemiştir)

f.(20000,100@100,0.5,[0@600,600@600,300@0])

Bu bir çeşit Sierpinsky pentagon tipi şey yapar:

f.(100000,100@100,1-(2/(1+sqrt(5))),{|i| (sin(i*2pi/5)+1*300)@(1-cos(i*2pi/5)*300)}!5)

6 puanla aynı şey ortada ters bir Koch kar tanesini bırakır:

f.(100000,100@100,1/3,{|i| (sin(i*2pi/6)+1*300)@(1-cos(i*2pi/6)*300)}!6)

Son olarak, işte as'ın cevabından çıkan 3D piramitleri hakkında bir fikir. (Gölgelendirme efekti elde etmek için iki noktadan birini kullandığımı unutmayın.)

f.(150000,100@100,0.49,[300@180, 0@500,0@500,350@400,600@500,250@600])

Python, 189 183 175

Düzenleme: ters çevrilen r oranını düzeltti ve birkaç bayttan tasarruf etmek için S&B görüntüye geçti.

Nokta sayısını n, ilk puan p, oran olarak rve puan listesini alır l. Yastık modülüne ihtiyaç duyuyor.

import random,PIL.Image as I
s=850
def c(n,p,r,l):
    i=I.new('L',(s,s));x,y=p;
    for j in range(n):w,z=random.choice(l);w*=r;z*=r;x,y=x-x*r+w,y-y*r+z;i.load()[x,s-y]=s
    i.show()

Örnekler:

Resmin merkezi etrafındaki dairede noktalar oluşturuyorum

points = [(425+s*cos(a)/2, 425+s*sin(a)/2) for a in frange(.0, 2*pi, pi/2)]
c(1000000, (425, 425), 0.4, points)

XOXO tekrarları, oranı 0,4'ten 0,6'ya değiştiriyor

Bir çeşit kar tanesi

stars = [(425+s*cos(a)/2,425+s*sin(a)/2) for a in frange(.0,2*pi, pi/4)]
c(1000000, (425, 425), 0.6, stars)

JavaScript (407) (190)

JS ile rahat olmadığım için senaryom ve golf hakkında herhangi bir geri bildirim almaktan mutluyum =) (Bunu kullanmaktan çekinmeyin / kendi gönderiminiz için değiştirin!)

Okuma Girişi ( edc65'in girişiyle karşılaştırılabilir olması için girişi saymıyorum.):

p=prompt;n=p();[x,y]=p().split(',');r=p();l=p().split(';').map(e=>e.split(','));

Tuval Kurulumu ve Hesaplanması

d=document;d.body.appendChild(c=d.createElement('canvas'));c.width=c.height=1000;c=c.getContext('2d');
for(;n--;c.fillRect(x,y,2,2),[e,f]= l[Math.random()*l.length|0],x-=x*r-e*r,y-=y*r-f*r);

Biraz daha unungolfed (gerçek girdilerin henüz yorumlanmadığı bir örnek girdi dahil, kullanıma hazır)

p=prompt;
n=p('n','4000');
[x,y]=p('start','1,1').split(',');
r=p('r','0.5');
l=p('list','1,300;300,1;300,600;600,300').split(';').map(e=>e.split(','));d=document;
d.body.appendChild(c=d.createElement('canvas'));
c.width=c.height=1000;c=c.getContext('2d');
for(;n--;c.fillRect(x,y,2,2),[e,f]= l[Math.random()*l.length|0],x-=x*r-e*r,y-=y*r-f*r);

Örnekler

for(k = 0; k<50; k++){
rad = 10;
l.push([350+rad*k*Math.cos(6.28*k/10),350+rad*k*Math.sin(6.28*k/10)]);
}
r = 1.13;

r = 0.5;list = [[1,1],[300,522],[600,1],[300,177]];

r = 0.5
list = [[350+350*Math.sin(6.28*1/5),350+350*Math.cos(6.28*1/5)],
[350+350*Math.sin(6.28*2/5),350+350*Math.cos(6.28*2/5)],
[350+350*Math.sin(6.28*3/5),350+350*Math.cos(6.28*3/5)],
[350+350*Math.sin(6.28*4/5),350+350*Math.cos(6.28*4/5)],
[350+350*Math.sin(6.28*5/5),350+350*Math.cos(6.28*5/5)],


[350+90*Math.sin(6.28*1.5/5),350+90*Math.cos(6.28*1.5/5)],
[350+90*Math.sin(6.28*2.5/5),350+90*Math.cos(6.28*2.5/5)],
[350+90*Math.sin(6.28*3.5/5),350+90*Math.cos(6.28*3.5/5)],
[350+90*Math.sin(6.28*4.5/5),350+90*Math.cos(6.28*4.5/5)],
[350+90*Math.sin(6.28*5.5/5),350+90*Math.cos(6.28*5.5/5)]];

İşleme, 153

@Geobits'in Java'sı, Processing'e cevap verdi ve daha fazla golf oynadı, bu da 100 karaktere düştü. Başlangıçta süreci canlandırmak niyetindeyim, ancak giriş kısıtlamaları bu konuda çok zor (İşlemede stdin veya argv yok, bu da İşlemenin yerel draw()döngüsünü kullanmak yerine kendi işlevimi yazmam gerektiği anlamına geliyor ).

void d(float[]a){int v;size(600,600);for(float i=0,x=a[1],y=a[2];i++<a[0];v=(int)random(a.length/2-2),point(x+=(a[v*2+4]-x)*a[3],y+=(a[v*2+5]-y)*a[3]));}

Satır sonları ile komple program:

void setup() {
  d(new float[]{100000,300,300,.7,0,600,600,0,600,600,0,0,400,400,200,200,400,200,200,400}); 
}
void d(float[]a){
  int v;
  size(600,600);
  for(float i=0,x=a[1],y=a[2];
      i++<a[0];
      v=(int)random(a.length/2-2),point(x+=(a[v*2+4]-x)*a[3],y+=(a[v*2+5]-y)*a[3]));
}

Yukarıdaki programda Haçlar:

d(new float[]{100000,300,300,.65,142,257,112,358,256,512,216,36,547,234,180,360}); 

Bu Piramitler verir:

d(new float[]{100000,100,500,.5,100,300,500,100,500,500});

Bu Sierpinski üçgenini verir:

Ungolfed "referans uygulaması", Python

Güncelleme : çok, çok daha hızlı (büyüklük sırasına göre)

Etkileşimli kabuk göz atın!

Düzenleme dosyası ve set interactiveiçin True, daha sonra bunlardan birini yapın:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides bir çokgen oluşturur, kaydeder ve görüntüler.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... spec ne isterse onu yapar.

import matplotlib.pyplot as plt
import numpy as np
from fractions import Fraction as F
import random
from matplotlib.colors import ColorConverter
from time import sleep
import math
import sys
import cmd
import time

def plot_saved(n, r, start, points, filetype='png', barsize=30, dpi=100, poly=True, show=False):
    printed_len = 0

    plt.figure(figsize=(6,6))
    plt.axis('off')

    start_time = time.clock()
    f = F.from_float(r).limit_denominator()

    spts = []
    for i in range(len(points)):
        spts.append(tuple([round(points[i].real,1), round(points[i].imag,1)]))

    if poly:
        s = "{}-gon ({}, r = {}|{})".format(len(points), n, f.numerator, f.denominator)
    else:
        s = "{} ({}, r = {}|{})".format(spts, n, f.numerator, f.denominator) 

    step = math.floor(n / 50)

    for i in range(len(points)):
        plt.scatter(points[i].real, points[i].imag, color='#ff2222', s=50, alpha=0.7)

    point = start
    t = time.clock()

    xs = []
    ys = []

    for i in range(n+1):
        elapsed = time.clock() - t
        #Extrapolation
        eta = (n+1-i)*(elapsed/(i+1))
        printed_len = rewrite("{:>29}: {} of {} ({:.3f}%) ETA: {:.3f}s".format(
                s, i, n, i*100/n, eta), printed_len)
        xs.append(point.real)
        ys.append(point.imag)
        point = point * r + random.choice(points) * (1 - r)

    printed_len = rewrite("{:>29}: plotting...".format(s), printed_len)
    plt.scatter(xs, ys, s=0.5, marker=',', alpha=0.3)

    presave = time.clock()
    printed_len = rewrite("{:>29}: saving...".format(s), printed_len)
    plt.savefig(s + "." + filetype, bbox_inches='tight', dpi=dpi)

    postsave = time.clock()
    printed_len = rewrite("{:>29}: done in {:.3f}s (save took {:.3f}s)".format(
                            s, postsave - start_time, postsave - presave),
                            printed_len)

    if show:
        plt.show()
    print()
    plt.clf()

def rewrite(s, prev):
    spaces = prev - len(s)
    sys.stdout.write('\r')
    sys.stdout.write(s + ' '*(0 if spaces < 0 else spaces))
    sys.stdout.flush()
    return len(s)

class InteractiveChaosGame(cmd.Cmd):
    def do_polygon(self, args):
        (n, num, den, sx, sy, deg) = map(int, args.split())
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), list(np.roots([1] + [0]*(deg - 1) + [-1])), show=True)

    def do_points(self, args):
        l = list(map(int, args.split()))
        (n, num, den, sx, sy) = tuple(l[:5])
        l = l[5:]
        points = []
        for i in range(len(l)//2):
            points.append(complex(*tuple([l[2*i], l[2*i + 1]])))
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), points, poly=False, show=True)

    def do_pointsdpi(self, args):
        l = list(map(int, args.split()))
        (dpi, n, num, den, sx, sy) = tuple(l[:6])
        l = l[6:]
        points = []
        for i in range(len(l)//2):
            points.append(complex(*tuple([l[2*i], l[2*i + 1]])))
        plot_saved(n, (num + 0.0)/den, np.complex(sx, sy), points, poly=False, show=True, dpi=dpi)

    def do_default(self, args):
        do_generate(self, args)

    def do_EOF(self):
        return True

if __name__ == '__main__':
    interactive = False
    if interactive:
        i = InteractiveChaosGame()
        i.prompt = ": "
        i.completekey='tab'
        i.cmdloop()
    else:
        rs = [1/2, 1/3, 2/3, 3/8, 5/8, 5/6, 9/10]
        for i in range(3, 15):
            for r in rs:
                plot_saved(20000, r, np.complex(0,0), 
                            list(np.roots([1] + [0] * (i - 1) + [-1])), 
                            filetype='png', dpi=300)

Python (202 karakter)

nOrtalama puan , ortalama rbaşlangıç ağırlığı , a başlangıç ​​noktası tuple sve tuplearanan XY'lerin listesi olarak verilen noktaların sayısını alır l.

import random as v,matplotlib.pyplot as p
def t(n,r,s,l):
 q=complex;s=q(*s);l=[q(*i)for i in l];p.figure(figsize=(6,6))
 for i in range(n):p.scatter(s.real,s.imag,s=1,marker=',');s=s*r+v.choice(l)*(1-r)
 p.show()