Chaos Гра являє собою простий метод для генерації фракталів. З огляду на початкову точку, відношення довжини r та набір 2D точок, повторно виконайте наступне:

• Зі свого набору очок виберіть навмання (рівномірно).
• Середнє значення цієї точки та останньої намальованої точки (або початкової точки), використовуючи r та 1 - r як ваги (тобто r = 0 означає, що ви отримуєте початкову точку, r = 1 означає, що ви отримуєте випадкову точку, а r = 0,5 означає, що ви отримайте крапку посередині.)
• Намалюйте отриману точку.

Наприклад, якщо ви вибрали вершини рівностороннього трикутника і r = 0,5 , нанесені точки будуть відображати трикутник Сєрпінського:

^{Зображення знайдено у Вікіпедії}

Ви повинні написати програму або функцію, яка "грає" в гру хаосу, щоб створити фрактал.

Вхідні дані

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

• Кількість балів за графіком.
• Початкова координата (яка теж має бути намічена!).
• Середня вага r в інтервалі [0,1] .
• Список пунктів на вибір.

Вихідні дані

Ви можете візуалізувати на екрані або записати файл зображення. Якщо результат растеризований, він повинен бути не менше 600 пікселів з кожної сторони, всі точки повинні бути на полотні, і принаймні 75% горизонтальної та вертикальної протяжності зображення повинні бути використані для точок (цього слід уникати відповіді за допомогою єдиних чорних пікселів, які говорять, що "дійсно далеко зменшено") Х і у осі повинні бути на той же масштаб (тобто лінія від (0,0) до (1,1) повинна бути під кутом 45 градусів) , і кожна точка на графіку в області хаосу ігор повинна бути представлена в вигляді єдиної пікселів (якщо ваш спосіб побудови графіку не псевдонімує точку, він може бути поширений на 2х2 пікселі).

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

Будь ласка, включіть у відповідь три цікаві приклади.

Оцінка балів

Це кодовий гольф, тому найкоротша відповідь (у байтах) виграє.

Редагувати: Вам більше не потрібно будувати точки введення, оскільки вони насправді не видно як пікселі.

Математика, 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();
    }
}

Малюнки вхідних точок були видалені з вимог (так, 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

Октязини

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

Редагувати: виправити перевернуте співвідношення r та переключитися на B&W-зображення, щоб зберегти кілька байт.

Приймає кількість балів як 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 на «Обробку» та зробив ще кілька гри в гольф, в результаті чого скоротився на 100 символів. Спочатку я мав намір анімувати процес, але обмеження на вході є надто суворими щодо цього (Обробка не має stdin чи argv, а це означає, що я повинен написати власну функцію замість використання нативного draw()циклу 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]));}

Повна програма з перервами рядків:

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