カオスゲームはフラクタルを生成するための簡単な方法です。開始点、長さ比r、および2D点のセットを指定して、次の操作を繰り返し実行します。

• ポイントのセットから、ランダムに（均一に）選択します。
• rと1-rを重みとして使用して、そのポイントと最後に描かれたポイント（または開始ポイント）を平均します（つまり、r = 0は開始ポイントを取得し、r = 1はランダムポイントを取得し、r = 0.5はユーザーを意味します中間点を取得します。）
• 結果のポイントを描画します。

たとえば、正三角形の頂点を選択し、r = 0.5の場合、プロットされたポイントはシェルピンスキーの三角形をマッピングします。

^{ウィキペディアで見つかった画像}

カオスゲームを「再生」してフラクタルを作成するプログラムまたは関数を作成する必要があります。

入力

プログラムまたは関数のいずれかを作成し、ARGV、STDIN、または関数引数を介して次の入力を取得できます。

• プロットするポイントの数。
• 開始座標（プロットする必要もあります！）。
• 区間[0,1]の平均重みr。
• 選択するポイントのリスト。

出力

画面にレンダリングするか、画像ファイルを書き込むことができます。結果がラスタライズされる場合、各側に少なくとも600ピクセル、すべてのポイントがキャンバス上にあり、画像の水平および垂直範囲の少なくとも75％がポイントに使用されている必要があります（これは避けるためです「本当にズームアウトしている」と黒のピクセルで答えます）。X及びY軸は、同じ規模である必要があり（すなわち、0,0の（より線）である（1,1）45度の角度でなければならない）とカオスゲームにプロットの各点は、単一のように表現されなければなりませんピクセル（プロットメソッドがポイントをアンチエイリアスする場合、2x2ピクセルに広がる可能性があります）。

色は選択できますが、少なくとも2つの区別できる色が必要です。1つは背景用、もう1つはカオスゲーム中にプロットされるドット用です。入力ポイントをプロットする必要はありますが、する必要はありません。

回答に3つの興味深い出力例を含めてください。

得点

これはコードゴルフなので、最短の回答（バイト単位）が勝ちです。

編集：入力ポイントは実際には単一ピクセルとして表示されないため、入力ポイントをプロットする必要はなくなりました。

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

使い方

Mathematicaでは、このGraphics[]関数はスケーラブルなグラフィックスを生成します。画像の角をドラッグするだけで、好きなサイズにレンダリングできます。実際、表示されるすべてのグラフィックスの初期サイズは「.ini」設定であり、600または任意の他の値に設定できます。そのため、600x600の要件のために特別なことをする必要はありません。

このAbsolutePointSize[]ことは、画像サイズを拡大してもポイントサイズが変更されないことを指定しています。

コア構造は

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

または非ゴルフ擬似コードで：

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

それは再帰的にリストを構築(start point)し、最初の引数の（ベクトル）関数を連続する各ポイントに適用し、最終的にプロットされるすべての計算されたポイントのリストを返しますPoint[]

いくつかの自己複製の例：

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

機能として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();}

改行（使用法を表示するプログラム内）：

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

入力ポイントの描画が要件から削除されました（80バイトです！）。下の古いスクリーンショットにはまだ表示されていますが、実行しても表示されません。興味がある場合は、改訂履歴を参照してください。

入力は、floatの配列として与えられます。最初は反復で、次の2つは開始x yです。4番目はrで、最後にx1 y1 x2 y2 ...ファッションの座標リストがあります。

忍者スター

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

クロス

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

オクトチェーン

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

編集：ビッグカット、ウィリアム・バルボサのおかげ

編集：DocMaxのおかげで3バイト削減

出力を表示するために必要な関数とキャンバス要素をカウントする173バイト。

HTMLファイルとして保存をテストし、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))

入力を関数引数としてaに受け取り、結果をpgmファイルとしてstdoutに書き込みます。 nは反復、s開始点、rr、z入力点のリストです。

編集：入力ポイントを灰色で描画しなくなりました。

興味深い出力：

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

スーパーコライダー-106

SuperColliderは音楽を生成するための言語ですが、ピンチでグラフィックスを実行できます。

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

私はいくつかのあいまいな構文ショートカットを使用して数バイトを保存しました-より読みやすく、よりメモリ効率の良いバージョンは

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文字で。

Mathematicaの例と同様に、600x600ピクセルを取得するにはウィンドウを手動でサイズ変更する必要があります。これを行うと、再描画するのを待つ必要があります。

これにより、基本的なシェルピンスキーの三角形が生成されます（以前に見たことがないため表示されていません）

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

これにより、一種のシェルピンスキー五角形タイプのものが作成されます。

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

6点の同じものでは、真ん中に逆コッホ雪片が残ります。

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

最後に、エースの答えからの3Dピラミッドのリフです。（シェーディング効果を得るために、ポイントの1つを2回使用したことに注意してください。）

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

Pythonの、189 183 175

編集：逆r比を修正し、数バイトを節約するために白黒画像に切り替えました。

ポイントの数としてn、最初のポイントとしてp、比率としてrおよびポイントのリストとしてl。モジュールの枕が必要です。

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

例：

画像の中心の周りに円でポイントを生成しています

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の繰り返し、比率を0.4から0.6に変更するだけ

ある種の雪の結晶

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 =に慣れていないので、スクリプトとゴルフについてのフィードバックを喜んで受け取ります（これを自由に使用したり、自分の提出のために変更してください！）

入力の読み取り （edc65のエントリと比較するために、入力をカウントしません。）：

p=prompt;n=p();[x,y]=p().split(',');r=p();l=p().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);

もう少し自由（実際の入力プロンプトがコメントアウトされているため、すぐに使用できる入力例を含む）：

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

例

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

処理中、153

Processingへの@GeobitsのJavaの回答を移植し、さらにゴルフをしました。その結果、100文字削減されました。私はもともとプロセスをアニメーション化するつもりでしたが、これに対する入力制約が厳しすぎます（Processingにはstdinやargvがないため、Processingのネイティブdraw()ループを使用する代わりに独自の関数を記述する必要があります）。

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

改行を含む完全なプログラム：

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

上記のプログラムは、クロスを提供します：

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

これにより、ピラミッドが得られます。

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

これにより、シェルピンスキーの三角形が得られます。

Ungolfed「リファレンス実装」、Python

更新：はるかに高速（桁違い）

インタラクティブシェルをご覧ください！

ファイルを編集してに設定interactiveしTrue、次のいずれかを実行します。

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides ポリゴンを生成、保存、表示します。

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... 仕様が要求することを行います。

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文字）

としてのポイント数n、平均としての重みr、aとしての開始点、tuple sおよびXY tupleのリストとしてのポイントのリストを呼び出し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()