整数数学布局在网格上时可以生成惊人的模式。即使是最基本的功能，也可以完成精美的设计！

你的挑战

为1024x1024图像的红色，绿色和蓝色值编写3个Tweetable（表示140个字符或更少）功能体。

函数的输入将是两个整数i（给定像素的列号）和j（给定像素的行号），输出将是0到1023（含）之间的无符号短整数，表示给定的数量像素（i，j）中存在的颜色。

例如，以下三个函数产生以下图片：

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

规则

• 有了此C ++代码，就可以替换您的函数。我提供了一些宏，并包含了该库，并且您可能包含complex.h。您可以使用这些库和/或宏中的任何函数。请不要使用超出此范围的任何外部资源。

• 如果该版本不适合您，请确保您使用的是：

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

  如果这不起作用，请使用使用未签名字符而不是未签名短裤的备用版本。

Michaelangelo提供了清理后的24位或48位彩色输出版本。

• 您可以用另一种语言实现自己的版本，但是它的行为方式必须与提供的C ++版本相同，并且只能使用C ++内置函数，库或提供的宏中的函数来使其公平。
• 仅发布您的三个功能主体-请不要在帖子中包含我的代码
• 请提供图像的较小版本或嵌入式副本。它们被制成ppm格式，可能需要转换为其他格式才能在stackexchange上正确查看。
• 功能主体（不包括签名）必须为140个字符或更少。
• 这是一次人气竞赛-多数选票获胜

Mandelbrot 3 x 133字符

我想到的第一件事是“ Mandelbrot！”。

是的，我知道已经有一份mandelbrot提交。在确认自己可以将字符数降低到140个字符以下之后，我就从该解决方案中获得了技巧和优化，并将其引入了我的设计（感谢Martin和Todd）。剩下的空间用于选择一个有趣的位置和缩放以及一个不错的颜色主题：

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个字符

我试图将所有3个频道的频道数量降低到140个。边缘附近有一些色噪，位置不如第一个有趣，但是：132个字符

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

桌布

平面

我开始将格子/格子图案放到无边桌布的角度来看：

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

波纹

然后，我介绍了一个涟漪图（不是严格正确的透视图，但仍然是140个字符）：

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

颜色

然后，我将一些颜色进行了更细化，以在更宽的比例范围内提供细节，并使图像更加色彩丰富。

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

运动中

稍微减少代码就可以定义一个具有2个小数位的波动相位P，这对于足够接近平滑动画的帧就足够了。为了避免引起晕船，我在此阶段减小了幅度，并将整个图像再向上移动了151个像素（以增加1个字符为代价），以将混叠推离图像的顶部。动画别名令人着迷。

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

随机画家

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

这是一个基于随机性的条目。对于约0.1％的像素，它选择一种随机颜色，对于其他像素，它使用与随机相邻像素相同的颜色。请注意，每种颜色都是独立执行的，因此实际上这只是随机的绿色，蓝色和红色图片的叠加。为了在不同的运行中获得不同的结果，您需要将其添加srand(time(NULL))到main函数中。

现在进行一些更改。

通过跳过像素，我们可以使其更加模糊。

然后我们可以慢慢改变颜色，溢出会导致颜色突然变化，这使外观看起来更像画笔描边

我需要弄清楚的事情：

• 由于某些原因，我无法srand在没有分段的情况下放入这些函数。
• 如果我可以使所有三种颜色的随机游走都相同，则它看起来可能会更加有序。

您还可以使随机游走各向同性，例如

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

为你带来

更多随机绘画

我已经玩了更多，并创作了一些其他随机绘画。在挑战的限制范围内，并非所有这些方法都是可行的，因此我不想在这里包括它们。但是您可以在此imgur画廊中看到它们，以及一些有关如何生产它们的描述。

我很想将所有这些可能性开发成一个框架并将其放在GitHub上。（并不是像这样的东西还不存在，但还是很有趣！）

一些尖锐的东西

是的，我确切知道它的名字。

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

编辑：不再使用pow。 编辑2： @PhiNotPi指出，我不需要使用Abs太多。

您可以很容易地更改参考点以获得不同的图片：

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指出我的照片中有蝙蝠侠。

当然，必须有一个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;
}

现在尝试改善配色方案。如果我将计算定义为一个宏red_fn并在其他两个宏中使用该宏，以便我有更多的字符可以选择绿色和蓝色的奇特颜色，这是否作弊？

