Ganzzahlige Mathematik kann erstaunliche Muster erzeugen, wenn sie über ein Raster gelegt wird. Selbst die grundlegendsten Funktionen können erstaunlich aufwändige Designs ergeben!

Deine Herausforderung

Schreiben Sie für ein 1024x1024-Bild 3 tweetbare (dh 140 Zeichen oder weniger) Funktionskörper für die Werte Rot, Grün und Blau.

Die Eingabe für die Funktionen ist zwei ganze Zahlen i (Spaltennummer für das gegebene Pixel) und j (Zeilennummer für das gegebene Pixel), und die Ausgabe ist ein vorzeichenloser Kurzschluss zwischen 0 und 1023 einschließlich, der die Menge des gegebenen darstellt im Pixel vorhandene Farbe (i, j).

Die folgenden drei Funktionen ergeben beispielsweise das folgende Bild:

/* RED */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)*_sq(j-DIM/2))*2.0);
/* GREEN */
    return (unsigned short)sqrt((double)(
        (_sq(i-DIM/2)|_sq(j-DIM/2))*
        (_sq(i-DIM/2)&_sq(j-DIM/2))
    )); 
/* BLUE */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)&_sq(j-DIM/2))*2.0);

/* RED */
    return i&&j?(i%j)&(j%i):0;
/* GREEN */
    return i&&j?(i%j)+(j%i):0;
/* BLUE */
    return i&&j?(i%j)|(j%i):0;

Die Regeln

• Ersetzen Sie in Anbetracht dieses C ++ - Codes in Ihren Funktionen. Ich habe einige Makros zur Verfügung gestellt und die Bibliothek eingeschlossen, und Sie können complex.h einschließen. Sie können alle Funktionen aus diesen Bibliotheken und / oder meinen Makros verwenden. Verwenden Sie darüber hinaus keine externen Ressourcen.

• Wenn diese Version für Sie nicht funktioniert, stellen Sie sicher, dass Sie mit Folgendem kompilieren:

  g++ filename.cpp -std=c++11
  

  Wenn dies nicht funktioniert, verwenden Sie bitte die alternative Version mit nicht unterzeichneten Zeichen anstelle von nicht unterzeichneten Kurzzeichen.

Michaelangelo hat eine bereinigte 24-Bit- oder 48-Bit-Farbausgabeversion bereitgestellt .

• Sie können Ihre eigene Version in einer anderen Sprache implementieren, sie muss sich jedoch genauso verhalten wie die bereitgestellte C ++ - Version, und es dürfen nur Funktionen aus den integrierten C ++ - Funktionen, der Bibliothek oder den bereitgestellten Makros verwendet werden, um sie fair zu gestalten.
• Posten Sie nur Ihre drei Funktionskörper - bitte fügen Sie meinen Code nicht in Ihren Beitrag ein
• Bitte fügen Sie entweder eine kleinere Version oder eine eingebettete Kopie Ihres Bildes bei. Sie werden in ein ppm-Format umgewandelt und müssen möglicherweise in ein anderes konvertiert werden, damit sie beim Stapelaustausch richtig angezeigt werden können.
• Funktionskörper (ohne Signatur) dürfen maximal 140 Zeichen lang sein.
• Dies ist ein Beliebtheitswettbewerb - die meisten Stimmen gewinnen

Mandelbrot 3 x 133 Zeichen

Das erste, was mir in den Sinn kam, war "Mandelbrot!".

Ja, ich weiß, dass es bereits eine Mandelbrot-Einreichung gibt. Nachdem ich bestätigt habe, dass ich es selbst unter 140 Zeichen schaffen kann, habe ich die Tricks und Optimierungen aus dieser Lösung in meine übernommen (danke Martin und Todd). Das ließ Raum, um einen interessanten Ort und Zoom sowie ein schönes Farbthema zu wählen:

unsigned char RD(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,3.);
}
unsigned char GR(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.7);
}
unsigned char BL(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.5);
}

132 Zeichen insgesamt

Ich habe versucht, es für alle 3 Kanäle auf 140 zu bringen. Es gibt ein wenig Farbrauschen in der Nähe des Randes, und die Position ist nicht so interessant wie die erste, aber: 132 Zeichen

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}

Tischdecken

Eben

Ich fing an, ein kariertes / kariertes Muster wie ein grenzenloses Tischtuch in die richtige Perspektive zu rücken:

unsigned char RD(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}

Welligkeit

Dann habe ich eine Welligkeit eingeführt (nicht unbedingt korrekte Perspektive, aber immer noch in 140 Zeichen):

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}

Farbe

Dann habe ich einige Farben feiner gemasert, um eine größere Auswahl an Details zu erhalten und das Bild bunter zu machen ...

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;
}

In Bewegung

Wenn Sie den Code nur geringfügig weiter reduzieren, können Sie eine Wellenphase P mit zwei Dezimalstellen definieren, die gerade für Frames ausreicht, die für eine reibungslose Animation nah genug sind. In diesem Stadium habe ich die Amplitude reduziert, um Seekrankheit zu vermeiden, und das gesamte Bild um weitere 151 Pixel nach oben verschoben (zum Preis von 1 zusätzlichen Zeichen), um das Aliasing vom oberen Rand des Bildes zu entfernen. Animiertes Aliasing ist faszinierend.

unsigned char RD(int i,int j){
#define P 6.03
float s=3./(j+250),y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;}

unsigned char GR(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;}

unsigned char BL(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;}

Zufälliger Maler

char red_fn(int i,int j){
#define r(n)(rand()%n)
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):red_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char green_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):green_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char blue_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):blue_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}

Hier ist ein zufallsbasierter Eintrag. Für ungefähr 0,1% der Pixel wählt es eine zufällige Farbe, für die anderen verwendet es die gleiche Farbe wie ein zufälliges benachbartes Pixel. Beachten Sie, dass jede Farbe dies unabhängig tut, so dass dies eigentlich nur eine Überlagerung eines zufälligen grünen, blauen und roten Bildes ist. Um bei verschiedenen Läufen unterschiedliche Ergebnisse zu erzielen, müssen Sie srand(time(NULL))die mainFunktion erweitern.

Nun zu einigen Variationen.

Durch Überspringen von Pixeln können wir das Bild etwas verschwommener machen.

Und dann können wir langsam die Farben ändern, wobei die Überläufe zu plötzlichen Änderungen führen, die das Aussehen von Pinselstrichen noch verstärken

Dinge, die ich herausfinden muss:

• Aus irgendeinem Grund kann ich sranddiese Funktionen nicht nutzen, ohne einen Segfault zu erhalten.
• Wenn ich die zufälligen Bewegungen über alle drei Farben gleich machen könnte, könnte es ein bisschen ordentlicher aussehen.

Sie können den Random Walk auch isotrop machen

