Jogue o jogo Caos

28

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:

insira a descrição da imagem aqui

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.

Martin Ender
fonte
O que significa " cada ponto plotado ... deve ser representado como um único pixel "? É a) que nenhum anti-aliasing deve ser usado; ou b) que o número de pontos na segunda cor deve ser igual ao primeiro item da entrada? Observe que b) é impossível garantir, a menos que o procedimento de iteração tenha um teste para "Esse pixel coincide com um plotado anteriormente?", Porque se o seletor de números aleatórios seleciona o mesmo ponto vezes suficientes em uma linha, a posição converge para esse ponto.
Peter Taylor
@PeterTaylor O objetivo era evitar que as pessoas desenhassem pontos grandes como os pontos (como o Mathematica faz por padrão), mas eu já notei que o anti-aliasing causa alguns problemas ao garantir pixels únicos na resposta de Soham. Acho que vou relaxar isso para "não deve ser maior que 2x2 pixels", o que deve cobrir todos os problemas de suavização de serrilhado.
Martin Ender
Acho que não entendi uma coisa: você sempre considera a "média" do último ponto que você plotou e um ponto aleatório da lista atual. Em seguida, você adiciona esse novo ponto à lista. Isso está correto? Parece que se você tiver muitos pontos em um 'canto', terá muito mais, mas é improvável que saia dessa nuvem - pelo menos meu código sempre 'converge' muito rapidamente em pontos muito próximos um do outro realmente melhorar a imagem.
flawr
1
@ flawr não, você não adiciona o novo ponto à lista. A lista é fixa - o algoritmo se importa apenas com o último ponto que foi plotado, não com os anteriores.
27414 Nathaniel
Obrigado, isso explica muito, talvez deva ser esclarecido na pergunta.
flawr

Respostas:

8

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

Gráficos do Mathematica

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]

Gráficos do Mathematica

Dr. belisarius
fonte
@ MartinBüttner Instructions for testing this answer without Mathematica installed:1) Faça o download do pastebin e salve-o como * .CDF 2) Faça o download e instale o ambiente CDF gratuito da Wolfram Research em (não é um arquivo pequeno). Apreciar. Diga-me se funciona!
Dr. belisarius
Sua versão golfed não funciona muito bem (pelo menos no V10): você precisa mudar em torno #rde r#fugir sem um espaço ou *no meio.
Martin Ender
@ MartinBüttner Curioso! Funciona como um encanto na v9 (ainda não tenho a v10). Enfim, eu (cegamente) troquei o #e r.
Dr. belisarius
Ah, é um novo recurso. Agora você pode aplicar funções a associações; nesse caso, você obtém parâmetros nomeados que podem ser acessados #key. Tenho certeza que isso será útil. :)
Martin Ender
8

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

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

Octochains

1000000 400 400 0.75 200 0 600 0 800 200 800 600 600 800 200 800 0 600 0 200

insira a descrição da imagem aqui

Geobits
fonte
este trabalho does't no meu computador, e java queixas showé obsoleto
haskeller orgulhoso
O @proudhaskeller show() está obsoleto, mas ainda funciona. Quando você diz "não funciona", o que isso significa? Se você não possui o Java 8, será necessário adicionar um finalao String[]aprincipal.
Geobits
Portou sua resposta para Processing e cortou 100 caracteres.
user12205
1
@ace Nice. Você pode fazer isso com praticamente qualquer golfe Java para saída gráfica, mas eu gosto que sejam exatamente 100 caracteres: D
Geobits
7

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

agradável


mascarar


Neve


Tapete


<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>
edc65
fonte
1
<canvas id=C><script>F=(n,x,y,r,p)=>{t=C.getContext("2d"),C.width=C.height=600;for(;n--;)t.fillRect(x,y,1,1),i=Math.random()*p.length&~1,x-=(x-p[i])*r,y-=(y-p[i+1])*r}</script>é de 176 bytes de comprimento, eu não entendi sua contagem
William Barbosa
@WilliamBarbosa minha contagem está certa com base na minha resposta. Com suas dicas, fica melhor - obrigado!
Edc65 26/09/14
1
Você pode economizar mais dois se mover a inicialização do tamanho e atualizar para a forchamada:for(C.width=C.height=600;n--;y-=(y-p[i+1])*r)
DocMax 27/14
6

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:

insira a descrição da imagem aqui

