Il gioco del caos è un metodo semplice per generare frattali. Dato un punto di partenza, un rapporto di lunghezza re una serie di punti 2D, eseguire ripetutamente le seguenti operazioni:

• Dal tuo set di punti, scegline uno a caso (uniformemente).
• Media quel punto e l'ultimo punto disegnato (o il punto iniziale) usando r e 1 - r come i pesi (cioè r = 0 significa che ottieni il punto iniziale, r = 1 significa che ottieni il punto casuale e r = 0,5 significa che ottenere il punto a metà strada.)
• Disegna il punto risultante.

Ad esempio, se si selezionassero i vertici di un triangolo equilatero e r = 0,5 , i punti tracciati mapperebbero un triangolo di Sierpinski:

^{Immagine trovata su Wikipedia}

Devi scrivere un programma o una funzione che "gioca" al gioco del caos per creare un frattale.

Ingresso

È possibile scrivere un programma o una funzione e accettare i seguenti input tramite ARGV, STDIN o argomento della funzione:

• Il numero di punti da tracciare.
• La coordinata iniziale (che deve anche essere tracciata!).
• Il peso medio r nell'intervallo [0,1] .
• Un elenco di punti tra cui scegliere.

Produzione

È possibile eseguire il rendering sullo schermo o scrivere un file di immagine. Se il risultato è rasterizzato, deve essere di almeno 600 pixel su ciascun lato, tutti i punti devono essere sulla tela e almeno i punti 75% dell'estensione orizzontale e verticale dell'immagine devono essere usati per i punti (questo per evitare risponde con un singolo pixel nero dicendo "è veramente molto ingrandito"). Il x ed y asse devono essere sulla stessa scala (cioè la linea da (0,0) a (1,1) deve essere ad un angolo di 45 gradi) e ciascun punto tracciato del gioco caos deve essere rappresentato come una singola pixel (se il tuo metodo di stampa anti-alias del punto, può essere distribuito su 2x2 pixel).

I colori sono la tua scelta, ma hai bisogno di almeno due colori distinguibili: uno per lo sfondo e uno per i punti tracciati durante il gioco del caos. Potrebbe non essere necessario tracciare i punti di input.

Includi tre interessanti esempi di output nella tua risposta.

punteggio

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

Modifica: non è più necessario tracciare i punti di input, poiché non sono comunque realmente visibili come singoli pixel.

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

Come funziona

In Mathematica la Graphics[]funzione produce grafica scalabile, la rendi a qualsiasi dimensione desideri semplicemente trascinando gli angoli dell'immagine. In effetti, la dimensione iniziale di tutta la grafica visualizzata è un'impostazione ".ini" che è possibile impostare su 600 o su qualsiasi altro valore desiderato. Quindi non è necessario fare nulla di speciale per il requisito 600x600.

La AbsolutePointSize[]cosa specifica che la dimensione del punto non verrà modificata allargando la dimensione dell'immagine.

Il costrutto principale è

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

o in pseudo-codice non golfato:

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

Sta ricorsivamente costruendo un elenco a partire da (start point)e applicando la funzione (vettoriale) nel primo argomento a ciascun punto successivo, restituendo infine l'elenco di tutti i punti calcolati che devono essere tracciati daPoint[]

Alcuni esempi di auto-replica:

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: 246253 447

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

Interruzioni di riga (all'interno di un programma per mostrare l'utilizzo):

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

Il disegno dei punti di input è stato rimosso dai requisiti (yay 80 byte!). Sono ancora mostrati nei vecchi screenshot qui sotto, ma non verranno visualizzati se lo esegui. Vedi la cronologia delle revisioni se interessati.

Gli input sono dati come una matrice di float. Il primo sono le iterazioni, i prossimi due stanno iniziando x y. Il quarto è r, e ultimo arriva l'elenco delle coordinate, nella x1 y1 x2 y2 ...moda.

Stella Ninja

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

Attraversare

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

Modifica: grande taglio, grazie a William Barbosa

Modifica: 3 byte in meno, grazie a DocMax

173 byte contando la funzione e l'elemento canvas necessari per mostrare l'output.

Prova salva come file html e apri in 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))

Accetta input come argomenti di funzione in a, scrive il risultato su stdout come file pgm. nè iterazioni, sè punto di partenza, rè r ed zè un elenco di punti di input.

Modifica: non disegna più punti di input in grigio.

Risultati interessanti:

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 è un linguaggio per generare musica, ma può fare la grafica in un attimo.

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

Ho usato alcune scorciatoie di sintassi oscure per salvare alcuni byte - una versione più leggibile e più efficiente della memoria è

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

a 109 caratteri.

Come nell'esempio di Mathematica, devi ridimensionare manualmente la finestra per ottenere 600x600 pixel. Devi aspettare che si ridisegni quando lo fai.

Questo genera un triangolo Sierpinsky di base (non mostrato perché l'hai visto prima)

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

Questo fa una specie di cosa tipo pentagono di Sierpinsky:

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

La stessa cosa con 6 punti lascia un fiocco di neve Koch rovesciato nel mezzo:

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

Infine, ecco un riff sulle piramidi 3D dalla risposta dell'asso. (Nota che ho usato due volte uno dei punti per ottenere l'effetto di ombreggiatura.)

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

Python, 189 183 175

Modifica: risolto il rapporto r invertito e passato all'immagine in bianco e nero per risparmiare qualche byte.

Prende il numero di punti come n, primo punto come p, rapporto come red elenco di punti come l. Ha bisogno del modulo Cuscino.

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

Esempi:

Sto generando punti in cerchio attorno al centro dell'immagine

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)

Ripetizioni XOXO, cambiando solo il rapporto da 0,4 a 0,6

Una specie di fiocco di neve

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)

Sono felice di ricevere feedback sulla mia sceneggiatura e sul golf poiché non mi sento a mio agio con JS =) (Sentiti libero di usare questo / cambiarlo per la tua presentazione!)

Lettura input (per essere paragonabile alla voce di edc65 non conto l'input.):

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

Impostazione e calcolo dell'area di disegno

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

Un po 'più ungolfed (incluso un input di esempio in cui i promessi di input reali sono appena commentati, quindi pronti per l'uso):

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

Esempi

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

Elaborazione, 153

La risposta Java di @Geobits a Elaborazione è stata elaborata e ha continuato a giocare a golf, con una riduzione di 100 caratteri. Inizialmente intendevo animare il processo, ma i vincoli di input sono troppo severi su questo (Elaborazione non ha stdin o argv, il che significa che devo scrivere la mia funzione invece di usare il draw()ciclo nativo di Processing ).

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

Programma completo con interruzioni di riga:

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

Il programma sopra mostra le croci:

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

Questo dà a Pyramids:

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

Questo dà il triangolo Sierpinski:

"Implementazione di riferimento" non modificata, Python

Aggiornamento : molto, molto più veloce (per ordini di grandezza)

Dai un'occhiata alla shell interattiva!

Modifica il file e imposta interactivesu True, quindi esegui una di queste operazioni:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides genera, salva e visualizza un poligono.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... fa quello che le specifiche richiedono.

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

Prende il numero di punti come n, il peso medio come r, il punto iniziale come a tuple se l'elenco dei punti come un elenco di XY tuplechiamati 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()