编辑：很难用剩下的几个字节来提出合适的配色方案。这是另一个版本：

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

根据githubphagocyte的建议以及Todd Lehman的改进，我们可以轻松地选择较小的部分：

例如

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

给

朱莉娅集

如果有Mandelbrot，也应该有Julia集。

您可能需要花费数小时来调整参数和功能，所以这只是看起来不错的一种快速操作。

受到马丁的参与启发。

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

您想要一些RNG吗？

好的，Sparr的评论使我走上了轨道，以随机化这些小Julias的参数。我首先尝试使用的结果进行位级黑客攻击，time(0)但C ++不允许使用十六进制浮点数，因此这是一个死胡同（至少据我所知）。我本可以使用一些繁重的转换来实现这一点，但是这不适合140个字节。

无论如何，我没有多少余地，所以我不得不放下红色的Julia来放置宏，并使用更常规的RNG（timed种子和real rand()，hoohoo！）。

糟糕，缺少某些内容。显然，这些参数必须是静态的，否则您将得到一些奇怪的结果（但有趣的是，如果发现一些有趣的东西，也许以后我会进行调查）。

因此，这里是绿色和蓝色通道：

现在让我们添加一个简单的红色图案来填补空白。不太有想像力，但我不是图形程序员...：:)

最后是带有随机参数的新代码：

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

现在还剩下房间了...

这个很有趣，因为它根本不使用i，j参数。相反，它会在静态变量中记住状态。

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（+反buddhabrot）

编辑：现在是正确的Buddhabrot了！

编辑：我设法将颜色强度限制在字节限制内，因此不再有由于溢出而造成的错误黑色像素。

我真的很想在四点钟之后停下来...但是...

上载时会略微压缩（嵌入后会缩小），因此，如果您想欣赏所有细节，可以裁剪出有趣的512x512（不会压缩，并以完整尺寸显示）：

感谢githubphagocyte这个想法。这需要对所有三种颜色功能进行相当复杂的滥用：

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

还有一些字节可用于更好的配色方案，但到目前为止，我还没有发现任何能胜过灰度图像的东西。

给出的代码使用4096x4096起点，并且对每个起点进行多达500,000次迭代，以确定轨迹是否逃逸。在我的机器上花费了6到7个小时。您可以通过2k x 2k网格和10k迭代获得体面的结果，这需要两分钟，而即使是1k x 1k网格和1k迭代看起来也很不错（大约需要3秒）。如果您想弄乱这些参数，则需要更改一些地方：

• 要更改Mandelbrot递归深度，请将5e5in的两个实例调整BL为您的迭代计数。
• 要更改网格分辨率，请将所有四个4096in 更改RD为所需的分辨率，并以相同的系数将1024.in GR更改为正确的缩放比例。
• 您可能还需要缩放return c[i][j]，GR因为其中仅包含每个像素的绝对访问次数。最大颜色似乎主要与迭代次数无关，并且与起点总数成线性比例。因此，如果您想使用1k x 1k的网格，则可能需要return c[i][j]*16;或类似的方法，但是该因素有时需要一些摆弄。

对于不熟悉Buddhabrot的人（几天前像我一样），它基于Mandelbrot计算，但是每个像素的强度是在逃逸轨迹的迭代中访问该像素的频率。如果我们要计算在非逃逸轨迹期间的造访次数，那是一个防盗陀螺。还有一个称为Nebulabrot的更为复杂的版本，其中您为每个颜色通道使用不同的递归深度。但我会留给别人。与往常一样，更多信息，请参阅Wikipedia。

最初，我无法区分转义轨迹和非转义轨迹。这产生了一个图，该图是Buddhabrot和Antibuddhabrot的结合体（如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;
}

这张看起来有点像一张褪色的照片...我喜欢。

西尔平斯基五角大楼

您可能已经看到了通过将点绘制到随机选择的顶点的一半来逼近Sierpinski三角形的混沌游戏方法。在这里，我采用了5个顶点的相同方法。我可以确定的最短代码包括对5个顶点进行硬编码，而且我不可能将所有这些都适合140个字符。因此，我已将红色组件委托给一个简单的背景，并使用红色函数中的备用空间定义了一个宏，以将其他两个函数也置于140以下。因此，一切都是有效的，但五边形中没有红色成分。

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

