The Chaos Game adalah metode sederhana untuk menghasilkan fraktal. Diberi titik awal, rasio panjang r dan satu set titik 2D, berulang kali lakukan hal berikut:

• Dari kumpulan poin Anda, pilih satu secara acak (seragam).
• Rata-rata titik itu dan titik yang ditarik terakhir (atau titik awal) menggunakan r dan 1 - r sebagai bobot (yaitu r = 0 berarti Anda mendapatkan titik awal, r = 1 berarti Anda mendapatkan titik acak dan r = 0,5 berarti Anda dapatkan titik di tengah-tengahnya.)
• Gambarkan titik yang dihasilkan.

Misalnya, jika Anda memilih simpul segitiga sama sisi dan r = 0,5 , titik yang diplot akan memetakan segitiga Sierpinski:

^{Gambar ditemukan di Wikipedia}

Anda harus menulis sebuah program atau fungsi yang "memainkan" permainan kekacauan untuk membuat fraktal.

Memasukkan

Anda dapat menulis suatu program atau fungsi, dan mengambil input berikut melalui ARGV, STDIN atau argumen fungsi:

• Jumlah poin untuk plot.
• Koordinat awal (yang harus diplot juga!).
• Berat rata-rata r dalam interval [0,1] .
• Daftar poin untuk dipilih.

Keluaran

Anda dapat menampilkan di layar atau menulis file gambar. Jika hasilnya dirasterisasi, harus setidaknya 600 piksel di setiap sisi, semua titik harus ada di kanvas, dan setidaknya 75% dari batas horizontal dan vertikal gambar harus digunakan untuk titik (ini untuk menghindari menjawab dengan satu piksel hitam yang mengatakan "sangat jauh diperbesar"). The x dan y axis harus pada skala yang sama (yang adalah garis dari (0,0) ke (1,1) harus berada pada sudut 45 derajat) dan setiap titik diplot pada game kekacauan harus diwakili sebagai tunggal pixel (jika metode plotting Anda anti-alias maksudnya, itu mungkin tersebar lebih dari 2x2 piksel).

Warna adalah pilihan Anda, tetapi Anda membutuhkan setidaknya dua warna yang dapat dibedakan: satu untuk latar belakang dan satu untuk titik-titik yang diplot selama permainan kekacauan. Anda mungkin tetapi tidak harus memplot poin input.

Harap sertakan tiga contoh output menarik dalam jawaban Anda.

Mencetak gol

Ini kode golf, jadi jawaban tersingkat (dalam byte) menang.

Sunting: Anda tidak perlu lagi memplot poin input, karena mereka sebenarnya tidak terlihat sebagai piksel tunggal.

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

Bagaimana itu bekerja

Dalam Mathematica, Graphics[]fungsi ini menghasilkan grafik yang dapat diskalakan, Anda merendernya ke ukuran apa pun yang Anda inginkan hanya dengan menyeret sudut gambar. Bahkan, ukuran awal dari semua grafik yang ditampilkan adalah pengaturan ".ini" yang dapat Anda atur pada 600 atau pada nilai lain yang Anda inginkan. Jadi tidak perlu melakukan sesuatu yang khusus untuk persyaratan 600x600.

The AbsolutePointSize[]hal menentukan bahwa ukuran titik tidak akan diubah dengan memperbesar ukuran gambar.

Konstruk intinya adalah

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

atau dalam pseudo-code non-golf:

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

Secara rekursif membangun daftar mulai dari (start point)dan menerapkan fungsi (vectorial) dalam argumen pertama ke setiap titik berturut-turut, akhirnya mengembalikan daftar semua poin yang dihitung untuk diplot olehPoint[]

Beberapa contoh replikasi diri:

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]

Jawa: 246 253 447

Sebagai fungsi 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();}

Jeda baris (dalam program untuk menunjukkan penggunaan):

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

Menggambar titik input dihapus dari persyaratan (yay 80 byte!). Mereka masih ditampilkan di tangkapan layar lama di bawah, tetapi tidak akan muncul jika Anda menjalankannya. Lihat riwayat revisi jika tertarik.