static char c[1024][1024];return!c[i][j]?c[i][j]=r(999)?red_fn((i+r(5)+1022)%1024,(j+r(5)+1022)%1024):r(256):c[i][j];

dir geben

Mehr zufällige Bilder

Ich habe ein bisschen mehr damit gespielt und ein paar andere zufällige Bilder geschaffen. Nicht alle davon sind im Rahmen dieser Herausforderung möglich, daher möchte ich sie hier nicht aufnehmen. Aber Sie können sie in dieser Bildergalerie sehen, zusammen mit einigen Beschreibungen, wie ich sie hergestellt habe.

Ich bin versucht, all diese Möglichkeiten zu einem Framework zu entwickeln und auf GitHub zu stellen. (Nicht, dass so etwas noch nicht existiert, aber es macht trotzdem Spaß!)

Einige wirbelnde, spitze Dinge

Ja, ich wusste genau, wie ich es nennen sollte.

unsigned short RD(int i,int j){
    return(sqrt(_sq(73.-i)+_sq(609-j))+1)/(sqrt(abs(sin((sqrt(_sq(860.-i)+_sq(162-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(160.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(86.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(844.-i)+_sq(200-j))+1)/(sqrt(abs(sin((sqrt(_sq(250.-i)+_sq(20-j)))/115.0)))+1)/200;
}

BEARBEITEN: Nicht mehr verwendet pow. EDIT 2: @PhiNotPi wies darauf hin, dass ich nicht so viel abs verwenden muss.

Sie können die Referenzpunkte ziemlich einfach ändern, um ein anderes Bild zu erhalten:

unsigned short RD(int i,int j){
    return(sqrt(_sq(148.-i)+_sq(1000-j))+1)/(sqrt(abs(sin((sqrt(_sq(500.-i)+_sq(400-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(610.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(864.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(180.-i)+_sq(100-j))+1)/(sqrt(abs(sin((sqrt(_sq(503.-i)+_sq(103-j)))/115.0)))+1)/200;
}

@ EricTressler wies darauf hin, dass meine Bilder Batman enthalten.

Natürlich muss es eine Mandelbrot-Einreichung geben.

char red_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>31?256:k*8;
}
char green_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>63?256:k*4;
}
char blue_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k;
}

Ich versuche jetzt, das Farbschema zu verbessern. Ist es ein Betrug, wenn ich die Berechnung als Makro definiere red_fnund dieses Makro in den anderen beiden verwende, damit ich mehr Zeichen für eine ausgefallene Farbauswahl in Grün und Blau habe?

Bearbeiten: Es ist wirklich schwierig, mit diesen wenigen verbleibenden Bytes anständige Farbschemata zu finden. Hier ist eine andere Version:

/* RED   */ return log(k)*47;
/* GREEN */ return log(k)*47;
/* BLUE  */ return 128-log(k)*23;

Und gemäß dem Vorschlag von Githubphagocyte und mit den Verbesserungen von Todd Lehman können wir leicht kleinere Abschnitte auswählen:

Z.B

char red_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char green_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char blue_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return 128-k/200;
}

gibt

Julia setzt

Wenn es einen Mandelbrot gibt, sollte es auch einen Julia-Satz geben.

Sie können stundenlang daran arbeiten, die Parameter und Funktionen zu optimieren. Dies ist also nur eine kurze Anleitung, die anständig aussieht.

Inspiriert von Martins Teilnahme.

unsigned short red_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.)
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(X=x*x)+(Y=y*y)<4){x=X-Y+.36237;y=2*x*y+.32;}return log(n)*256;}

unsigned short green_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+-.7;y=2*X*Y+.27015;}return log(n)*128;}

unsigned short blue_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<600&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+.36237;y=2*X*Y+.32;}return log(n)*128;}

Möchten Sie etwas RNG?

OK, Sparrs Kommentar hat mich dazu veranlasst, die Parameter dieser kleinen Julias zufällig zu bestimmen. Ich habe zuerst versucht, Hacken auf Bit-Ebene mit dem Ergebnis von durchzuführen, time(0)aber C ++ erlaubt keine hexadezimalen Fließkommazahlen, so dass dies eine Sackgasse war (zumindest mit meinen begrenzten Kenntnissen). Ich hätte ein schweres Casting verwenden können, um es zu erreichen, aber das hätte nicht in die 140 Bytes gepasst.

Ich hatte sowieso nicht mehr viel Platz, also musste ich die rote Julia fallen lassen, um meine Makros zu platzieren und ein konventionelleres RNG ( timed seed und real rand(), woohoo!) Zu haben.

Hoppla, etwas fehlt. Offensichtlich müssen diese Parameter statisch sein, oder Sie haben einige seltsame Ergebnisse (aber lustig, vielleicht werde ich später nachforschen, ob ich etwas Interessantes finde).

Also hier sind wir mit nur grünen und blauen Kanälen:

Fügen wir nun ein einfaches rotes Muster hinzu, um die Lücke zu füllen. Nicht wirklich einfallsreich, aber ich bin kein Grafikprogrammierer ... bis jetzt :-)

Und zum Schluss der neue Code mit zufälligen Parametern:

unsigned short red_fn(int i, int j){
static int n=1;if(n){--n;srand(time(0));}
#define R rand()/16384.-1
#define S static float r=R,k=R;float
return _cb(i^j);}

unsigned short green_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.),
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

unsigned short blue_fn(int i, int j){
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

Es ist noch Platz übrig ...

Dieser ist interessant, weil er die i, j-Parameter überhaupt nicht verwendet. Stattdessen merkt es sich den Zustand in einer statischen Variablen.

unsigned char RD(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char GR(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char BL(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}

/* RED */
    int a=(j?i%j:i)*4;int b=i-32;int c=j-32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
/* GREEN */
    int a=(j?i%j:i)*4;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((i+j)/2))^_cb((i-j)*2);
/* BLUE */
    int a=(j?i%j:i)*4;int b=i+32;int c=j+32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);

Buddhabrot (+ Antibuddhabrot)

Edit: Es ist jetzt ein richtiger Buddhabrot!

Bearbeiten: Ich habe es geschafft, die Farbintensität innerhalb der Bytegrenze zu begrenzen, sodass es aufgrund des Überlaufs keine falsch schwarzen Pixel mehr gibt.

Ich wollte unbedingt nach vier aufhören ... aber ...

Dies wird beim Hochladen leicht komprimiert (und beim Einbetten verkleinert). Wenn Sie also alle Details bewundern möchten, sehen Sie sich die interessanten 512x512-Ausschnitte an (die nicht komprimiert werden und in voller Größe angezeigt werden):

Danke an Githubphagocyte für die Idee. Dies erforderte einen ziemlich komplizierten Missbrauch aller drei Farbfunktionen:

unsigned short RD(int i,int j){
    #define f(a,b)for(a=0;++a<b;)
    #define D float x=0,y=0
    static int z,m,n;if(!z){z=1;f(m,4096)f(n,4096)BL(m-4096,n-4096);};return GR(i,j);
}
unsigned short GR(int i,int j){
    #define R a=x*x-y*y+i/1024.+2;y=2*x*y+j/1024.+2
    static float c[DIM][DIM],p;if(i>=0)return(p=c[i][j])>DM1?DM1:p;c[j+DIM][i/2+DIM]+=i%2*2+1;
}
unsigned short BL(int i,int j){
    D,a,k,p=0;if(i<0)f(k,5e5){R;x=a;if(x*x>4||y*y>4)break;GR(int((x-2)*256)*2-p,(y-2)*256);if(!p&&k==5e5-1){x=y=k=0;p=1;}}else{return GR(i,j);}
}

Für ein besseres Farbschema sind noch einige Bytes übrig, aber bisher habe ich nichts gefunden, was das Graustufenbild übertrifft.

Der angegebene Code verwendet 4096 x 4096 Startpunkte und durchläuft bis zu 500.000 Iterationen, um zu bestimmen, ob die Flugbahnen entkommen oder nicht. Das hat auf meiner Maschine zwischen 6 und 7 Stunden gedauert. Mit einem Raster von 2 x 2 k und Iterationen von 10 k, die zwei Minuten dauern, können Sie gute Ergebnisse erzielen, und selbst ein Raster von 1 x 1 k mit Iterationen von 1 k sieht recht gut aus (das dauert etwa 3 Sekunden). Wenn Sie mit diesen Parametern experimentieren möchten, müssen einige Punkte geändert werden:

• Passen Sie zum Ändern der Mandelbrot-Rekursionstiefe beide Instanzen von 5e5in BLan Ihre Iterationsanzahl an.
• Um die Rasterauflösung zu ändern, um alle vier ändern 4096in RDauf die gewünschte Auflösung und die 1024.in GRden gleichen Faktor die richtige Skalierung zu halten.
• Sie werden wahrscheinlich müssen auch die Skalierung return c[i][j]in GRda , dass nur die absolute Anzahl der Besuche jeden Pixel enthält. Die maximale Farbe scheint weitgehend unabhängig von der Iterationszahl zu sein und skaliert linear mit der Gesamtzahl der Startpunkte. Wenn Sie also ein 1k x 1k-Raster verwenden möchten, möchten Sie vielleicht return c[i][j]*16;oder ähnliches, aber dieser Faktor erfordert manchmal ein wenig Fummeln.

Für diejenigen, die mit dem Buddhabrot nicht vertraut sind (wie ich vor ein paar Tagen), basiert es auf der Mandelbrot-Berechnung, aber die Intensität jedes Pixels gibt an, wie oft dieses Pixel in den Iterationen der entkommenden Flugbahnen besucht wurde. Wenn wir die Besuche während nicht entkommender Flugbahnen zählen, handelt es sich um ein Antibuddhabrot. Es gibt eine noch raffiniertere Version namens Nebulabrot, bei der Sie für jeden Farbkanal eine andere Rekursionstiefe verwenden. Aber ich überlasse das jemand anderem. Weitere Informationen finden Sie wie immer bei Wikipedia .

Ursprünglich habe ich nicht zwischen entkommenen und nicht entkommenen Flugbahnen unterschieden. Das erzeugte eine Handlung, die die Vereinigung eines Buddhabrots und eines Antibuddhabrots ist (wie durch Githubphagozyten hervorgehoben).

unsigned short RD(int i,int j){
    #define f(a)for(a=0;++a<DIM;)
    static int z;float x=0,y=0,m,n,k;if(!z){z=1;f(m)f(n)GR(m-DIM,n-DIM);};return BL(i,j);
}
unsigned short GR(int i,int j){
    float x=0,y=0,a,k;if(i<0)f(k){a=x*x-y*y+(i+256.0)/512;y=2*x*y+(j+512.0)/512;x=a;if(x*x+y*y>4)break;BL((x-.6)*512,(y-1)*512);}return BL(i,j);
}
unsigned short BL(int i,int j){
    static float c[DIM][DIM];if(i<0&&i>-DIM-1&&j<0&&j>-DIM-1)c[j+DIM][i+DIM]++;else if(i>0&&i<DIM&&j>0&&j<DIM)return log(c[i][j])*110;
}

Dieser sieht ein bisschen aus wie ein verblasstes Foto ... das gefällt mir.

Sierpinski Pentagon

Möglicherweise haben Sie die Chaos- Spielmethode zur Annäherung an das Sierpinski-Dreieck kennengelernt, indem Sie Punkte auf halbem Weg zu einem zufällig ausgewählten Scheitelpunkt gezeichnet haben. Hier habe ich den gleichen Ansatz mit 5 Eckpunkten gewählt. Der kürzeste Code, auf den ich mich festlegen konnte, beinhaltete die harte Codierung der 5 Eckpunkte, und es gab keine Möglichkeit, alles in 140 Zeichen einzupassen. Daher habe ich die rote Komponente an einen einfachen Hintergrund delegiert und den freien Platz in der roten Funktion verwendet, um ein Makro zu definieren, um die anderen beiden Funktionen auch unter 140 zu bringen. Es gilt also alles auf Kosten der Abwesenheit einer roten Komponente im Fünfeck.

unsigned char RD(int i,int j){
#define A int x=0,y=0,p[10]={512,9,0,381,196,981,827,981,DM1,381}
auto s=99./(j+99);return GR(i,j)?0:abs(53-int((3e3-i)*s+j*s)%107);}

unsigned char GR(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<2e7;n++){int v=(rand()%11+1)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

unsigned char BL(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<3e7;n++){int v=(rand()%11+4)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

Vielen Dank an Martin Büttner für die in den Kommentaren der Frage erwähnte Idee, ein Makro in einer Funktion zu definieren, um es dann in einer anderen zu verwenden, und für die Verwendung von Memoization, um die Pixel in einer willkürlichen Reihenfolge zu füllen, anstatt auf die Rasterreihenfolge der Hauptfunktion beschränkt zu sein .

Das Bild hat eine Größe von über 500 KB und wird durch Stapelaustausch automatisch in JPG konvertiert. Dies verwischt einige der feineren Details, daher habe ich auch nur das obere rechte Viertel als PNG eingefügt, um den ursprünglichen Look zu zeigen:

Noten

Sierpinski-Musik. : D Die Leute im Chat sagen, es sieht eher aus wie das gelochte Papier für Spieluhren.

unsigned short RD(int i,int j){
    return ((int)(100*sin((i+400)*(j+100)/11115)))&i;
}
unsigned short GR(int i,int j){
    return RD(i,j);
}
unsigned short BL(int i,int j){
    return RD(i,j);
}

Einige Details, wie das funktioniert ... ähm, es ist eigentlich nur ein Zoom auf ein Rendering einiger gewellter Sierpinski-Dreiecke. Der Noten-Look (und auch die Blockhaftigkeit) ist das Ergebnis von Integer-Kürzungen. Wenn ich die rote Funktion ändere, sagen wir

return ((int)(100*sin((i+400)*(j+100)/11115.0)));

Die Kürzung wird entfernt und wir erhalten die volle Auflösung rendern:

Also ja, das ist interessant.

Zufälliger Voronoi-Diagrammgenerator jemand?

OK, dieser hat mir eine harte Zeit bereitet. Ich finde es aber ziemlich schön, auch wenn die Ergebnisse nicht so kunstvoll sind wie bei einigen anderen. Das ist der Deal mit Zufälligkeit. Vielleicht sehen einige Zwischenbilder besser aus, aber ich wollte unbedingt einen voll funktionsfähigen Algorithmus mit Voronoi-Diagrammen haben.

Bearbeiten:

Dies ist ein Beispiel für den endgültigen Algorithmus. Das Bild ist im Grunde genommen die Überlagerung von drei Voronoi-Diagrammen, eines für jede Farbkomponente (rot, grün, blau).

Code

ungolfed, kommentierte Version am Ende

unsigned short red_fn(int i, int j){
int t[64],k=0,l,e,d=2e7;srand(time(0));while(k<64){t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short green_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short blue_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

Es hat mich sehr viel Mühe gekostet, daher möchte ich die Ergebnisse in verschiedenen Phasen teilen, und es gibt nette (falsche), die ich zeigen kann.

Erster Schritt: Einige Punkte nach dem Zufallsprinzip setzen lassen, mit x=y

Ich habe es in JPEG konvertiert, weil das ursprüngliche PNG zu schwer für das Hochladen war ( >2MB), ich wette, das sind weit mehr als 50 Graustufen!

Zweitens: Haben Sie eine bessere y-Koordinate

Ich konnte es mir nicht leisten, eine andere zufällig generierte Koordinatentabelle für die yAchse zu erstellen. Daher brauchte ich eine einfache Methode, um " zufällige " Koordinaten mit so wenigen Zeichen wie möglich zu erhalten. Ich ging für die Verwendung des xin der Tabelle von einem anderen Punkt koordinieren, um eine bitweise tut ANDauf dem Index des Punktes.

3. Ich erinnere mich nicht, aber es wird schön

Aber zu dieser Zeit war ich weit über 140 Zeichen, so dass ich es ziemlich viel Golf spielen musste.

Viertens: Scanlines

Nur ein Scherz, das ist nicht erwünscht, aber irgendwie cool.

Ich arbeite immer noch an der Verkleinerung des Algorithmus und bin stolz darauf, Folgendes präsentieren zu können:

StarFox Edition

Voronoi instagram

5. Erhöhen Sie die Anzahl der Punkte

Ich habe jetzt ein funktionierendes Stück Code, gehen wir also von 25 auf 60 Punkte.

Das ist auf nur einem Bild schwer zu erkennen, aber die Punkte befinden sich fast alle im selben yBereich. Natürlich habe ich die bitweise Operation nicht geändert, &42ist viel besser:

Und hier sind wir am selben Punkt wie das allererste Bild aus diesem Beitrag. Lassen Sie uns nun den Code für die seltenen erklären, die interessiert wären.

Ungolfed und erklärt Code

unsigned short red_fn(int i, int j)
{
    int t[64],          // table of 64 points's x coordinate
        k = 0,          // used for loops
        l,              // retains the index of the nearest point
        e,              // for intermediary results
        d = 2e7;        // d is the minimum distance to the (i,j) pixel encoutnered so far
        // it is initially set to 2e7=2'000'000 to be greater than the maximum distance 1024²

    srand(time(0));     // seed for random based on time of run
    // if the run overlaps two seconds, a split will be observed on the red diagram but that is
    // the better compromise I found

    while(k < 64)       // for every point
    {
        t[k] = rand() % DIM;        // assign it a random x coordinate in [0, 1023] range
        // this is done at each call unfortunately because static keyword and srand(...)
        // were mutually exclusive, lenght-wise

        if (
            (e=                         // assign the distance between pixel (i,j) and point of index k
                _sq(i - t[k])           // first part of the euclidian distance
                +
                _sq(j - t[42 & k++])    // second part, but this is the trick to have "" random "" y coordinates
                // instead of having another table to generate and look at, this uses the x coordinate of another point
                // 42 is 101010 in binary, which is a better pattern to apply a & on; it doesn't use all the table
                // I could have used 42^k to have a bijection k <-> 42^k but this creates a very visible pattern splitting the image at the diagonal
                // this also post-increments k for the while loop
            ) < d                       // chekcs if the distance we just calculated is lower than the minimal one we knew
        )
        // {                            // if that is the case
            d=e,                        // update the minimal distance
            l=k;                        // retain the index of the point for this distance
            // the comma ',' here is a trick to have multiple expressions in a single statement
            // and therefore avoiding the curly braces for the if
        // }
    }

    return t[l];        // finally, return the x coordinate of the nearest point
    // wait, what ? well, the different areas around points need to have a
    // "" random "" color too, and this does the trick without adding any variables
}

// The general idea is the same so I will only comment the differences from green_fn
unsigned short green_fn(int i, int j)
{
    static int t[64];       // we don't need to bother a srand() call, so we can have these points
    // static and generate their coordinates only once without adding too much characters
    // in C++, objects with static storage are initialized to 0
    // the table is therefore filled with 60 zeros
    // see http://stackoverflow.com/a/201116/1119972

    int k = 0, l, e, d = 2e7;

    while(k<64)
    {
        if( !t[k] )                 // this checks if the value at index k is equal to 0 or not
        // the negation of 0 will cast to true, and any other number to false
            t[k] = rand() % DIM;    // assign it a random x coordinate

        // the following is identical to red_fn
        if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)
            d=e,l=k;
    }

    return t[l];
}

Vielen Dank fürs Lesen.

Das Lyapunov-Fraktal

Die Zeichenfolge, die verwendet wurde, um dies zu generieren, war AABAB und der Parameterraum war [2,4] x [2,4]. ( Erklärung von String und Parameterraum hier )

Mit begrenztem Code-Platz fand ich diese Färbung ziemlich cool.

    //RED
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s);
    //GREEN
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return s>0?s:0;
    //BLUE
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s*x);

Ich habe auch eine Variation des Mandelbrot-Sets gemacht. Es wird eine Karte verwendet, die der Mandelbrot-Set-Karte ähnelt. Sagen Sie, M (x, y) ist die Mandelbrot-Karte. Dann ist M (sin (x), cos (y)) die Abbildung, die ich verwende, und anstatt zu prüfen, ob escape-Werte vorhanden sind, verwende ich x und y, da sie immer begrenzt sind.

//RED
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 2.5*(x*x+y*y);
//GREEN
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(x);
//BLUE
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(y);

BEARBEITEN

Nach langem Hin und Her habe ich mich endlich daran gemacht, ein GIF für das Morphing des zweiten Bildes zu erstellen. Hier ist es:

Weil Einhörner.

Ich konnte die OPs-Version mit unsigned shortund Farbwerten bis 1023 nicht zum Laufen bringen. Bis dies behoben ist, ist hier eine Version mit charund einem maximalen Farbwert von 255.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}

Logistische Hügel

Die Funktionen

unsigned char RD(int i,int j){    
    #define A float a=0,b,k,r,x
    #define B int e,o
    #define C(x) x>255?255:x
    #define R return
    #define D DIM
    R BL(i,j)*(D-i)/D;
}
unsigned char GR(int i,int j){      
    #define E DM1
    #define F static float
    #define G for(
    #define H r=a*1.6/D+2.4;x=1.0001*b/D
    R BL(i,j)*(D-j/2)/D;
}
unsigned char BL(int i,int j){
    F c[D][D];if(i+j<1){A;B;G;a<D;a+=0.1){G b=0;b<D;b++){H;G k=0;k<D;k++){x=r*x*(1-x);if(k>D/2){e=a;o=(E*x);c[e][o]+=0.01;}}}}}R C(c[j][i])*i/D;
}

