Играть в игру хаос

28

Chaos Игра представляет собой простой метод для генерации фракталов. Учитывая начальную точку, отношение длины r и набор 2D точек, многократно выполните следующее:

  • Из вашего набора точек, выберите один наугад (равномерно).
  • Усредните эту точку и последнюю нарисованную точку (или начальную точку), используя r и 1 - r в качестве весов (т.е. r = 0 означает, что вы получили начальную точку, r = 1 означает, что вы получили случайную точку, а r = 0,5 означает, что вы получить точку на полпути между ними.)
  • Нарисуйте результирующую точку.

Например, если вы выбрали вершины равностороннего треугольника и r = 0,5 , построенные точки отобразили бы треугольник Серпинского:

введите описание изображения здесь

Изображение найдено в Википедии

Вы должны написать программу или функцию, которая «играет» в игру хаоса, чтобы создать фрактал.

вход

Вы можете написать либо программу, либо функцию и получить следующие входные данные через ARGV, STDIN или аргумент функции:

  • Количество точек на графике.
  • Начальная координата (которая также должна быть нанесена!).
  • Усредняющий вес r в интервале [0,1] .
  • Список точек на выбор.

Выход

Вы можете визуализировать на экране или написать файл изображения. Если результат растеризован, он должен быть не менее 600 пикселей с каждой стороны, все точки должны быть на холсте, и по крайней мере 75% горизонтального и вертикального экстента изображения должны использоваться для точек (это нужно для того, чтобы избежать отвечает одним черным пикселем, говоря: «Это действительно сильно уменьшено»). Оси x и y должны быть в одном масштабе (то есть линия от (0,0) до (1,1) должна быть под углом 45 градусов), и каждая точка, изображенная в игре хаоса, должна быть представлена ​​как одна pixel (если ваш метод построения графика сглаживает точку, она может быть растянута на 2x2 пикселя).

Цвета - ваш выбор, но вам нужно по крайней мере два различимых цвета: один для фона и один для точек, построенных во время игры в хаос. Вы можете, но не обязательно наносить на график точки ввода.

Пожалуйста, включите три интересных примера выходных данных в свой ответ.

счет

Это код гольф, поэтому самый короткий ответ (в байтах) выигрывает.

Изменить: вам больше не нужно наносить точки ввода, так как они все равно не видны как отдельные пиксели.

Мартин Эндер
источник
Что означает « каждая точка на графике ... должна быть представлена ​​в виде одного пикселя »? А) что не следует использовать сглаживание; или б) что количество точек во втором цвете должно быть равно первому элементу из входных данных? Обратите внимание, что б) невозможно гарантировать, если в процедуре итерации нет теста «Совпадает ли этот пиксель с ранее нанесенным?», Потому что, если селектор случайных чисел выбирает одну и ту же точку достаточно много раз подряд, то позиция будет сходиться к этот момент.
Питер Тейлор
@PeterTaylor Он был предназначен для того, чтобы люди не рисовали большие точки в качестве точек (как это делает Mathematica по умолчанию), но я уже заметил, что сглаживание вызывает некоторые проблемы с обеспечением единичных пикселей в ответе Сохэма. Я думаю, что я уменьшу это до «не должно быть больше, чем 2x2 пикселей», что должно покрыть все проблемы сглаживания.
Мартин Эндер,
Я думаю, что я что-то неправильно понял: вы всегда берете «среднее» последней построенной точки и случайную точку текущего списка. Затем вы добавляете эту новую точку в список. Это верно? Кажется, что если у вас есть много точек в одном «углу», вы получите гораздо больше, но вряд ли из этого облака выйдет - по крайней мере, мой код всегда «сходится» довольно быстро к точкам, которые слишком близки друг к другу, чтобы действительно улучшить картину.
flawr
1
@ flawr нет, вы не добавляете новую точку в список. Список фиксирован - алгоритм заботится только о последней точке, которая была нанесена, а не о том, что было до нее.
Натаниэль
Спасибо, это многое объясняет, возможно, следует уточнить в вопросе.
flawr

Ответы:

8

Математика, 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]

Математическая графика

Доктор белисарий
источник
@ MartinBüttner Instructions for testing this answer without Mathematica installed:1) Загрузите это из pastebin и сохраните как * .CDF 2) Загрузите и установите бесплатную среду CDF от Wolfram Research по адресу (не маленький файл). Наслаждаться. Скажи мне, если это работает!
д-р Велизарий
Ваша golfed версия не совсем работает (по крайней мере , на V10): вам нужно переключить вокруг , #rчтобы r#уйти без пробела или *между ними.
Мартин Эндер,
@ MartinBüttner Любопытно! Это работает как брелок на v9 (у меня еще нет v10). Во всяком случае, я (вслепую) поменял местами #и r.
Доктор Велизарий
Ах, это новая функция. Теперь вы можете применять функции к ассоциациям, и в этом случае вы получите именованные параметры, к которым можно получить доступ #key. Я уверен, что это пригодится. :)
Мартин Эндер
8

Ява: 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();
    }
}

Отрисовка входных точек была удалена из требований (yay 80 байт!). Они все еще показаны на старых скриншотах ниже, но не появятся, если вы запустите их. Смотрите историю изменений, если интересно.

Входные данные приведены в виде массива с плавающей точкой. Первая - это итерации, следующие две начинаютсяx y . Четвертый - это 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

введите описание изображения здесь

Octochains

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

введите описание изображения здесь