Input diberikan sebagai array float. Yang pertama adalah iterasi, dua berikutnya dimulai x y. Keempat r, dan terakhir adalah daftar koordinat, dalam x1 y1 x2 y2 ...mode.

Ninja Star

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

Menyeberang

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

Gurita

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

Sunting: potongan besar, terima kasih kepada William Barbosa

Sunting: 3 byte lebih sedikit, terima kasih kepada DocMax

173 byte menghitung fungsi dan elemen kanvas yang diperlukan untuk menampilkan output.

Tes simpan sebagai file html dan buka di FireFox.

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

Mengambil input sebagai argumen fungsi ke a, menulis hasilnya ke stdout sebagai file pgm. nadalah iterasi, sadalah titik awal, rr, dan zdaftar poin input.

Sunting: Tidak lagi menggambar titik input berwarna abu-abu.

Output menarik:

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

SuperCollider - 106

SuperCollider adalah bahasa untuk menghasilkan musik, tetapi dapat melakukan grafik dengan cepat.

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

Saya telah menggunakan beberapa cara pintas sintaksis yang tidak jelas untuk menghemat beberapa byte - versi yang lebih mudah dibaca dan lebih hemat memori adalah

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

pada 109 karakter.

Seperti contoh Mathematica, Anda harus mengubah ukuran jendela secara manual untuk mendapatkan 600x600 piksel. Anda harus menunggu sampai menggambar ulang ketika Anda melakukan ini.

Ini menghasilkan segitiga Sierpinsky dasar (tidak ditampilkan karena Anda pernah melihatnya sebelumnya)

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

Ini membuat semacam jenis pentagon Sierpinsky:

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

Hal yang sama dengan 6 poin membuat kepingan salju Koch terbalik di tengah:

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

Akhirnya, inilah riff pada piramida 3D dari jawaban ace. (Perhatikan bahwa saya telah menggunakan salah satu poin dua kali, untuk mendapatkan efek bayangan.)

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

Python, 189 183 175

Sunting: memperbaiki rasio r terbalik , dan beralih ke gambar B&W untuk menghemat beberapa byte.

Membawa jumlah poin sebagai n, poin pertama sebagai p, rasio sebagai rdan daftar poin sebagai l. Membutuhkan modul Bantal.

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

Contoh:

Saya menghasilkan titik dalam lingkaran di sekitar pusat gambar

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)

Pengulangan XOXO, hanya mengubah rasio dari 0,4 menjadi 0,6

Semacam serpihan salju

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)

Saya senang mendapatkan umpan balik tentang skrip saya dan golf karena saya tidak nyaman dengan JS =) (Jangan ragu untuk menggunakan ini / ubah untuk kiriman Anda sendiri!)

Input Input (Agar dapat dibandingkan dengan entri edc65 , saya tidak menghitung input.):

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

Pengaturan & Perhitungan Kanvas

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

Agak lebih ungolfed (termasuk input contoh di mana input nyata dijanjikan hanya dikomentari, jadi siap digunakan):

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

Contohnya

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

Memproses, 153

Ported @Geobits 'Java menjawab untuk Memproses dan melakukan lebih banyak bermain golf, menghasilkan pengurangan 100 karakter. Saya awalnya bermaksud untuk menghidupkan proses, tetapi batasan input terlalu keras pada ini (Pemrosesan tidak memiliki stdin atau argv, yang berarti bahwa saya harus menulis fungsi saya sendiri daripada menggunakan draw()loop asli Pemrosesan ).

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

Program lengkap dengan jeda baris:

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

Program di atas memberikan Crosses:

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

Ini memberi Piramida:

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

Ini memberikan segitiga Sierpinski:

"Implementasi referensi" yang tidak disatukan, Python

Pembaruan : jauh, jauh lebih cepat (atas perintah besarnya)

Lihatlah shell interaktif!

Edit file dan set interactiveke True, lalu lakukan salah satu dari ini:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides menghasilkan, menyimpan, dan menampilkan poligon.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... melakukan apa yang diminta oleh spec.

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)

Mengambil jumlah poin sebagai n, berat rata-rata sebagai r, titik awal sebagai tuple sdan daftar poin sebagai daftar XY tupledisebut 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()