Ungolfed

Alle #Definitionen müssen für BL unter 140 Zeichen passen. Hier ist die ungolfed Version des blauen Algorithmus, leicht modifiziert:

for(double a=0;a<DIM;a+=0.1){       // Incrementing a by 1 will miss points
    for(int b=0;b<DIM;b++){         // 1024 here is arbitrary, but convenient
        double r = a*(1.6/DIM)+2.4; // This is the r in the logistic bifurcation diagram (x axis)
        double x = 1.0001*b/DIM;    // This is x in the logistic bifurcation diagram (y axis). The 1.0001 is because nice fractions can lead to pathological behavior.
        for(int k=0;k<DIM;k++){
            x = r*x*(1-x);          // Apply the logistic map to x
            // We do this DIM/2 times without recording anything, just to get x out of unstable values
            if(k>DIM/2){
                if(c[(int)a][(int)(DM1*x)]<255){
                    c[(int)a][(int)(DM1*x)]+=0.01; // x makes a mark in c[][]
                } // In the golfed code, I just always add 0.01 here, and clip c to 255
            }
        }            
    }    
}

Wo die Werte von x für ein gegebenes r (j-Wert) am häufigsten fallen, wird die Darstellung heller (normalerweise als dunkler dargestellt).

Diffusionslimitierte Aggregation