Geobits
источник
это не работает на моем компьютере, и жалобы Java showустарели
гордый haskeller
@proudhaskeller show() является устаревшим, но он все еще работает. Когда вы говорите «не работает», что это значит? Если у вас нет Java 8, вам нужно добавить finalк String[]aв основном , по крайней мере.
Geobits
Портировал свой ответ на Обработка и вырезал 100 символов.
user12205 25.09.14
1
@ace Хорошо. Вы можете сделать это практически с любым Java-гольфом для графического вывода, но мне нравится, что это ровно 100 символов: D
Geobits
7

JavaScript (E6) + HTML 173 176 193

Изменить: большой вырез, благодаря Уильяму Барбозе

Изменить: 3 байта меньше, благодаря DocMax

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>
edc65
источник
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>длиной 176 байт, я не понял твой счет
Уильям Барбоза
@WilliamBarbosa мой счет правильный, основываясь на моем ответе. С твоими намеками становится лучше - спасибо!
edc65
1
Вы можете сбрить еще два, если вы переместите инициализацию размера и обновите в forвызове:for(C.width=C.height=600;n--;y-=(y-p[i+1])*r)
DocMax
6

Питон - 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, записывает результат в stdout в виде файла pgm. nэто итерации, sэто начальная точка, rэто r, и 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)]
faubi
источник
Некоторые обычные символы Python сохраняются: начальные значения наподобие p=[255]*360000могут быть необязательными параметрами для функции; тело цикла for может идти по одной и той же строке, если у него нет потока управления; Вы можете сбрить Parens от [1]*(n+1)как [1]*-~n; так как вы не используете iв наружном цикл, он короче запустить код на nраз , как exec"code;"*n); Я думаю, что параны for i in(0,1)могут быть удалены.
xnor
6

Суперколлайдер - 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-пирамидах из ответа туза. (Обратите внимание, что я использовал одну из точек дважды, чтобы получить эффект затенения.)

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

введите описание изображения здесь

Натаниель
источник
6

Питон, 189 183 175

Изменить: исправил перевернутый г отношение и переключился изображение, чтобы сохранить несколько байтов.

Принимает количество точек как 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)

введите описание изображения здесь

интернет сделан из catz
источник
Незнайка о фиксации в обратном направлении г вещь, но вы можете сэкономить довольно много персонажей, делая это программа , использующая n,p,r,l=input(). Вы также можете снять скобки с *=операций и использования import random as R.
FryAmTheEggman
@FryAmTheEggman К сожалению, корректируя мой ответ Аннулирует оптимизации на *=. :( The inputвещи будет хорошо быть очень неприятно работать, а импорт в настоящее время является наиболее краткой формой можно (или я что - то пропустил?).
Teh интернетов сделан catz
Я уверен, что линия может быть, import random as R,PIL.Image as Iа затем random.choiceможет быть R.choice. Да, использование ввода неэффективно, но вы можете использовать версию функции для тестирования и опубликовать ее input()для лучшего результата !! 1! : P
FryAmTheEggman
О, я только что заметил, что определение случайного действительно сохраняет 0 символов. Ой: S В любом случае, я также понял, что математика - твой друг: y=x*(1-r)+w== y=x-x*r-w.
FryAmTheEggman
@FryAmTheEggman, это была моя точка зрения: с. Но спасибо за математику.
интернет сделан из catz
4

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

введите описание изображения здесь

flawr
источник
Какие из них вы имеете в виду?
flawr
О, спасибо, что сказал мне, я скоро обновлю представление!
flawr
Вы связали мой ответ, но я считаю установку холста. Я просто не считаю одну строку, вызывающую функцию. Хорошие изображения в любом случае, особенно первый.
edc65
Ах, я этого не заметил, я просто хотел сделать его «сопоставимым», но это трудно, когда я пытаюсь полагаться только на JS =) @ MartinBüttner Обновлено, теперь, когда я понял это правильно, я смог удалить большую часть мусор =)
flawr
3

Обработка, 153

Портировал Java-ответ @Geobits на Processing и сделал еще несколько игр в гольф, что привело к сокращению на 100 символов. Первоначально я намеревался оживить процесс, но входные ограничения слишком жесткие для этого (в обработке нет stdin или argv, что означает, что я должен написать свою собственную функцию вместо использования собственного 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});

Это дает треугольник Серпинского: введите описание изображения здесь

user12205
источник
4
Мне нравится трехмерный эффект пирамид. :)
Мартин Эндер
1

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)
Сохам Чоудхури
источник
Без выполнения этой команды я понятие не имею , что такое удивительное средство. Возможно, вы могли бы объяснить или показать несколько фотографий того, что отличает его от более коротких?
Geobits
@Geobits отредактировано, чтобы включать в себя отказ от ответственности и изображение :)
Сохам Чоудхури
4
Я бы предпочел, чтобы вы включили это под отдельным заголовком (например, Ungolfed Reference Реализация) в ваш другой ответ, так как публикация только кода без кода технически "не является ответом".
Мартин Эндер
-2

Питон (202 символа)

Принимает количество точек как n, усредняющий вес как r, начальную точку как a tuple sи список точек как список tupleвызываемых XY 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()
Сохам Чоудхури
источник
@ MartinBüttner Соответствует ли тот факт, что я принимаю данные определенного типа, спецификации?
Сохам Чоудхури
1
Кроме того, на моей машине результат не 600x600 пикселей, x и y имеют разные масштабы длины, а точки охватывают более 1 пикселя.
Мартин Эндер