Chaos Gra jest prosta metoda do generowania fraktali. Biorąc pod uwagę punkt początkowy, stosunek długości r oraz zestaw punktów 2D, wielokrotnie wykonaj następujące czynności:

• Z zestawu punktów wybierz jeden losowo (jednolicie).
• Średnie tego punktu, a ostatni punkt sporządzone (lub punktem wyjścia) za pomocą R i 1 - R jako obciążników (czyli R = 0 oznacza, że otrzymasz punkt wyjścia, r = 1 oznacza, że otrzymasz punkt losowy i R = 0,5 oznacza, że dostać punkt w połowie drogi.)
• Narysuj wynikowy punkt.

Na przykład, jeśli wybrałeś wierzchołki równobocznego trójkąta ir = 0,5 , wykreślone punkty odwzorowałyby trójkąt Sierpińskiego:

^{Obraz znaleziony na Wikipedii}

Musisz napisać program lub funkcję, która „gra” w grę chaosu i tworzy fraktal.

Wkład

Możesz napisać program lub funkcję i przyjmować następujące dane wejściowe za pomocą ARGV, STDIN lub argumentu funkcji:

• Liczba punktów do wykreślenia.
• Współrzędna początkowa (która również musi zostać narysowana!).
• Średnia waga rw przedziale [0,1] .
• Lista punktów do wyboru.

Wydajność

Możesz renderować na ekranie lub zapisać plik obrazu. Jeśli wynik jest zrasteryzowany, musi on wynosić co najmniej 600 pikseli z każdej strony, wszystkie punkty muszą znajdować się na obszarze roboczym, a co najmniej 75% zakresu obrazu w poziomie i pionie musi być użyte dla punktów (aby tego uniknąć odpowiada pojedynczymi czarnymi pikselami, mówiąc „jest naprawdę bardzo pomniejszony”). X i y Oś musi być w tej samej skali (to jest od linii (0,0) do (1,1), muszą być pod kątem 45 stopni), a każdy punkt na wykresie w grze chaosu przedstawia się jako jeden piksel (jeśli twoja metoda kreślenia antyaliasuje punkt, może on zostać rozłożony na 2x2 piksele).

Kolory są twoim wyborem, ale potrzebujesz co najmniej dwóch rozróżnialnych kolorów: jednego dla tła i jednego dla kropek wykreślonych podczas gry chaosu. Możesz, ale nie musisz kreślić punktów wejściowych.

Proszę obejmują trzy interesującym przykładem wyjścia w swojej odpowiedzi.

Punktacja

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Edycja: Nie musisz już rysować punktów wejściowych, ponieważ i tak nie są one widoczne jako pojedyncze piksele.

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

Jak to działa

W Mathematica Graphics[]funkcja tworzy skalowalną grafikę, renderujesz ją do dowolnego rozmiaru, po prostu przeciągając rogi obrazu. W rzeczywistości początkowy rozmiar całej wyświetlanej grafiki to ustawienie „.ini”, które można ustawić na 600 lub dowolną inną wartość. Dlatego nie ma potrzeby robienia niczego specjalnego dla wymagań 600 x 600.

AbsolutePointSize[]Rzeczą określa, że rozmiar punkt nie zostanie zmodyfikowany poprzez zwiększenie rozmiaru obrazu.

Podstawowym konstruktem jest

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

lub w pseudo-kodzie bez golfa:

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

Rekurencyjnie buduje listę zaczynając od (start point)i stosując funkcję (wektorową) w pierwszym argumencie do każdego kolejnego punktu, w końcu zwracając listę wszystkich obliczonych punktów do wykreślenia przezPoint[]

Niektóre przykłady samoreplikacji:

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

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

Podziały linii (w programie pokazujące użycie):

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

Rysowanie punktów wejściowych zostało usunięte z wymagań (tak 80 bajtów!). Nadal są wyświetlane na poniższych zrzutach ekranu, ale nie zostaną wyświetlone, jeśli je uruchomisz. Zobacz historię zmian, jeśli jesteś zainteresowany.

Dane wejściowe są podane jako tablica liczb zmiennoprzecinkowych. Pierwsza to iteracje, kolejne dwie zaczynają się x y. Po czwarte r, a na końcu jest lista współrzędnych, w x1 y1 x2 y2 ...modzie.