Ich war schon immer fasziniert von der diffusionsbegrenzten Aggregation und der Anzahl der unterschiedlichen Erscheinungsformen in der realen Welt.

Ich fand es schwierig, dies in nur 140 Zeichen pro Funktion zu schreiben, daher musste ich den Code schrecklich machen (oder schön, wenn Sie Dinge wie ++d%=4und mögen for(n=1;n;n++)). Die drei Farbfunktionen rufen sich gegenseitig auf und definieren Makros zur gegenseitigen Verwendung, sodass sie nicht gut lesbar sind, aber jede Funktion hat knapp 140 Zeichen.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-(BL(i,j))/2:0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

Um zu veranschaulichen, wie sich die Partikel allmählich ansammeln, habe ich in regelmäßigen Abständen Schnappschüsse angefertigt. Jeder Frame wurde durch Ersetzen der 1 for(n=1;n;n++)durch 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29 erzeugt. 1. Dadurch wurde das Limit von 140 Zeichen für jeden Lauf knapp unterschritten.

Sie können sehen, dass Aggregate, die nahe beieinander wachsen, sich gegenseitig die Partikel entziehen und langsamer wachsen.

Wenn Sie den Code geringfügig ändern, werden die verbleibenden Partikel angezeigt, die noch nicht an den Aggregaten haften. Dies zeigt die dichteren Regionen, in denen das Wachstum schneller erfolgt, und die sehr spärlichen Regionen zwischen Aggregaten, in denen aufgrund des Verbrauchs aller Partikel kein Wachstum mehr stattfinden kann.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-BL(i,j):0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

