Les mathématiques entières peuvent générer des motifs étonnants lorsqu'elles sont disposées sur une grille. Même les fonctions les plus élémentaires peuvent donner des designs incroyablement élaborés!

Votre challenge

Ecrivez 3 corps de fonction tweetable (c'est-à-dire 140 caractères ou moins) pour les valeurs rouge, verte et bleue pour une image 1024x1024.

Les entrées des fonctions seront deux entiers i (numéro de colonne pour le pixel donné) et j (numéro de ligne pour le pixel donné) et la sortie sera un court-circuit non signé compris entre 0 et 1023 inclus, ce qui représente le montant de la valeur donnée. couleur présente dans le pixel (i, j).

Par exemple, les trois fonctions suivantes produisent l'image ci-dessous:

/* 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;

Les règles

• Étant donné ce code C ++ , remplacez-le dans vos fonctions. J'ai fourni quelques macros et inclus la bibliothèque, et vous pouvez inclure complex.h. Vous pouvez utiliser toutes les fonctions de ces bibliothèques et / ou de mes macros. Veuillez ne pas utiliser de ressources externes au-delà de cela.

• Si cette version ne fonctionne pas pour vous, assurez-vous de compiler avec:

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

  Si cela ne fonctionne pas, veuillez utiliser la version alternative en utilisant des caractères non signés au lieu de courts non signés.

Michaelangelo a fourni une version de sortie couleur nettoyée 24 bits ou 48 bits .

• Vous pouvez implémenter votre propre version dans un autre langage, mais celle-ci doit se comporter de la même manière que la version C ++ fournie. Seules les fonctions des éléments intégrés de C ++, de la bibliothèque ou des macros fournies peuvent être utilisées pour la rendre juste.
• Publiez uniquement vos trois corps de fonction - veuillez ne pas inclure mon code dans votre message
• Veuillez inclure une version plus petite ou une copie intégrée de votre image. Ils sont convertis au format ppm et doivent éventuellement être convertis en un autre format pour une visualisation correcte sur stackexchange.
• Les corps de fonction (signature non comprise) doivent comporter 140 caractères au maximum.
• Ceci est un concours de popularité - la plupart des votes sont gagnants

Mandelbrot 3 x 133 caractères

La première chose qui me vint à l'esprit fut "Mandelbrot!".

Oui, je sais qu'il y a déjà une soumission de mandelbrot. Après avoir confirmé que je pouvais le faire moi-même en-dessous de 140 caractères, j'ai pris les astuces et optimisations de cette solution dans la mienne (merci à Martin et Todd). Cela laissait de la place pour choisir un emplacement et un zoom intéressants, ainsi qu’un joli thème de couleur:

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 caractères au total

J'ai essayé de le réduire à 140 pour les 3 canaux. Il y a un peu de bruit de couleur près du bord, et l'emplacement n'est pas aussi intéressant que le premier, mais: 132 caractères

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

Nappes

Plat

J'ai commencé par mettre en perspective un motif à carreaux / vichy comme une nappe sans limite:

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

Ondulation

Ensuite, j'ai introduit une ondulation (perspective non strictement correcte, mais toujours en 140 caractères):

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

Couleur

Ensuite, j'ai rendu certaines couleurs plus fines pour donner des détails sur une gamme plus large d’échelles et pour rendre la photo plus colorée ...

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

En mouvement

Réduire légèrement le code permet de définir une phase d'onde P avec 2 décimales, ce qui suffit pour des images suffisamment proches pour une animation fluide. À ce stade, j’ai réduit l’amplitude afin d’éviter le mal de mer et redéfini l’ensemble de l’image de 151 pixels supplémentaires (au prix d’un caractère supplémentaire) afin de faire disparaître le repliement du spectre. Le crénelage animé est hypnotique.

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

Peintre au hasard

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

Voici une entrée basée sur le hasard. Pour environ 0,1% des pixels, il choisit une couleur aléatoire, pour les autres, il utilise la même couleur qu'un pixel adjacent aléatoire. Notez que chaque couleur le fait de manière indépendante. Il ne s’agit donc que d’une superposition d’images aléatoires de couleur verte, bleue et rouge. Pour obtenir des résultats différents sur différentes exécutions, vous devez ajouter srand(time(NULL))à la mainfonction.

Maintenant, pour quelques variations.

En sautant des pixels, nous pouvons le rendre un peu plus flou.

Et puis, nous pouvons changer lentement les couleurs, où les débordements se traduisent par des changements brusques qui font que cela ressemble encore plus à des coups de pinceau.

Les choses que j'ai besoin de comprendre:

• Pour une raison quelconque, je ne peux pas mettre sranddans ces fonctions sans obtenir une erreur de segmentation.
• Si je pouvais rendre les marches aléatoires identiques sur les trois couleurs, cela pourrait sembler un peu plus ordonné.

Vous pouvez également rendre la marche aléatoire isotrope, comme

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

pour te donner

Plus de peintures aléatoires

J'ai joué un peu plus avec cela et créé d'autres peintures aléatoires. Tous ne sont pas possibles dans les limites de ce défi, je ne souhaite donc pas les inclure ici. Mais vous pouvez les voir dans cette galerie imgur avec quelques descriptions de la façon dont je les ai produites.

Je suis tenté de développer toutes ces possibilités dans un cadre et de le mettre sur GitHub. (Ce genre de choses n'existe pas déjà, mais c'est amusant quand même!)

Certaines choses swirly pointy

Oui, je savais exactement comment l'appeler.

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

EDIT: n'utilise plus pow. EDIT 2: @PhiNotPi a fait remarquer que je n'ai pas besoin d'utiliser autant d'abs.

Vous pouvez changer les points de référence assez facilement pour obtenir une image différente:

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 a souligné que Batman était dans mes images.

Bien sûr, il doit y avoir une soumission de Mandelbrot.

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

Essayer d'améliorer le jeu de couleurs maintenant. Est-ce une erreur si je définis le calcul comme une macro red_fnet que je l' utilise dans les deux autres, de sorte que j'ai plus de caractères pour la sélection de couleurs fantaisie en vert et en bleu?

Edit: Il est très difficile de trouver des schémas de couleurs corrects avec ces quelques octets restants. Voici une autre version:

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

Et selon la suggestion de githubphagocyte et les améliorations de Todd Lehman, nous pouvons facilement choisir des sections plus petites:

Par exemple

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

donne

Julia définit

S'il y a un Mandelbrot, il devrait y avoir aussi un set Julia.

Vous pouvez passer des heures à peaufiner les paramètres et les fonctions, ce qui en fait un modèle rapide et élégant.

Inspiré de la participation de Martin.

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

Voulez-vous du RNG?

OK, le commentaire de Sparr m'a mis sur la piste pour randomiser les paramètres de ce petit Julias. J'ai d'abord essayé de faire du piratage au niveau des bits avec le résultat de, time(0)mais le C ++ n'autorisant pas les littératures hexadécimales à virgule flottante, il s'agissait donc d'une impasse (du moins, à ma connaissance,). J'aurais pu utiliser des castings lourds pour y parvenir, mais cela n'aurait pas été compris dans les 140 octets.

De toute façon, il ne me restait plus beaucoup de place, alors j’ai dû laisser tomber la Julia rouge pour pouvoir mettre mes macros et disposer d’un RNG plus conventionnel ( timegraine d et réelle rand(), woohoo!).

Oups, il manque quelque chose. Évidemment, ces paramètres doivent être statiques ou vous aurez des résultats étranges (mais drôle, peut-être que je vais étudier un peu plus tard si je trouve quelque chose d’intéressant).

Nous y sommes donc, avec uniquement les canaux vert et bleu:

Ajoutons maintenant un motif rouge simple pour combler le vide. Pas vraiment imaginatif, mais je ne suis pas un programmeur graphique ... pour le moment :-)

Et enfin le nouveau code avec des paramètres aléatoires:

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

Il y a encore de la place maintenant ...

Celui-ci est intéressant car il n'utilise pas du tout les paramètres i, j. Au lieu de cela, il se souvient de l'état d'une variable statique.

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: C'est un véritable Buddhabrot maintenant!

Edit: j'ai réussi à limiter l'intensité de la couleur dans la limite d'octet, de sorte qu'il n'y ait plus de pixels faussement noirs en raison du débordement.

Je voulais vraiment m'arrêter après quatre heures ... mais ...

Ceci est légèrement compressé pendant le téléchargement (et réduit lors de l'intégration), donc si vous voulez admirer tous les détails, voici l'intéressant recadrage 512x512 (qui n'est pas compressé et est affiché dans sa taille réelle):

Merci à githubphagocyte pour l'idée. Cela nécessitait un abus assez compliqué des trois fonctions de couleur:

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

Il reste quelques octets pour un meilleur jeu de couleurs, mais jusqu'à présent, je n'ai rien trouvé qui vaille mieux que l'image en niveaux de gris.

Le code, tel qu'il est donné, utilise 4096 x 4096 points de départ et effectue jusqu'à 500 000 itérations sur chacune d'elles pour déterminer si les trajectoires s'échappent ou non. Cela a pris entre 6 et 7 heures sur ma machine. Vous pouvez obtenir des résultats corrects avec une grille de 2k par 2k et 10k itérations, ce qui prend deux minutes, et même une grille de 1k par 1k avec 1k itérations est très jolie (cela prend environ 3 secondes). Si vous souhaitez modifier ces paramètres, vous devez modifier quelques éléments:

• Pour modifier la profondeur de récursion de Mandelbrot, ajustez les deux instances de 5e5dans BLvotre nombre d'itérations.
• Pour modifier la résolution de la grille, changer tous les quatre 4096dans RDla résolution désirée et 1024.dans GRle même facteur pour maintenir la mise à l' échelle correcte.
• Vous aurez probablement aussi besoin de redimensionner l' return c[i][j]in dans la GRmesure où cela contient uniquement le nombre absolu de visites de chaque pixel. La couleur maximale semble être la plupart du temps indépendante du nombre d'itérations et évolue linéairement avec le nombre total de points de départ. Donc, si vous voulez utiliser une grille de 1k sur 1k, vous pouvez le faire return c[i][j]*16;ou similaire, mais ce facteur nécessite parfois quelques manipulations.

Pour ceux qui ne connaissent pas Buddhabrot (comme moi il y a quelques jours), il est basé sur le calcul de Mandelbrot, mais l'intensité de chaque pixel correspond à la fréquence de visite de ce pixel dans les itérations des trajectoires d'échappement. Si nous comptons les visites lors de trajectoires non échappées, c'est un Antibuddhabrot. Il existe une version encore plus sophistiquée appelée Nebulabrot dans laquelle vous utilisez une profondeur de récursivité différente pour chaque canal de couleur. Mais je laisserai cela à quelqu'un d'autre. Pour plus d' informations, comme toujours, Wikipedia .

À l'origine, je ne faisais pas la distinction entre les trajectoires d'échappement et les trajectoires sans fuite. Cela a généré un complot qui est l'union d'un Buddhabrot et d'un Antibuddhabrot (comme indiqué par githubphagocyte).

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

Celui-ci ressemble un peu à une photo fanée ... J'aime ça.

Sierpinski Pentagon

Vous avez peut-être vu la méthode du jeu du chaos consistant à approximer le triangle de Sierpinski en traçant des points à mi-chemin d'un sommet choisi au hasard. Ici, j'ai adopté la même approche en utilisant 5 sommets. Le code le plus court sur lequel je pouvais me résoudre incluait le codage en dur des 5 sommets, et il n’était pas question pour moi d’adapter tout cela à 140 caractères. J'ai donc délégué le composant rouge à un fond simple et utilisé l'espace disponible dans la fonction rouge pour définir une macro afin de ramener les deux autres fonctions à moins de 140 également. Donc, tout est valable au prix de ne pas avoir de composant rouge dans le pentagone.

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

Merci à Martin Büttner pour l’idée mentionnée dans les commentaires de la question sur la définition d’une macro dans une fonction à utiliser ensuite dans une autre, ainsi que pour l’utilisation de la mémoire pour remplir les pixels dans un ordre arbitraire plutôt que de se limiter à l’ordre de trame de la fonction principale .

L'image dépasse 500 Ko. Elle est donc automatiquement convertie en jpg par échange de pile. Cela brouille certains des détails les plus fins. J'ai donc également inclus le quart supérieur droit sous forme de png pour montrer le look original:

Partition

Sierpinski musique. : D Les gars sur le chat disent qu'il ressemble plus au papier perforé pour les boîtes à musique.

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

Quelques détails sur la façon dont cela fonctionne ... euh, il ne s'agit en fait que d'un zoom avant sur le rendu de certains triangles de Sierpinski ondulés. L'aspect de la partition (et son aspect bloc) est le résultat d'une troncature d'entier. Si je change la fonction rouge à, par exemple,

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

la troncature est supprimée et nous obtenons le rendu en pleine résolution:

Alors oui, c'est intéressant.

Quelqu'un at-il un générateur de diagramme aléatoire de Voronoï ?

OK, celui-ci m'a donné du fil à retordre. Je pense que c’est plutôt bien, même si les résultats ne sont pas aussi artistiques que d’autres. C'est l'affaire avec le hasard. Certaines images intermédiaires semblent peut-être meilleures, mais je voulais vraiment avoir un algorithme pleinement fonctionnel avec des diagrammes de voronoï.

Modifier:

Ceci est un exemple de l'algorithme final. L'image est fondamentalement la superposition de trois diagrammes de voronoï, un pour chaque composante de couleur (rouge, vert, bleu).

Code

non golfé, version commentée à la fin

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

Il m'a fallu beaucoup d'efforts, alors j'ai envie de partager les résultats à différentes étapes, et il y en a de bonnes (incorrectes) à montrer.

Première étape: placer quelques points au hasard, avec x=y

Je l'ai converti en jpeg parce que le png original était trop lourd pour upload ( >2MB), je parie que c'est bien plus de 50 nuances de gris!

Deuxièmement: avoir une meilleure coordonnée y

Je ne pouvais pas se permettre d'avoir une autre table de coordonnées générées au hasard pour l' yaxe, donc je besoin d' un moyen simple d'obtenir « au hasard » les dans le moins de caractères possible. Je suis allé en utilisant les xcoordonnées d'un autre point de la table, en faisant un bitwise ANDsur l'index du point.

3ème: je ne m'en souviens pas mais ça commence à bien

Mais à cette époque, j’avais dépassé les 140 personnages, j’avais donc besoin de beaucoup jouer au golf.

4ème: lignes de balayage

Je plaisante, ce n'est pas voulu, mais plutôt cool, il me semble.

Toujours en train de réduire la taille de l'algorithme, je suis fier de présenter:

Édition StarFox

Voronoï instagram

5ème: augmenter le nombre de points

J'ai maintenant un morceau de code de travail, passons donc de 25 à 60 points.

C'est difficile à voir à partir d'une seule image, mais les points sont presque tous situés dans la même yplage. Bien sûr, je n'ai pas changé l'opération bitwise, &42c'est bien mieux:

Et nous sommes au même point que la toute première image de ce post. Expliquons maintenant le code pour les rares qui seraient intéressés.

Ungolfed et expliqué le 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];
}

Merci d'avoir lu jusqu'ici.

La fractale de Lyapunov

La chaîne utilisée pour générer ceci était AABAB et l'espace de paramètre était [2,4] x [2,4]. ( explication de la chaîne et de l'espace de paramètre ici )

Avec un espace de code limité, je pensais que cette coloration était plutôt 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);

J'ai également fait une variante de l'ensemble Mandelbrot. Il utilise une carte similaire à celle de Mandelbrot. Dites M (x, y) est la carte de Mandelbrot. Alors M (sin (x), cos (y)) est la carte que j’utilise, et au lieu de rechercher les valeurs qui échappent, j’utilise x, et y car elles sont toujours délimitées.

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

MODIFIER

Après beaucoup de douleur, j'ai finalement réussi à créer un gif de la deuxième image en train de se transformer. C'est ici:

Parce que les licornes.

Je ne pouvais pas utiliser la version OP avec unsigned shortdes valeurs de couleur allant jusqu'à 1023. Donc, jusqu'à ce que cela soit corrigé, voici une version utilisant charune valeur de couleur maximale de 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);
}

Collines Logistiques

Les fonctions

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

Toutes les définitions doivent correspondre à BL sous 140 caractères. Voici la version non-golfée de l'algorithme bleu, légèrement modifié:

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

Là où les valeurs de x tombent le plus souvent pour une valeur donnée de r (j), le graphique devient plus clair (généralement décrit comme plus sombre).

Diffusion Agrégation Limitée

J'ai toujours été fasciné par l' agrégation limitée par la diffusion et le nombre de façons dont elle apparaît dans le monde réel.

J'ai eu du mal à écrire ceci en seulement 140 caractères par fonction, j'ai donc dû rendre le code horrible (ou beau, si vous aimez les choses comme ++d%=4et for(n=1;n;n++)). Les trois fonctions de couleur s'appellent et définissent les macros à utiliser. La lecture est donc difficile, mais chaque fonction comporte un peu moins de 140 caractères.

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

Pour visualiser comment les particules s'agrègent progressivement, j'ai produit des instantanés à intervalles réguliers. Chaque image a été produite en remplaçant le 1 for(n=1;n;n++)par 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Cela le maintient juste sous la limite de 140 caractères pour chaque exécution.

Vous pouvez voir que les agrégats qui se développent proches se privent les uns des autres de particules et croissent plus lentement.

En modifiant légèrement le code, vous pouvez voir les particules restantes qui ne sont pas encore attachées aux agrégats. Cela montre les régions plus denses où la croissance va se produire plus rapidement et les régions très clairsemées entre les agrégats où aucune croissance ne peut plus se produire car toutes les particules ont été épuisées.

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

Cela peut être animé de la même manière qu'auparavant:

Spirale (140 exactement)

Cela correspond exactement à 140 caractères si vous n'incluez pas les en-têtes et les crochets de la fonction. C'est autant de complexité en spirale que je pourrais tenir dans la limite de personnage.

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

J'ai progressivement construit sur une simple spirale, en ajoutant des motifs sur les bords de la spirale et en expérimentant comment différentes spirales pourraient être combinées pour donner un aspect cool. Voici une version non-golfée avec des commentaires expliquant le rôle de chaque pièce. Jouer avec les paramètres peut produire des résultats intéressants.

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

Jouer avec les paramètres:

Ici, les spirales sont alignées mais présentent des motifs de bord différents. Au lieu des arêtes de blocs dans l'exemple principal, elle a des arêtes entièrement composées d'ondes de péché.

Ici, le dégradé a été supprimé:

Une animation ( qui, pour une raison quelconque, ne semble pas boucler une fois après l'avoir téléchargée, désolée. J'ai également dû la réduire. Ouvrez-la dans un nouvel onglet si vous avez raté l'animation ):

Et voici l' album imgur avec toutes les images qu'il contient . J'aimerais voir si quelqu'un peut trouver d'autres motifs en spirale sympas. En outre, je dois dire que c’est de loin l’un des défis les plus intéressants que j’ai jamais vu. Prendre plaisir!

EDIT: Voici quelques fonds réalisés à partir de ces spirales avec des paramètres modifiés.

De plus, en combinant mes motifs de bords en spirale avec certaines des fractales que j'ai vues ici grâce à l'utilisation de xor / et / ou d'opérations, voici une dernière spirale:

Hommage à un classique

V1 : Inspirée par "Be happy" de DreamWarrior, cette soumission simple incorpore une petite image pixel-art dans chaque canal de couleur. Je n'ai même pas eu à jouer au code!
V2 : maintenant avec un code considérablement plus court et une bordure noire épaisse n'isolant que "l'écran de jeu".
V3 : vaisseau spatial, balle, aliens endommagés et bordure bleue, oh mon dieu! Essayer de viser cela , à peu près.

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

Je suis tombé par hasard sur un montage de Umber Ferrule dont l'avatar m'a inspiré pour ajouter une autre entrée basée sur le pixel art. Puisque l'idée de base du code est en grande partie similaire à celle de Space Invaders, je l'ajoute à cette entrée, bien que les deux aient clairement des points de défi différents. Pour ce dernier, obtenir le bon rose (au détriment du blanc) et le fait qu’il s’agisse d’un sprite plutôt grand ont été de bons défis. Les caractères d'échappement hexadécimaux ( \xFFetc.) du canal rouge représentent les caractères correspondants dans le fichier source (le canal rouge du fichier source contient des données binaires), alors que les caractères d'échappement en octal sont littéraux (c'est-à-dire présents dans le fichier source).

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

Peinture d'action

Je voulais essayer de recréer quelque chose de similaire au travail de Jackson Pollock - des gouttes d'eau et de la peinture coulée sur une toile horizontale. Bien que j'aie aimé les résultats, le code a été beaucoup trop long à poster sur cette question et mes meilleurs efforts n'ont encore réduit que 600 octets environ. Ainsi, le code publié ici (qui a des fonctions respectives de 139 octets, 140 octets et 140 octets) a été produit avec une aide considérable de la part de certains génies du chat . Grand merci à:

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

pour une session de golf en groupe sans répit.

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}

La macro E (q) est utilisée dans les fonctions RD et GR. Changer la valeur de l'argument change la façon dont les composants rouge et vert des couleurs changent. La macro J se termine par un nombre qui sert à déterminer l'ampleur de la modification de la composante bleue, ce qui affecte les composantes rouge et verte car elles sont calculées à partir de celle-ci. J'ai inclus quelques images avec les arguments rouge et vert de E variés pour montrer la variété de combinaisons de couleurs possibles. Survolez les images pour les valeurs rouge et verte si vous souhaitez les exécuter vous-même.

Toutes ces images peuvent être visualisées en taille réelle si vous les téléchargez. La taille du fichier est petite, car la couleur plate convient à l'algorithme de compression PNG. Aucune compression avec perte n'était donc nécessaire pour télécharger sur le site.

Si vous souhaitez voir des images de différentes étapes du processus de golf alors que nous avons essayé différentes choses, vous pouvez regarder dans le chat de peinture d'action .

Je pensais jouer avec les paramètres de ce code ... Tout le mérite revient à @Manuel Kasten. Ce sont tellement cool que je ne pouvais pas résister à poster.

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

Edit: C’est maintenant une réponse valable, grâce aux déclarations forward de GRetBL .

S'amuser avec la séquence Q de Hofstadter! Si nous utilisons la distance radiale d'un point comme entrée et la sortie comme couleur inverse, nous obtenons quelque chose qui ressemble à du vinyle coloré.

La séquence est très similaire à la séquence de Fibonacci, mais au lieu de revenir en arrière de 1 à 2 étapes, vous prenez les deux valeurs précédentes pour déterminer le retour avant de prendre la somme. Il se développe grossièrement linéaire, mais de temps en temps, il y a une rafale de chaos (à des intervalles croissants) qui se résout ensuite en une séquence presque linéaire avant la prochaine rafale:

Vous pouvez voir ces ondulations dans l'image après les régions qui ont une couleur très "plate".

Bien sûr, utiliser une seule couleur est ennuyeux.

Maintenant pour le code. J'ai besoin de la fonction récursive pour calculer la séquence. Pour ce faire, je l'utilise RDchaque fois que jc'est négatif. Malheureusement, cela ne laisse pas assez de caractères pour calculer la valeur du canal rouge lui-même, donc RDappelle à son tour GRavec un décalage pour produire le canal rouge.

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

Bien sûr, c’est à peu près l’utilisation la plus simple possible de la séquence, et il reste encore beaucoup de caractères. N'hésitez pas à l'emprunter et à faire d'autres choses folles avec!

Voici une autre version où la limite et les couleurs sont déterminées par la séquence Q. Dans ce cas, il y avait assez de place RDpour que je n'ai même pas besoin de la déclaration anticipée:

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

Ceci calcule la transformation de Joukowsky d'un ensemble de cercles concentriques centrés sur un point légèrement décalé par rapport à l'origine. J'ai légèrement modifié les intensités dans le canal bleu pour donner un peu de variation de couleur.

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

Objectif c

Réécrivez le code C ++ dans Objective-C parce que je ne pouvais pas le compiler ... Il donnait les mêmes résultats que les autres réponses lorsque je courais sur mon iPad, alors tout va bien.

Voici ma soumission:

Le code derrière est assez simple:

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

Vous pouvez zoomer sur les carrés en les multipliant iet jpar 0.5, 0.25etc. avant qu'ils ne soient traités.

Sierpinski Paint Splash

Je voulais jouer plus avec les couleurs, donc j'ai continué à changer mon autre réponse (la swirly) et finalement j'ai fini avec ça.

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

C'est mon avatar maintenant. : P

Je me sens obligé de soumettre cette entrée que j'appellerai "comportement indéfini", ce qui illustrera ce que fait votre compilateur avec les fonctions censées renvoyer une valeur mais ne:

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

Tous les pixels noirs:

Pixels pseudo-aléatoires:

Et bien sûr, une foule d'autres résultats possibles en fonction de votre compilateur, ordinateur, gestionnaire de mémoire, etc.

sensationnel

Juste quelques trigonométrie et astuces macro bizarres.

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;

EDIT: si ce M_PIn’est pas autorisé car uniquement sur les systèmes compatibles POSIX, il peut être remplacé par le littéral 3.14.

Je ne suis pas bon en maths. J'ai toujours été pauvre élève en classe de mathématiques. Alors j'ai fait simple.

J'ai utilisé le code Javascript modifié de l'utilisateur 1455003 . Et ceci est mon code complet .

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

Il est très court pour que les trois fonctions tiennent dans un tweet.

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

Une autre fonction très courte. J'ai trouvé ce motif sierpinski (et un motif tangent) en jouant avec diverses fonctions mathématiques. C'est le code complet

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

Une autre version. les corps de fonction sont tweetables.

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

Fonction de rendu d'image révisée. 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)
}

Violet

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

Peintre planétaire

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

Inspiré par Martin superbe entrée , il s'agit d'une approche différente. Au lieu d'ensemencer de manière aléatoire une partie des pixels, je commence par le coin supérieur gauche sous le nom de RVB (512 512 512), puis effectue des marches aléatoires sur chaque couleur à partir de là. Le résultat ressemble à quelque chose d'un télescope (imo).

Chaque pixel prend la moyenne des pixels au-dessus / à gauche de celui-ci et ajoute un bit aléatoire. Vous pouvez jouer avec la variabilité en changeant lap variable, mais je pense que ce que j'utilise est un bon équilibre (principalement parce que j'aime le bleu, donc plus de volatilité du flou donne de bons résultats).

Il y a un léger biais négatif de la division entière lors de la moyenne. Je pense que cela fonctionne, cependant, et donne un bel effet d'assombrissement au coin inférieur.

Bien sûr, pour obtenir plus d'un résultat, vous devez ajouter une srand()ligne à votre fonction principale.

Ondes réfléchies

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

Un motif de base d'échiquier déformé en fonction de la position d'une vague se dilatant à partir d'un point semblable à une pierre tombée dans un étang (très loin de la précision physique!). La variable west le nombre de pixels à partir de ce point que la vague a déplacé. Si elle west suffisamment grande, l’onde reflète les côtés de l’image.

w = 225

w = 360

w = 5390

Voici un GIF montrant une succession d’images au fur et à mesure que la vague s’étend. J'ai fourni un certain nombre de tailles différentes, chacune montrant autant d'images que la limite de taille de fichier de 500 Ko le permet.

Si je peux trouver un moyen de l'adapter, j'aimerais idéalement que les interférences de vagues soient modélisées de manière à ce que les ondes aient l'air plus réalistes lorsqu'elles se croisent. Je suis content de la réflexion cependant.

Notez que je n'ai pas vraiment modélisé la réflexion d'onde dans 3 lots de 140 octets. Il n'y a pas vraiment de réflexion en cours, il lui arrive juste de ressembler à ça. J'ai caché l'explication au cas où quelqu'un voudrait deviner en premier:

La première onde réfléchie est identique à une onde provenant de l'autre côté du bord de l'image, à la même distance que le point d'origine. Le code calcule donc la position correcte pour les 4 points requis pour obtenir l’effet de réflexion de chacune des 4 arêtes. Les autres niveaux d'ondes réfléchies sont tous identiques à une onde provenant d'une tuile plus éloignée, si vous imaginez l'image comme une tuile dans un plan. Le code donne l’illusion de 8 niveaux de réflexion en affichant 189 cercles en expansion distincts, chacun placé au bon endroit dans une grille de 17 sur 17, de sorte qu’ils traversent le carré central de la grille (c’est-à-dire le carré de l’image) à juste le bon moment pour donner l’impression du niveau de réflexion actuel requis. C’est simple (et bref!) De coder, mais s’exécute assez lentement ...