感谢MartinBüttner在问题的评论中提到的想法，即在一个函数中定义宏然后在另一个函数中使用，以及使用备忘录以任意顺序填充像素，而不是受限于主函数的栅格顺序。

图片超过500KB，因此可以通过堆栈交换自动转换为jpg。这模糊了一些更好的细节，因此我还只包括了右上四分之一的png，以显示原始外观：

乐谱

谢尔宾斯基音乐。：D聊天的人说，它看起来更像是音乐盒的打孔纸。

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

有关其工作原理的一些细节...嗯，实际上，它只是放大一些波浪形Sierpinski三角形的渲染。乐谱的外观（以及块状感）是整数截断的结果。如果我将红色功能更改为

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

截断被删除，我们得到完整的分辨率渲染：

是的，这很有趣。

随机Voronoi图生成器有人吗？

好，这个给我带来了困难。即使结果不像其他一些那么狡猾，我也认为这很好。那就是随机性。也许某些中间图像看起来更好，但是我真的想使用voronoi图实现一个完全有效的算法。

编辑：

这是最终算法的一个示例。该图像基本上是三个voronoi图的叠加，每种颜色分量（红色，绿色，蓝色）一个。

码

末尾未评论的版本

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

我花了很多精力，所以我觉得要在不同阶段共享结果，并且要显示一些不错的（不正确的）结果。

第一步：将一些点随机放置 x=y

我已将其转换为jpeg，因为原始png太重而无法上传（>2MB），所以我敢打赌，它的灰度超过50种！

第二：拥有更好的y坐标

我负担不起为该y轴随机生成另一个坐标表，因此我需要一种简单的方法来以尽可能少的字符获得“随机”坐标。我通过对x点AND的索引进行按位操作来使用表中另一点的坐标。

第三名：我不记得了，但是越来越好

但是这一次我已经超过140个字符，所以我需要打很多球。

第四条：扫描线

只是开玩笑，这不是想要的，而是一种很酷的方法。

我仍在努力减小算法的大小，我很自豪地提出：

StarFox版

Voronoi Instagram

第五：增加积分

我现在有一段有效的代码，所以让我们从25点提高到60点。

仅从一张图像很难看到，但是这些点几乎都位于同一y范围内。当然，我没有更改按位运算，&42更好：

在这里，与本文的第一张图片相同。现在，让我们解释一下感兴趣的罕见代码。

取消解释的代码

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

感谢您到目前为止的阅读。

Lyapunov分形

用于生成该字符串的字符串是AABAB，参数空间为[2,4] x [2,4]。（这里对字符串和参数空间的说明）

由于代码空间有限，我认为这种着色非常酷。

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

我还对Mandelbrot集进行了更改。它使用类似于Mandelbrot集地图的地图。说M（x，y）是Mandelbrot地图。然后M（sin（x），cos（y））是我使用的映射，而不是检查转义值，我使用x和y，因为它们始终是有界的。

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

编辑

经过一番痛苦之后，我终于开始创建第二个图像变形的gif。这里是：

因为独角兽。

我无法使用unsigned short颜色值高达1023 的OP版本，因此在修复该问题之前，这里是使用char最大颜色值为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);
}

物流山

功能

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

不打高尔夫球

所有的#define都适合140个字符以下的BL。这是蓝色算法的简化版本：

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

对于给定的r（j值），x的值下降最多的地方，曲线变得更亮（通常描绘为更暗）。

扩散受限聚集

我一直着迷于扩散限制聚合及其在现实世界中出现的不同方式。

我发现很难用每个函数仅用140个字符来编写此代码，因此我不得不使代码变得可怕（或者，如果您喜欢++d%=4和一样的东西，那就太漂亮了for(n=1;n;n++)）。这三个颜色函数相互调用并定义了彼此要使用的宏，因此读取效果不佳，但是每个函数都不足140个字符。

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

为了可视化粒子如何逐渐聚集，我定期生成快照。通过将1 in替换为for(n=1;n;n++)0，-1 << 29，-2 << 29，-3 << 29、4 << 29、3 << 29、2 << 29、1 << 29， 1.这样可以使每次运行的字符数保持在140个字符以下。

您会看到，聚集体彼此靠近生长会彼此剥夺颗粒，并且生长会更加缓慢。

