Các Chaos Game là một phương pháp đơn giản để tạo ra Fractals. Cho điểm bắt đầu, tỷ lệ chiều dài r và tập hợp các điểm 2D, lặp đi lặp lại như sau:

• Từ tập hợp các điểm của bạn, chọn một điểm ngẫu nhiên (thống nhất).
• Trung bình điểm đó và điểm được vẽ cuối cùng (hoặc điểm bắt đầu) sử dụng r và 1 - r làm trọng số (nghĩa là r = 0 có nghĩa là bạn có điểm bắt đầu, r = 1 có nghĩa là bạn có điểm ngẫu nhiên và r = 0,5 có nghĩa là bạn lấy điểm giữa chừng.)
• Vẽ điểm kết quả.

Chẳng hạn, nếu bạn chọn các đỉnh của một tam giác đều và r = 0,5 , các điểm được vẽ sẽ vạch ra một tam giác Sierpinki:

^{Hình ảnh được tìm thấy trên Wikipedia}

Bạn sẽ viết một chương trình hoặc chức năng "chơi" trò chơi hỗn loạn để tạo ra một fractal.

Đầu vào

Bạn có thể viết chương trình hoặc hàm và lấy các đầu vào sau thông qua ARGV, STDIN hoặc đối số hàm:

• Số lượng điểm để âm mưu.
• Tọa độ bắt đầu (cũng phải được vẽ!).
• Trọng lượng trung bình r trong khoảng [0,1] .
• Một danh sách các điểm để lựa chọn.

Đầu ra

Bạn có thể kết xuất trên màn hình hoặc viết một tập tin hình ảnh. Nếu kết quả được rasterized, nó cần có ít nhất 600 pixel cho mỗi bên, tất cả các điểm phải nằm trên khung vẽ và ít nhất 75% mức độ ngang và dọc của hình ảnh phải được sử dụng cho các điểm (điều này là để tránh câu trả lời với một pixel đen duy nhất có nội dung "nó thực sự bị thu nhỏ"). Các x và y trục phải nằm trên cùng một tỷ lệ (có nghĩa là dòng từ (0,0) đến (1,1) phải ở một góc 45 độ) và mỗi điểm vẽ trong các trò chơi hỗn loạn phải được thể hiện dưới dạng một đĩa đơn pixel (nếu phương pháp vẽ biểu đồ của bạn chống lại bí danh điểm, nó có thể được trải trên 2x2 pixel).

Màu sắc là lựa chọn của bạn, nhưng bạn cần ít nhất hai màu có thể phân biệt: một cho nền và một cho các chấm được vẽ trong trò chơi hỗn loạn. Bạn có thể nhưng không phải vẽ các điểm đầu vào.

Vui lòng bao gồm ba kết quả đầu ra thú vị trong câu trả lời của bạn.

Chấm điểm

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Chỉnh sửa: Bạn không còn cần phải vẽ các điểm đầu vào, vì dù sao chúng không thực sự hiển thị dưới dạng các pixel đơn lẻ.

Toán học, 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}}]

Làm thế nào nó hoạt động

Trong Mathematica, Graphics[]hàm tạo ra đồ họa có thể mở rộng, bạn kết xuất nó tới bất kỳ kích thước nào bạn muốn bằng cách kéo các góc hình ảnh. Trên thực tế, kích thước ban đầu của tất cả đồ họa được hiển thị là cài đặt ".ini" mà bạn có thể đặt ở mức 600 hoặc ở bất kỳ giá trị nào khác bạn muốn. Vì vậy, không cần phải làm gì đặc biệt cho yêu cầu 600x600.

Các AbsolutePointSize[]điều quy định rằng kích thước điểm sẽ không được sửa đổi bằng cách mở rộng kích thước hình ảnh.

Cấu trúc cốt lõi là

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

hoặc trong mã giả không chơi gôn:

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

Nó đang đệ quy xây dựng một danh sách bắt đầu từ (start point)và áp dụng hàm (vectơ) trong đối số đầu tiên cho mỗi điểm liên tiếp, cuối cùng trả về danh sách tất cả các điểm được tính toán được vẽ bởiPoint[]

Một số ví dụ tự sao chép:

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

Là một chức năng 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();}

Ngắt dòng (trong một chương trình để hiển thị việc sử dụng):

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

Vẽ các điểm đầu vào đã bị xóa khỏi các yêu cầu (yay 80 byte!). Chúng vẫn được hiển thị trong các ảnh chụp màn hình cũ bên dưới, nhưng sẽ không hiển thị nếu bạn chạy nó. Xem lịch sử sửa đổi nếu quan tâm.