Iterations: 100000
Starting Point: (200, 200)
r: 0.8
Points: [(0, 0), (0, 599), (599, 0), (599, 599), (300, 300)]

insira a descrição da imagem aqui

Iterations: 100000
Starting Point: (100, 300)
r: 0.6
Points: [(0, 0), (0, 599), (599, 0), (300, 0), (300, 300), (0, 300)]

insira a descrição da imagem aqui

Iterations: 100000
Starting Point: (450, 599)
r: 0.75
Points: [(0, 0), (0, 300), (0, 599), (300, 0), (599, 300), (150, 450)]
faubi
fonte
Alguns caracteres comuns do Python salvam: Valores iniciais como p=[255]*360000podem ser parâmetros opcionais para a função; o corpo de um loop for pode continuar na mesma linha se não tiver fluxo de controle; você pode raspar parênteses de [1]*(n+1)como [1]*-~n; como você não usa ino loop for externo, é mais curto executar o código as nvezes que exec"code;"*n); Eu acho que os parênteses for i in(0,1)podem ser removidos.
Xnor
6

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)

insira a descrição da imagem aqui

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)

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

Nathaniel
fonte
6

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)

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

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)

insira a descrição da imagem aqui

as internets são feitas de catz
fonte
Dunno sobre a fixação dos trás r coisa, mas você pode economizar muito poucos caracteres, tornando este um programa usando n,p,r,l=input(). Você também pode remover os colchetes das *=operações e usar import random as R.
FryAmTheEggman 26/09/14
@FryAmTheEggman Infelizmente, corrigir minha resposta invalida a otimização em *=:(. inputSeria bom ser muito desagradável de se trabalhar, e a importação atualmente é a forma mais concisa possível (ou eu perdi alguma coisa?).
internets são feitos de catz
Tenho certeza de que a linha pode ser import random as R,PIL.Image as Ie então random.choicepode ser R.choice. Sim, o uso da entrada é ruim, mas você pode usar a versão da função para testar e publicar a versão para input()obter uma pontuação melhor !! : P
FryAmTheEggman 26/09/14
Ah, acabei de notar que definir aleatoriamente salva 0 caracteres. De qualquer forma, também percebi que a matemática é sua amiga: y=x*(1-r)+w== y=x-x*r-w.
FryAmTheEggman 26/09/14
@FryAmTheEggman esse era o meu ponto: p. Mas obrigado pela matemática.
internets é feito de catz
4

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;

insira a descrição da imagem aqui

r = 0.5;list = [[1,1],[300,522],[600,1],[300,177]];

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

flawr
fonte
Quais você quer dizer?
flawr
Oh, obrigado por me dizer, vou atualizar a submissão em breve!
flawr
Você vinculou minha resposta, mas eu conto a configuração da tela. Só não conto a única linha que chama a função. Imagens bonitas de qualquer maneira, espacialmente a primeira.
edc65
Ah, eu não percebi isso, só queria torná-lo 'comparável', mas é difícil quando tento confiar apenas no JS =) @ MartinBüttner Atualizado, agora que entendi da maneira correta que consegui remover grande parte do o lixo =)
flawr 26/09/14
3

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: insira a descrição da imagem aqui

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

Isso dá às pirâmides: insira a descrição da imagem aqui

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

Isso dá o triângulo de Sierpinski: insira a descrição da imagem aqui

user12205
fonte
4
Eu amo o efeito 3D das pirâmides. :)
Martin Ender
1

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

insira a descrição da imagem aqui

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)
Soham Chowdhury
fonte
Sem executar isso, não tenho idéia do que significa incrível . Talvez você possa explicar ou mostrar algumas fotos do que a diferencia das menores.
Geobits
@Geobits editada para incluir aviso e imagem :)
Soham Chowdhury
4
Eu preferiria que você incluísse isso em um cabeçalho separado (por exemplo, Implementação de Referência Ungolfed) em sua outra resposta, pois postar apenas código não-tecnicamente tecnicamente "não é uma resposta".
Martin Ender
-2

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()
Soham Chowdhury
fonte
@ MartinBüttner O fato de eu estar recebendo um tipo específico de entrada atende às especificações?
Soham Chowdhury
1
Além disso, na minha máquina, o resultado não é de 600x600 pixels, xey têm diferentes escalas de comprimento e os pontos cobrem mais de 1 pixel.
Martin Ender