通过稍微更改代码，您可以看到尚未附着到聚合的其余粒子。这显示了密度较高的区域，其生长将更快地发生，而聚集体之间的区域非常稀疏，由于所有颗粒都被耗尽，因此无法再发生生长。

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

可以采用与以前相同的方式设置动画：

螺旋形（正好140个）

如果不包括函数标题和括号，则这是140个字符。我可以适应字符限制中的螺旋式复杂度。

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

我逐渐建立在一个简单的螺旋上，在螺旋边缘上添加了图案，并尝试了如何组合不同的螺旋以使其看起来很酷。这是一个非高尔夫版本，带有注释，解释了每件作品的功能。弄乱参数可以产生一些有趣的结果。

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

混乱的参数：

在这里，螺旋线排列但具有不同的边缘图案。代替主要示例中的块状边缘，它具有完全由正弦波组成的边缘。

在这里，渐变已被删除：

动画（由于某种原因，在我上传动画后，它似乎并没有循环播放，很抱歉。此外，我还必须缩小动画。如果错过了动画，只需在新选项卡中将其打开）：

而且，这是imgur专辑包含所有图像。我很想看看是否有人可以找到其他炫酷的螺旋花纹。而且，我必须说，这是迄今为止我所见过的最酷的挑战之一。请享用！

编辑：这是一些由这些螺旋线制成的背景，参数已更改。

另外，通过将我的螺旋边缘图案与通过使用异或/和/或运算在这里看到的一些分形相结合，这是最终的螺旋：

向经典致敬

V1：受DreamWarrior的“变得快乐”的启发，这种直观的呈现方式在每个颜色通道中都嵌入了一个小像素艺术图像。我什至不必打高尔夫球！
V2：现在具有较短的代码和较粗的黑色边框，仅将“游戏屏幕”隔离开了。
V3：飞船，子弹，受损的外星人和蓝色边框，哦，我的天！试图瞄准这个，大概。

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

我偶然发现Umber Ferrule的编辑，他的头像启发了我添加另一个基于像素艺术的作品。由于代码的核心思想与“太空侵略者”基本相似，因此我将其添加到本条目中，尽管两者肯定具有不同的挑战点。为此，正确地粉红色（以白色为代价）以及它是一个相当大的精灵的事实证明是不错的挑战。\xFF红色通道中的十六进制转义符（等）表示它们在源文件中的相应字符（即，源文件中的红色通道包含二进制数据），而八进制转义符是文字的（即存在于源文件中）。

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

动作绘画

我想尝试重新创建类似于杰克逊·波洛克（Jackson Pollock）的作品-在水平画布上滴下油漆。尽管我喜欢这个结果，但是代码太长了，无法发布到这个问题，尽我最大的努力仍然只能将其减少到大约600字节。因此，这里发布的代码（分别具有139个字节，140个字节和140个字节的功能）是在chat中一些天才的帮助下产生的。非常感谢：

• 埃里克·特雷斯勒
• 萤火虫
• 皮诺皮
• 马丁·布特纳

进行无休止的团体高尔夫比赛。

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}

E（q）宏用于RD和GR函数。更改参数的值会更改颜色的红色和绿色分量的更改方式。J宏以一个数字结尾，该数字用于确定蓝色分量的变化量，这又会影响红色和绿色分量，因为它们是根据它们计算得出的。我提供了一些带有E的红色和绿色参数的图像，以显示可能的多种颜色组合。如果要自己运行这些图像，请将鼠标悬停在图像上以获取红色和绿色值。

如果下载所有这些图像，则可以全尺寸查看。文件大小较小，因为纯色适合PNG压缩算法，因此不需要有损压缩即可上传到站点。

如果您想在尝试各种事情的同时查看高尔夫过程中各个阶段的图像，可以在动作绘画聊天中查看。

想通了我会使用此代码的参数...所有功劳归@Manuel Kasten。这些太酷了，我无法抗拒发布。

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

苏斯永恒森林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);

编辑：现在这是一个有效的答案，这要归功于前申报GR和BL。

体验霍夫施塔特的Q序列！如果我们将某个点的径向距离用作输入，将输出用作反色，则得到的东西看起来像彩色乙烯基。

该序列与斐波那契数列非常相似，但是您无需在序列中返回1和2步，而是取前两个值来确定在求和之前要返回多远。它大致呈线性增长，但是时不时地出现一阵混乱（以不断增加的间隔），然后在下一个突发之前再次稳定到几乎线性的序列：

