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 пикселя).

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

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

счет

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

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

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

Ява: 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

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>

Питон - 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)]

Суперколлайдер - 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])

Питон, 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)

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

Портировал 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});

Это дает треугольник Серпинского:

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)

Питон (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()