Gwiazda Ninja

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

Krzyż

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

Oktochainy

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

Edycja: duży krój, dzięki Williamowi Barbosie

Edycja: 3 bajty mniej, dzięki DocMax

173 bajty zliczające funkcję i element canvas potrzebne do wyświetlenia wyniku.

Testuj jako plik HTML i otwórz w 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))

Pobiera dane wejściowe jako argumenty funkcji do a, zapisuje wynik na standardowe wyjście jako plik pgm. nto iteracje, sto punkt początkowy, rto r, i zto lista punktów wejściowych.

Edycja: Nie rysuje już punktów wejściowych na szaro.

Ciekawe produkty:

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

SuperCollider to język do generowania muzyki, ale potrafi tworzyć grafiki w mgnieniu oka.

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

Użyłem niejasnych skrótów składniowych, aby zaoszczędzić kilka bajtów - bardziej czytelna i bardziej wydajna pamięć jest wersja

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

na 109 znakach.

Podobnie jak w przykładzie Mathematica, musisz ręcznie zmienić rozmiar okna, aby uzyskać 600 x 600 pikseli. Musisz wtedy poczekać na ponowne losowanie.

Generuje to podstawowy trójkąt Sierpińskiego (nie pokazano, ponieważ widziałeś go wcześniej)

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

To coś w rodzaju pięciokąta Sierpińskiego:

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

Ta sama rzecz z 6 punktami pozostawia odwrócony płatek śniegu Koch na środku:

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

Na koniec, oto riff na piramidach 3D z odpowiedzi asa. (Pamiętaj, że dwukrotnie użyłem jednego z punktów, aby uzyskać efekt cieniowania).

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

Python, 189 183 175

Edycja: naprawiono odwrócony współczynnik r i przełączono na obraz czarno-biały, aby zaoszczędzić kilka bajtów.

Przyjmuje liczbę punktów jako n, pierwszy punkt jako p, stosunek jako ri listę punktów jako l. Potrzebuje modułu Poduszka.

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

Przykłady:

Generuję punkty w kółko wokół centrum obrazu

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)

Powtórzenia XOXO, tylko zmieniam stosunek z 0,4 na 0,6

Jakiś płatek śniegu

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)

Z przyjemnością otrzymam opinię na temat mojego skryptu i gry w golfa, ponieważ nie czuję się komfortowo z JS =) (Zapraszam do korzystania z tego / zmieniania go do własnego zgłoszenia!)

Odczytywanie danych wejściowych (Aby być porównywalnym z wpisem edc65 , nie liczę danych wejściowych.):

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

Ustawienia i obliczenia na płótnie

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

Nieco bardziej niepohamowany (w tym przykładowe dane wejściowe, w których prawdziwe promesy wejściowe są po prostu komentowane, więc gotowe do użycia):

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

Przykłady

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

Przetwarzanie, 153

Przeniesiono odpowiedź Java @Geobits na Przetwarzanie i zrobiłem trochę golfa, co spowodowało redukcję 100 znaków. Początkowo zamierzałem animować proces, ale ograniczenia wejściowe są w tym przypadku zbyt surowe (Przetwarzanie nie ma stdin ani argv, co oznacza, że ​​muszę napisać własną funkcję zamiast korzystać z natywnej draw()pętli przetwarzania ).

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

Kompletny program z podziałem linii:

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

Powyższy program daje Krzyże:

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

To daje piramidy:

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

To daje trójkąt Sierpińskiego:

Niegolfowane „referencyjne wdrożenie”, Python

Aktualizacja : znacznie, znacznie szybciej (o rzędy wielkości)

Sprawdź interaktywną powłokę!

Edytuj plik i ustaw interactivena True, a następnie wykonaj jedną z następujących czynności:

polygon numberOfPoints numeratorOfWeight denominatorOfWeight startX startY numberOfSides generuje, zapisuje i wyświetla wielokąt.

points numberOfPoints numeratorOfWeight denominatorOfWeight startX startY point1X point1Y point2X point2Y ... robi to, o co prosi specyfikacja.

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 znaków)

Przyjmuje liczbę punktów jako nśrednią wagę jako rpunkt początkowy jako tuple sa listę punktów jako listę tuplenazwanych 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()