Các đầu vào được đưa ra như một mảng của phao. Đầu tiên là lặp lại, hai tiếp theo đang bắt đầu x y. Thứ tư là r, và cuối cùng là danh sách tọa độ, trong x1 y1 x2 y2 ...thời trang.

Ngôi sao ninja

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

Vượt qua

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

Chỉnh sửa: cắt giảm lớn, nhờ William Barbosa

Chỉnh sửa: 3 byte ít hơn, nhờ có DocMax

173 byte đếm hàm và phần tử canvas cần thiết để hiển thị đầu ra.

Kiểm tra lưu dưới dạng tệp html và mở trong FireFox.

Câu đố

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

Con trăn - 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))

Đưa đầu vào dưới dạng đối số hàm vào a, ghi kết quả vào thiết bị xuất chuẩn dưới dạng tệp pgm. nlà các lần lặp, slà điểm bắt đầu, rlà r và zlà danh sách các điểm đầu vào.

Chỉnh sửa: Không còn vẽ các điểm đầu vào màu xám.

Kết quả thú vị:

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

Siêu xe - 106

SuperCollider là một ngôn ngữ để tạo nhạc, nhưng nó có thể làm đồ họa ở một mức độ khó khăn.

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

Tôi đã sử dụng một số phím tắt cú pháp tối nghĩa để lưu một vài byte - phiên bản dễ đọc hơn và hiệu quả hơn về bộ nhớ là

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 ký tự.

Như với ví dụ Mathicala, bạn phải thay đổi kích thước cửa sổ theo cách thủ công để có được 600x600 pixel. Bạn phải đợi nó vẽ lại khi bạn làm điều này.

Điều này tạo ra một tam giác Sierpinky cơ bản (không hiển thị vì bạn đã thấy nó trước đó)

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

Điều này làm cho một loại điều hình ngũ giác Sierpinky:

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

Điều tương tự với 6 điểm để lại một bông tuyết Koch đảo ngược ở giữa:

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

Cuối cùng, đây là một đoạn ngắn trên các kim tự tháp 3D từ câu trả lời của ace. (Lưu ý rằng tôi đã sử dụng một trong hai điểm để có hiệu ứng đổ bóng.)

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

Con trăn, 189 183 175

Chỉnh sửa: đã sửa tỷ lệ r đảo ngược và chuyển sang hình ảnh B & W để lưu một vài byte.

Lấy số điểm như n, điểm đầu tiên p, tỷ lệ rvà danh sách các điểm như l. Cần gối mô-đun.

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

Ví dụ:

Tôi đang tạo các điểm trong vòng tròn xung quanh trung tâm của hình ảnh

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 lặp lại, chỉ thay đổi tỷ lệ từ 0,4 đến 0,6

Một số loại tuyết

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)

Tôi rất vui khi nhận được bất kỳ phản hồi nào về kịch bản của tôi và về việc chơi golf vì tôi không thoải mái với JS =) (Hãy sử dụng / thay đổi nó để gửi bài của riêng bạn!)

Đọc đầu vào (Để có thể so sánh với mục nhập của edc65 tôi không tính đầu vào.):

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

Cài đặt & Tính toán Canvas

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

Một phần nào đó chưa được chỉnh sửa (bao gồm cả một ví dụ đầu vào trong đó các quảng cáo đầu vào thực sự chỉ được nhận xét, vì vậy đã sẵn sàng để sử dụng):

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

Ví dụ

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

Chế biến, 153

Đã trả lời câu trả lời Java của @Geobits cho Xử lý và đã chơi gôn nhiều hơn, dẫn đến giảm 100 ký tự. Ban đầu tôi dự định làm động quá trình, nhưng các ràng buộc đầu vào quá khắc nghiệt đối với điều này (Xử lý không có stdin hoặc argv, điều đó có nghĩa là tôi phải viết hàm riêng của mình thay vì sử dụng draw()vòng lặp riêng của Xử lý ).

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

Hoàn thành chương trình với ngắt dòng:

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

Chương trình trên cho Crosses:

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

Điều này mang lại cho Kim tự tháp:

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

Điều này mang lại cho tam giác Sierpinki:

"Thực hiện tham chiếu", Python

Cập nhật : nhiều, nhanh hơn nhiều (theo đơn đặt hàng cường độ)

Kiểm tra vỏ tương tác!

Chỉnh sửa tệp và đặt interactivethành True, sau đó thực hiện một trong các thao tác sau:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides tạo, lưu và hiển thị một đa giác.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... làm những gì các spec yêu cầu.

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 ký tự)

Lấy số điểm là n, trọng số trung bình là r, điểm bắt đầu là a tuple svà danh sách các điểm dưới dạng danh sách các XY tupleđược gọi 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()