Dies kann auf die gleiche Weise wie zuvor animiert werden:

Spirale (genau 140)

Das sind genau 140 Zeichen, wenn Sie die Funktionsüberschriften und -klammern nicht einschließen. Es ist so viel Spiralkomplexität, wie ich in die Zeichenbegrenzung einpassen könnte.

unsigned char RD(int i,int j){
    return DIM-BL(2*i,2*j);
}
unsigned char GR(int i,int j){
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    i-=512;j-=512;int d=sqrt(i*i+j*j);return d+atan2(j,i)*82+sin(_cr(d*d))*32+sin(atan2(j,i)*10)*64;
}

Nach und nach baute ich eine einfache Spirale auf, fügte Muster an den Spiralrändern hinzu und experimentierte, wie verschiedene Spiralen kombiniert werden könnten, um cool auszusehen. Hier ist eine ungolfed Version mit Kommentaren, die erklären, was jedes Stück macht. Das Spielen mit Parametern kann zu interessanten Ergebnissen führen.

unsigned char RD(int i,int j){
    // *2 expand the spiral
    // DIM- reverse the gradient
    return DIM - BL(2*i, 2*j);
}
unsigned char GR(int i,int j){
    // notice swapped parameters
    // 128 changes phase of the spiral
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    // center it
    i -= DIM / 2;
    j -= DIM / 2;

    double theta = atan2(j,i); //angle that point is from center
    double prc = theta / 3.14f / 2.0f; // percent around the circle

    int dist = sqrt(i*i + j*j); // distance from center

    // EDIT: if you change this to something like "prc * n * 256" where n
    //   is an integer, the spirals will line up for any arbitrarily sized
    //   DIM value, or if you make separate DIMX and DIMY values!
    int makeSpiral = prc * DIM / 2;

    // makes pattern on edge of the spiral
    int waves = sin(_cr(dist * dist)) * 32 + sin(theta * 10) * 64;

    return dist + makeSpiral + waves;
}

Spielerisch mit Parametern:

Hier sind die Spiralen aneinander gereiht, haben aber unterschiedliche Kantenmuster. Anstelle der blockartigen Kanten im Hauptbeispiel weist dies Kanten auf, die vollständig aus Sinuswellen bestehen.

Hier wurde der Farbverlauf entfernt:

Eine Animation ( die sich aus irgendeinem Grund nach dem Hochladen nicht zu wiederholen scheint. Tut mir leid. Außerdem musste ich sie verkleinern. Öffne sie einfach in einem neuen Tab, wenn du die Animation verpasst hast. ):

Und hier ist das Imgur-Album mit allen Bildern. Ich würde gerne sehen, ob jemand andere coole Spiralmuster findet. Außerdem muss ich sagen, dass dies bei weitem eine der coolsten Herausforderungen ist, die ich je gesehen habe. Genießen!

