O Chaos Game é um método simples para gerar fractais. Dado um ponto de partida, uma proporção de comprimento r e um conjunto de pontos 2D, faça o seguinte:

• No seu conjunto de pontos, escolha um aleatoriamente (uniformemente).
• Calcule a média desse ponto e o último ponto desenhado (ou o ponto inicial) usando r e 1 - r como pesos (ou seja, r = 0 significa que você obtém o ponto de partida, r = 1 significa que você obtém o ponto aleatório er = 0,5 significa que você entre no meio do caminho.)
• Desenhe o ponto resultante.

Por exemplo, se você escolher os vértices de um triângulo equilátero er = 0,5 , os pontos plotados mapearão um triângulo de Sierpinski:

^{Imagem encontrada na Wikipedia}

Você deve escrever um programa ou função que "reproduza" o jogo do caos para criar um fractal.

Entrada

Você pode escrever um programa ou uma função e receber as seguintes entradas via ARGV, STDIN ou argumento da função:

• O número de pontos a serem plotados.
• A coordenada inicial (que também deve ser plotada!).
• O peso médio r no intervalo [0,1] .
• Uma lista de pontos para escolher.

Saída

Você pode renderizar na tela ou gravar um arquivo de imagem. Se o resultado for rasterizado, ele precisará ter pelo menos 600 pixels de cada lado, todos os pontos deverão estar na tela e pelo menos 75% da extensão horizontal e vertical da imagem deverão ser usados ​​para pontos (isso é para evitar respostas com um único pixel preto dizendo "está muito longe"). O x e y eixo deve estar na mesma escala (que é a linha de (0,0) para (1,1) deve estar a um ângulo de 45 graus) e cada ponto representado no jogo caos deve ser representada como uma única pixel (se o seu método de plotagem suavizar o ponto, ele pode ser espalhado por 2x2 pixels).

As cores são a sua escolha, mas você precisa de pelo menos duas cores distinguíveis: uma para o fundo e outra para os pontos plotados durante o jogo do caos. Você pode, mas não precisa plotar os pontos de entrada.

Inclua três exemplos de resultados interessantes em sua resposta.

Pontuação

Isso é código de golfe, então a resposta mais curta (em bytes) vence.

Editar: você não precisa mais plotar os pontos de entrada, pois eles não são realmente visíveis como pixels únicos de qualquer maneira.

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

Como funciona

No Mathematica, a Graphics[]função produz gráficos escaláveis, você o renderiza para o tamanho que desejar, simplesmente arrastando os cantos da imagem. De fato, o tamanho inicial de todos os gráficos exibidos é uma configuração ".ini" que você pode definir em 600 ou em qualquer outro valor que desejar. Portanto, não há necessidade de fazer nada de especial para o requisito de 600x600.

A AbsolutePointSize[]coisa especifica que o tamanho do ponto não será modificado aumentando o tamanho da imagem.

A construção principal é

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

ou no pseudo-código não-golfe:

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

Ele está construindo recursivamente uma lista iniciando (start point)e aplicando a função (vetorial) no primeiro argumento a cada ponto sucessivo, retornando finalmente a lista de todos os pontos calculados a serem plotados porPoint[]

Alguns exemplos de auto-replicação:

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

Como uma função 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();}

Quebras de linha (dentro de um programa para mostrar o uso):

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

Os pontos de entrada de desenho foram removidos dos requisitos (yay 80 bytes!). Eles ainda são mostrados nas capturas de tela antigas abaixo, mas não aparecerão se você executá-la. Veja o histórico de revisões, se estiver interessado.

As entradas são fornecidas como uma matriz de flutuadores. A primeira é iterações, as próximas duas estão começando x y. O quarto é r, e por último, a lista de coordenadas, na x1 y1 x2 y2 ...moda.

Estrela ninja

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

Cruz

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 173176193

Edit: corte grande, graças a William Barbosa

Editar: 3 bytes a menos, graças ao DocMax

173 bytes contando a função e o elemento canvas necessário para mostrar a saída.

Teste salvar como arquivo html e abra no 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))

Leva a entrada como argumentos de função para a, grava o resultado em stdout como arquivo pgm. né iterações, sé ponto de partida, ré r e zé uma lista de pontos de entrada.

Editar: não desenha mais pontos de entrada em cinza.

Resultados interessantes:

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

O SuperCollider é um idioma para gerar música, mas pode fazer gráficos rapidamente.

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

Usei alguns atalhos de sintaxe obscuros para economizar alguns bytes - uma versão mais legível e mais eficiente de memória é

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

Como no exemplo do Mathematica, você deve redimensionar manualmente a janela para obter 600x600 pixels. Você precisa esperar que ele seja redesenhado novamente ao fazer isso.

Isso gera um triângulo básico de Sierpinsky (não mostrado porque você já viu isso antes)

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

Isso faz uma espécie de coisa do tipo pentágono de Sierpinsky:

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

A mesma coisa com 6 pontos deixa um floco de neve Koch invertido no meio:

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

Finalmente, aqui está um riff sobre as pirâmides 3D da resposta do ás. (Observe que eu usei um dos pontos duas vezes para obter o efeito de sombreamento.)

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

Python, 189 183 175

Editar: corrigiu a taxa de inversão de r e mudou para a imagem em preto e branco, a fim de economizar alguns bytes.

Toma o número de pontos como n, primeiro ponto como p, razão como re lista de pontos como l. Precisa do módulo Pillow.

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

Exemplos:

Estou gerando pontos em círculo ao redor do centro da imagem

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)

Repetições XOXO, apenas alterando a proporção de 0,4 para 0,6

Algum tipo de floco de 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)

Fico feliz em receber algum feedback sobre o meu script e sobre o golfe, pois não me sinto à vontade com o JS =).

Leitura de entrada (para ser comparável à entrada de edc65 , não conto a entrada.):

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

Configuração e cálculo do 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);

Um pouco mais desregrado (incluindo um exemplo de entrada em que os prompts de entrada reais são apenas comentados e prontos para 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);

Exemplos

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

Processamento, 153

Portou a resposta Java do @Geobits para o Processing e jogou mais golfe, resultando em uma redução de 100 caracteres. Originalmente, pretendia animar o processo, mas as restrições de entrada são muito duras com isso (o Processing não possui stdin ou argv, o que significa que devo escrever minha própria função em vez de usar o draw()loop nativo do 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]));}

Programa completo com quebras de linha:

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

O programa acima fornece Crosses:

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

Isso dá às pirâmides:

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

Isso dá o triângulo de Sierpinski:

"Implementação de referência" ungolfed, Python

Atualização : muito, muito mais rápida (por ordens de magnitude)

Confira o shell interativo!

Edite o arquivo e defina interactivecomo True, e siga um destes procedimentos:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides gera, salva e exibe um polígono.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... faz o que a especificação pede.

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

Toma o número de pontos como n, o peso médio como r, o ponto inicial como a tuple se a lista de pontos como uma lista dos XY tuples chamados 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()