您可以在颜色看起来非常“平坦”的区域之后的图像中看到这些波纹。

当然，仅使用一种颜色很无聊。

现在获取代码。我需要递归函数来计算序列。要做到这一点，我会RD在任何时候j都是负面的。不幸的是，这并没有留下足够的字符来计算红色通道值本身，因此RD依次调用GR了偏移量以产生红色通道。

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

当然，这几乎是该序列最简单的用法，并且还剩下许多字符。随意借用它，并用它做其他疯狂的事情！

这是边界和颜色由Q序列确定的另一个版本。在这种情况下，有足够的空间，RD所以我什至不需要前向声明：

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

这将计算以从原点稍微偏移的点为中心的一组同心圆的Joukowsky变换。我稍微修改了蓝色通道的强度，以产生一些颜色变化。

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

目标C

在Objective-C cos中重写了C ++代码，我无法对其进行编译...在iPad上运行时，它得到的结果与其他答案相同，所以这很好。

这是我的意见书：

其背后的代码非常简单：

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

你可以乘以放大广场i和j通过0.5，0.25在处理之前等。

Sierpinski油漆飞溅

我想用更多的颜色玩游戏，所以我不断更改其他答案（涡旋式答案），最终得到答案。

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

现在是我的头像。：P

我不得不提交此条目，我将其称为“未定义行为”，这将说明您的编译器对应该返回值但不返回值的函数的作用：

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

全黑像素：

伪随机像素：

当然，还有许多其他可能的结果，具体取决于您的编译器，计算机，内存管理器等。

时髦

只是一些三角学和怪异的宏技巧。

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;

编辑：如果M_PI由于仅存在于POSIX兼容系统上而不被允许，则可以将其替换为文字3.14。

我数学不好。我在数学课上总是很贫穷的学生。所以我做了一个简单的。

我使用了修改过的user1455003的Javascript代码。而这是我的全部代码。

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

它非常短，因此所有三个功能都合而为一。

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

另一个很短的功能。我在弄乱各种数学函数的同时发现了这种sierpinski模式（和一些切线模式）。这是完整的代码

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

另一个版本。功能体是可发推的。

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

修订的图像渲染功能。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)
}

紫色

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

行星画家

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

受到马丁的启发 出色入门的，这是另一回事。我没有随机播种一部分像素，而是从左上角开始为RGB（512,512,512），然后从那里对每种颜色进行随机遍历。结果看起来像是来自望远镜（imo）的东西。

每个像素取其上方/左侧的像素平均值，并添加一点随机性。您可以通过更改p变量，但是我认为我使用的是一个很好的平衡（主要是因为我喜欢蓝色，所以更多的模糊波动性会带来不错的结果）。

平均时，整数除法会有轻微的负偏差。我认为效果不错，但可以给底角提供很好的变暗效果。

当然，要获得不仅仅是单个结果的结果，您需要srand()在主函数中添加一行。

反射波

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

基本的国际象棋棋盘图案会根据波浪的位置而变形，波浪的位置从像石头一样落在池塘中的点开始扩展（非常不精确！）。变量w是波浪移动到该点的像素数。如果w足够大，则波将从图像的侧面反射。

w = 225

w = 360

w = 5390

这是一张GIF，显示了随着波的扩展而产生的一系列图像。我提供了许多不同的大小，每个大小都显示了500KB文件大小限制所允许的尽可能多的帧。

如果我能找到一种适合的方法，则理想情况下，我希望对波干扰进行建模，以使波穿过时看起来更逼真。我对反射感到满意。

请注意，我还没有真正模拟3个140字节的波反射。实际上并没有发生任何反射，只是看起来像这样。万一有人想先猜一下，我已经隐藏了解释：

第一反射波与源自图像边缘另一侧的波相同，与原始点的距离相同。因此，该代码将计算4个点的正确位置，以得到4个边缘中每一个的反射效果。如果您将图像想象为一个平面中的一个图块，则反射波的其他级别都与源自更远的图块的波相同。该代码通过显示189个独立的扩展圆，给出了8种反射级别的错觉，每个扩展圆都位于17 x 17网格中的正确点上，从而使它们通过网格的中心正方形（即图像正方形）。恰到好处的时机给人以所需的当前反射水平的印象。这很简单（而且很短！），但是运行起来很慢。