EDIT: Hier sind einige Hintergründe aus diesen Spiralen mit geänderten Parametern.

Durch Kombinieren meiner Spiralkantenmuster mit einigen der Fraktale, die ich hier durch die Verwendung von xor / und / oder Operationen gesehen habe, ist hier eine letzte Spirale:

Hommage an einen Klassiker

V1 : Inspiriert von DreamWarriors "Be happy", bettet diese einfache Einreichung ein kleines Pixel-Art-Bild in jeden Farbkanal ein. Ich musste nicht einmal den Code spielen!
V2 : jetzt mit erheblich kürzerem Code und einem dicken schwarzen Rand, der nur den "Spielbildschirm" isoliert.
V3 : Raumschiff, Kugel, beschädigte Aliens und blaue Grenze, oh mein Gott! Der Versuch , für Ziel dieses grob.

// RED
#define g(I,S,W,M)j/128%8==I&W>>(j/32%4*16+i/64)%M&S[abs(i/4%16-8)-(I%2&i%64<32)]>>j/4%8&1
return g(1,"_\xB6\\\x98\0\0\0",255L<<36,64)?j:0;

// GREEN
#define S g(6,"\xFF\xFE\xF8\xF8\xF8\xF8\xF0\x0",1L<<22,64)|i/4==104&j/24==30
return g(2,"<\xBC\xB6}\30p\0\0",4080,32)|S?j:0;

// BLUE
return g(3,"_7\xB6\xFE\x5E\34\0",0x70000000FD0,64)|S|abs(i/4-128)==80&abs(j/4-128)<96|abs(j/4-128)==96&abs(i/4-128)<80?j:0;

Ich bin zufällig auf einen Schnitt von Umber Ferrule gestoßen, dessen Avatar mich dazu inspiriert hat, einen weiteren pixelbasierten Eintrag hinzuzufügen. Da die Kernidee des Codes weitgehend der von Space Invaders ähnelt, füge ich sie diesem Eintrag hinzu, obwohl die beiden definitiv unterschiedliche herausfordernde Punkte hatten. In diesem Fall erwies es sich als schöne Herausforderung, Pink richtig zu machen (auf Kosten von Weiß) und die Tatsache, dass es sich um ein ziemlich großes Sprite handelt. Die hexadezimalen Escapes ( \xFFusw.) im roten Kanal stellen die entsprechenden Zeichen in der Quelldatei dar (dh der rote Kanal in der Quelldatei enthält Binärdaten), während die oktalen Escapes literal sind (dh in der Quelldatei vorhanden sind).

// RED
#define g(S)(S[i/29%18*2+j/29/8%2]>>j/29%8&1)*DM1*(abs(i-512)<247&abs(j-464)<232)
return g("\xF3\xF2\xF2\x10\xF4\0\xF2\x10\xE1\xE0\x81\0\x80\0\x80\0\0\0\0\0@\0! \x03d8,=\x2C\x99\x84\xC3\x82\xE1\xE3");

// GREEN
return g(";\376z\34\377\374\372\30k\360\3\200\0\0\0\0\0\0\200\0\300\0\341 \373d\307\354\303\374e\374;\376;\377")? DM1 : BL(i,j)? DM1/2 : 0;

// BLUE
return g("\363\360\362\20\364\0\362\20\341\340\200\0\200\0\200\0\0\0\0\0\0\0\0\0\0\08\0<\0\230\0\300\0\341\340") / 2;

Action-Malerei

Ich wollte versuchen, etwas Ähnliches wie Jackson Pollock nachzubilden - Farbe über eine horizontale Leinwand zu tropfen und zu gießen. Obwohl mir die Ergebnisse gefallen haben, war der Code viel zu lang, um auf diese Frage zu antworten, und meine besten Bemühungen haben ihn immer noch auf etwa 600 Byte reduziert. Der hier veröffentlichte Code (mit Funktionen von 139 Bytes, 140 Bytes und 140 Bytes) wurde mit enormer Hilfe einiger Genies im Chat erstellt . Vielen Dank an:

• Eric Tressler
• FireFly
• PhiNotPi
• Martin Büttner

für eine unerbittliche gruppen-golfsitzung.

unsigned char RD(int i,int j){
#define E(q)return i+j?T-((T-BL(i,j))*q):T;
#define T 255
#define R .1*(rand()%11)
#define M(v)(v>0&v<DIM)*int(v)
#define J [j]*250;
E(21)}

unsigned char GR(int i,int j){
#define S DIM][DIM],n=1e3,r,a,s,c,x,y,d=.1,e,f;for(;i+j<1&&n--;x=R*DM1,y=R*DM1,s=R*R*R*R,a=R*7,r=s*T)for(c=R;r>1;x+=s*cos(a),y+=s*sin
E(21)}

unsigned char BL(int i,int j){static float m[S(a),d=rand()%39?d:-d,a+=d*R,s*=1+R/99,r*=.998)for(e=-r;e++<r;)for(f=-r;f++<r;)m[M(x+e)*(e*e+f*f<r)][M(y+f)]=c;return T-m[i]J}

Das E (q) -Makro wird in den RD- und GR-Funktionen verwendet. Durch Ändern des Werts des Arguments wird die Art und Weise geändert, in der sich die roten und grünen Komponenten der Farben ändern. Das J-Makro endet mit einer Zahl, mit der bestimmt wird, wie stark sich die blaue Komponente ändert, was sich wiederum auf die rote und die grüne Komponente auswirkt, da sie daraus berechnet werden. Ich habe einige Bilder mit den roten und grünen Argumenten von E hinzugefügt, um die Vielfalt der möglichen Farbkombinationen zu zeigen. Bewegen Sie den Mauszeiger über die Bilder für die roten und grünen Werte, wenn Sie diese selbst ausführen möchten.

Alle diese Bilder können in voller Größe angezeigt werden, wenn Sie sie herunterladen. Die Dateigröße ist klein, da die flache Farbe dem PNG-Komprimierungsalgorithmus entspricht. Daher war keine verlustbehaftete Komprimierung erforderlich, um auf die Site hochzuladen.

Wenn Sie Bilder aus verschiedenen Phasen des Golfspiels sehen möchten, während wir verschiedene Dinge ausprobiert haben, können Sie im Action-Painting-Chat nachsehen .

Ich dachte, ich würde mit den Parametern dieses Codes spielen ... Das gesamte Guthaben geht an @Manuel Kasten. Diese sind einfach so cool, dass ich nicht widerstehen konnte, etwas zu posten.

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 1000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);

BubbleGumRupture http://i57.tinypic.com/3150eqa.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 40*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 10*pow((n)/800,.5);

SeussZoom http://i59.tinypic.com/am3ypi.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 4000*pow((n)/800,.5);

SeussEternalForest http://i61.tinypic.com/35akv91.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);

Bearbeiten: Dies ist jetzt eine gültige Antwort, dank der Vorwärtserklärungen von GRund BL.

Viel Spaß mit Hofstädters Q-Sequenz! Wenn wir den radialen Abstand von einem Punkt als Eingabe und die Ausgabe als Umkehrfarbe verwenden, erhalten wir etwas, das wie farbiges Vinyl aussieht.

Die Sequenz ist der Fibonacci-Sequenz sehr ähnlich, aber anstatt 1 und 2 Schritte in der Sequenz zurückzugehen, nehmen Sie die beiden vorherigen Werte, um zu bestimmen, wie weit Sie zurückgehen müssen, bevor Sie die Summe nehmen. Es wächst ungefähr linear, aber hin und wieder kommt es (in zunehmenden Abständen) zu einem Chaosausbruch, der sich dann vor dem nächsten Ausbruch wieder in einer fast linearen Reihenfolge niederschlägt:

Sie können diese Wellen im Bild nach Regionen sehen, die in der Farbe sehr "flach" aussehen.

Nur eine Farbe zu verwenden ist natürlich langweilig.

Nun zum Code. Ich brauche die rekursive Funktion, um die Sequenz zu berechnen. Dazu benutze ich RDwann immer jes negativ ist. Leider, das nicht verlassen genug Zeichen Rotkanalwert selbst zu berechnen, so RDruft wiederum GRmit einem den roten Kanal zu erzeugen , versetzt.

unsigned short RD(int i,int j){
    static int h[1000];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):GR(i+256,j+512);
}
unsigned short GR(int i,int j){
    return DIM-4*RD(sqrt((i-512)*(i-512)+(j-768)*(j-768))/2.9,-1);
}
unsigned short BL(int i,int j){
    return DIM-4*RD(sqrt((i-768)*(i-768)+(j-256)*(j-256))/2.9,-1);
}

Dies ist natürlich so ziemlich die einfachste Verwendung der Sequenz, und es sind noch viele Zeichen übrig. Fühlen Sie sich frei, es auszuleihen und andere verrückte Dinge damit zu tun!

Hier ist eine andere Version, bei der die Grenze und die Farben durch die Q-Sequenz bestimmt werden. In diesem Fall war genügend Platz, RDso dass ich nicht einmal die Forward-Deklaration brauchte:

unsigned short RD(int i,int j){
    static int h[1024];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):RD(2*RD(i,-1)-i+512>1023-j?i:1023-i,-1)/0.6;
}
unsigned short GR(int i,int j){
    return RD(i, j);
}
unsigned short BL(int i,int j){
    return RD(i, j);
}

Dies berechnet die Joukowsky-Transformation eines Satzes konzentrischer Kreise, die auf einem Punkt zentriert sind, der geringfügig vom Ursprung versetzt ist. Ich habe die Intensitäten im blauen Kanal leicht verändert, um ein wenig Farbabweichung zu erzielen.

unsigned short RD(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s,n=hypot(r+(.866-r/2)/q,s+(r*.866+s/2)/q),
    d=.5/log(n);if(d<0||d>1)d=1;return d*(sin(n*10)*511+512);
}
unsigned short GR(int i,int j){
    return 0;
}
unsigned short BL(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s;return RD(i,j)*sqrt(q/40);
}

Ziel c

Den C ++ - Code in Objective-C umgeschrieben, da ich ihn nicht kompilieren konnte ... Es gab die gleichen Ergebnisse wie andere Antworten, wenn es auf meinem iPad ausgeführt wurde, das ist also alles gut.

Hier ist mein Beitrag:

Der Code dahinter ist ziemlich einfach:

unsigned short red_fn(int i,int j)
{
    return j^j-i^i;
}
unsigned short green_fn(int i,int j)
{
    return (i-DIM)^2+(j-DIM)^2;
}
unsigned short blue_fn(int i,int j)
{
    return i^i-j^j;
}

Sie können in auf Plätzen vergrößern durch Multiplikation iund jdurch 0.5, 0.25usw. , bevor sie verarbeitet werden.

Sierpinski Paint Splash

Ich wollte mehr mit Farben spielen, also änderte ich meine andere Antwort (die wirbelnde) und endete schließlich damit.

unsigned short RD(int i,int j){
    return(sqrt(_sq(abs(73.-i))+_sq(abs(609.-j)))+1.)/abs(sin((sqrt(_sq(abs(860.-i))+_sq(abs(162.-j))))/115.)+2)/(115^i&j);
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(abs(160.-i))+_sq(abs(60.-j)))+1.)/abs(sin((sqrt(_sq(abs(73.-i))+_sq(abs(609.-j))))/115.)+2)/(115^i&j);
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(abs(600.-i))+_sq(abs(259.-j)))+1.)/abs(sin((sqrt(_sq(abs(250.-i))+_sq(abs(20.-j))))/115.)+2)/(115^i&j);
}

Es ist jetzt mein Avatar. : P

Ich fühle mich gezwungen, diesen Eintrag einzureichen, den ich als "undefiniertes Verhalten" bezeichne. Dies zeigt, was Ihr Compiler mit Funktionen macht, die einen Wert zurückgeben sollen, dies aber nicht tun:

unsigned short red_fn(int i,int j){}
unsigned short green_fn(int i,int j){}
unsigned short blue_fn(int i,int j){}

Alle schwarzen Pixel:

Pseudozufällige Pixel:

Und natürlich eine Vielzahl weiterer möglicher Ergebnisse, abhängig von Ihrem Compiler, Computer, Speichermanager usw.

groovig

Nur ein paar Trigonometrie und seltsame Makrotricks.

RD:

#define I (i-512)
#define J (j-512)
#define A (sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

GR:

#undef A
#define A (M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

BL:

#undef A
#define A (2*M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

BEARBEITEN: Wenn dies M_PInicht zulässig ist, weil es nur auf POSIX-kompatiblen Systemen vorhanden ist, kann es durch das Literal ersetzt werden 3.14.

Ich kann nicht gut rechnen. Ich war immer ein schlechter Schüler im Matheunterricht. Also habe ich einfach eins gemacht.

Ich habe modifiziert Javascript-Code von user1455003 verwendet . Und das ist mein vollständiger Code .

function red(x, y) {
    return (x + y) & y;
}

function green(x, y) {
    return (255 + x - y) & x;
}

function blue(x, y) {
    // looks like blue channel is useless
    return Math.pow(x, y) & y;
}

Es ist sehr kurz, sodass alle drei Funktionen in einen Tweet passen.

function red(x, y) {
    return Math.cos(x & y) << 16;
}

function green(x, y) {
    return red(DIM - x, DIM - y);
}

function blue(x, y) {
    return Math.tan(x ^ y) << 8;
}

Eine weitere sehr kurze Funktionen. Ich habe dieses Sierpinski-Muster (und einige Tangentenmuster) gefunden, als ich mit verschiedenen mathematischen Funktionen rumgespielt habe.Dies ist der vollständige Code

JavaScript

var can = document.createElement('canvas');
can.width=1024;
can.height=1024;
can.style.position='fixed';
can.style.left='0px';
can.style.top='0px';
can.onclick=function(){
  document.body.removeChild(can);
};

document.body.appendChild(can);

var ctx = can.getContext('2d');
var imageData = ctx.getImageData(0,0,1024,1024);
var data = imageData.data;
var x = 0, y = 0;
for (var i = 0, len = data.length; i < len;) {
    data[i++] = red(x, y) >> 2;
    data[i++] = green(x, y) >> 2;
    data[i++] = blue(x, y) >> 2;
    data[i++] = 255;
    if (++x === 1024) x=0, y++;
}
ctx.putImageData(imageData,0,0);

function red(x,y){
if(x>600||y>560) return 1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function green(x,y){
if(x>600||y>560) return y%160<80?0:1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:1024;
}

Andere Version. Funktionskörper sind tweetbar.

function red(x,y){
c=x*y%1024
if(x>600||y>560) return c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function green(x,y){
c=x*y%1024
if(x>600||y>560) return y%160<80?0:c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:x*y%1024;
}

Überarbeitete Bildrenderfunktion. draw (rgbFunctions, setCloseEvent);

function draw(F,e){
    var D=document
    var c,id,d,x,y,i,L,s=1024,b=D.getElementsByTagName('body')[0]
    c=D.createElement('canvas').getContext('2d')
    if(e)c.canvas.onclick=function(){b.removeChild(c.canvas)}
    b.appendChild(c.canvas)
    c.canvas.width=c.canvas.height=s
    G=c.getImageData(0,0,s,s)
    d=G.data
    x=y=i=0;
    for (L=d.length;i<L;){
        d[i++]=F.r(x,y)>>2
        d[i++]=F.g(x,y)>>2
        d[i++]=F.b(x,y)>>2
        d[i++]=255;
        if(++x===s)x=0,y++
    }
    c.putImageData(G,0,0)
}

Lila

var purple = {
    r: function(i,j) {
        if (j < 512) j=1024-j
        return (i % j) | i
    },
    g: function(i,j){
        if (j < 512) j = 1024 -j
        return (1024-i ^ (i %j)) % j
    },
    b: function(i,j){
        if (j < 512) j = 1024 -j
        return 1024-i | i+j %512
    }
};

draw(purple,true);

Planetenmaler

//red
static int r[DIM];int p=rand()%9-4;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//green
static int r[DIM];int p=rand()%7-3;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//blue
static int r[DIM];int p=rand()%15-7;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;

Inspiriert von Martins offensichtlich großartigem Beitrag , ist dies eine andere Einstellung dazu. Anstatt einen Teil der Pixel zufällig auszusondern, beginne ich mit der linken oberen Ecke als RGB (512.512.512) und gehe von dort aus auf jeder Farbe zufällig spazieren. Das Ergebnis sieht aus wie ein Teleskop (imo).

Jedes Pixel nimmt den Durchschnitt der darüber / links liegenden Pixel und fügt ein bisschen Zufall hinzu. Sie können mit der Variabilität spielen, indem Sie die pVariable ändern , aber ich denke, ich verwende eine gute Balance (hauptsächlich, weil ich blau mag, damit mehr Unschärfevolatilität gute Ergebnisse liefert).

Bei der Mittelwertbildung kommt es zu einer leichten negativen Verzerrung durch die Ganzzahldivision. Ich denke, es funktioniert jedoch und gibt der unteren Ecke einen schönen Verdunkelungseffekt.

Natürlich müssen Sie srand()Ihrer Hauptfunktion eine Zeile hinzufügen, um mehr als nur ein einziges Ergebnis zu erhalten .

Reflektierte Wellen

unsigned char RD(int i,int j){
#define A static double w=8000,l,k,r,d,p,q,a,b,x,y;x=i;y=j;for(a=8;a+9;a--){for(b=8;b+9;b--){l=i-a*DIM-(int(a)%2?227:796);
return 0;}

unsigned char GR(int i,int j){
#define B k=j-b*DIM-(int(b)%2?417:606);r=sqrt(l*l+k*k);d=16*cos((r-w)/7)*exp(-_sq(r-w)/120);p=d*l/r;q=d*k/r;x-=p;y-=q;}}
return 0;}

unsigned char BL(int i,int j){AB
return (int(x/64)+int(y/64))%2*255;}

Ein grundlegendes Schachbrettmuster, das entsprechend der Position einer Welle verzerrt ist, die sich von einem Punkt aus aus ausdehnt, wie ein Stein, der in einen Teich gefallen ist (sehr weit von der physischen Genauigkeit entfernt!). Die Variable wist die Anzahl der Pixel von dem Punkt an, an dem sich die Welle bewegt hat. Wenn wes groß genug ist, wird die Welle von den Seiten des Bildes reflektiert.

w = 225

w = 360

w = 5390

Hier ist ein GIF, das eine Folge von Bildern zeigt, wenn sich die Welle ausdehnt. Ich habe eine Reihe verschiedener Größen angegeben, von denen jede so viele Frames anzeigt, wie es die maximale Dateigröße von 500 KB zulässt.

Wenn ich einen Weg finden kann, wie ich ihn einpassen kann, möchte ich im Idealfall eine Welleninterferenz modellieren, damit die Wellen realistischer aussehen, wenn sie sich kreuzen. Ich bin jedoch mit dem Nachdenken zufrieden.

Beachten Sie, dass ich die Wellenreflexion in 3 Lots von 140 Bytes nicht wirklich modelliert habe. Es wird nicht wirklich darüber nachgedacht, es sieht einfach so aus. Ich habe die Erklärung ausgeblendet, falls jemand zuerst raten möchte:

Die erste reflektierte Welle ist identisch mit einer Welle, die von der anderen Seite der Bildkante ausgeht und denselben Abstand wie der ursprüngliche Punkt hat. Der Code berechnet also die richtige Position für die 4 Punkte, die erforderlich sind, um den Reflexionseffekt von jeder der 4 Kanten zu erzielen. Weitere Ebenen der reflektierten Welle sind alle mit einer Welle identisch, die aus einer weiteren entfernten Kachel stammt, wenn Sie sich das Bild als eine Kachel in einer Ebene vorstellen. Der Code gibt die Illusion von 8 Reflexionsebenen, indem 189 separate expandierende Kreise angezeigt werden, die jeweils an der richtigen Stelle in einem 17 x 17-Raster platziert sind, sodass sie durch das zentrale Quadrat des Rasters (dh das Bildquadrat) bei gehen genau die richtigen Zeiten, um einen Eindruck von der geforderten aktuellen Reflexionsstärke zu bekommen. Das ist einfach (und kurz!) Zu programmieren, läuft aber ziemlich langsam ...