整数演算は、グリッド上にレイアウトすると驚くべきパターンを生成できます。最も基本的な機能でさえ、驚くほど精巧なデザインを生み出すことができます！

あなたの挑戦

1024x1024の画像の赤、緑、青の値に3つのツイート可能な（140文字以下を意味する）関数本文を記述します。

関数への入力は2つの整数i（指定されたピクセルの列番号）とj（指定されたピクセルの行番号）であり、出力は指定された量を表す0から1023までの符号なしショートです。ピクセル（i、j）に存在する色。

たとえば、次の3つの関数は次の図を生成します。

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

  それでもうまくいかない場合は、無署名のショートの代わりに無署名の文字を使用した代替バージョンを使用してください。

ミカエルアンジェロは、クリーンアップされた24ビットまたは48ビットのカラー出力バージョンを提供しています。

• 独自のバージョンを別の言語で実装することもできますが、提供されているC ++バージョンと同じように動作する必要があり、C ++の組み込み、ライブラリ、または提供されているマクロの関数のみを使用して公平にします。
• 3つの関数本体のみを投稿してください-投稿に私のコードを含めないでください
• 小さいバージョンか、画像の埋め込みコピーを含めてください。これらはppm形式に作成され、stackexchangeで適切に表示するために別の形式に変換する必要がある場合があります。
• 関数本体（署名を含まない）は、140文字以下でなければなりません。
• これは人気コンテストです-ほとんどの票が勝ちます

マンデルブロ3 x 133文字

私の頭に浮かんだ最初のものは「マンデルブロ！」でした。

はい、すでにマンデルブロの提出があることを知っています。私は自分で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、セグメンテーションフォールトを取得せずにこれらの関数内に配置することはできません。
• ランダムウォークを3色すべてで同じにすることができれば、もう少し整然と見えるかもしれません。

次のように、ランダムウォークを等方性にすることもできます。

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は、私の写真にはバットマンが含まれていると指摘しました。

もちろん、マンデルブロの提出が必要です。

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し、他の2つでそのマクロを使用して、緑と青の派手な色を選択するための文字を増やすと、不正行為になりますか？

編集：これらのいくつかの残りのバイトでまともな配色を考え出すことは本当に難しいです。他のバージョンは次のとおりです。

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

与える

ジュリアセット

マンデルブロが存在する場合、ジュリアセットも存在するはずです。

パラメータと関数を微調整するのに何時間も費やすことができるので、これはまともなように見える簡単なものです。

マーティンの参加からインスピレーションを受けた。

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が必要ですか？

OK、Sparrのコメントは、これらの小さなJuliasのパラメーターをランダム化するために私をトラックに入れました。私は最初にビットレベルのハッキングを試みましたtime(0)が、C ++では16進浮動小数点のリッターが許可されていないため、これは行き止まりでした（少なくとも私の知識は限られています）。私はそれを達成するためにいくつかの重いキャストを使用することもできましたが、それは140バイトに収まりませんでした。

とにかく余地があまりなかったので、マクロを入れるために赤いジュリアを落とし、より一般的なRNG（timed seedとreal rand()、woohoo！）を持たなければなりませんでした。

おっと、何かが足りない。明らかに、これらのパラメーターは静的である必要があります。そうでない場合は、奇妙な結果になります（しかし、おもしろい、何か面白いものが見つかったら、後で調査します）。

したがって、ここでは緑と青のチャネルのみがあります。

次に、単純な赤いパターンを追加して、ボイドを埋めましょう。本当に想像力豊かではありませんが、私はグラフィックプログラマではありません...まだ:-)

最後に、ランダムパラメーターを使用した新しいコード：

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

ブッダブロット（+ Antibuddhabrot）

編集：それは今、適切な仏broです！

編集：色の強度をバイト制限内に抑えることができたため、オーバーフローによる誤った黒ピクセルがなくなりました。

私は本当に4後に停止したかった...しかし...

これはアップロード中にわずかに圧縮されます（埋め込み時に縮小されます）。すべての詳細を賞賛したい場合は、ここから512x512の興味深い部分を切り取ります（圧縮されず、フルサイズで表示されます）。

アイデアを提供してくれたgithubphagocyteに感謝します。これには、3つのカラー関数すべてのかなり複雑な乱用が必要でした。

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の反復で2分かかるまともな結果を得ることができ、1kの反復で1k x 1kのグリッドでさえ非常にきれいに見えます（3秒ほどかかります）。これらのパラメーターをいじりたい場合は、変更が必要な場所がいくつかあります。

• マンデルブロの再帰の深さを変更するには5e5、inの両方のインスタンスをBL反復回数に合わせて調整します。
• グリッドの解像度を変更するには、4つすべてを目的の解像度に変更し、同じ倍率で4096in RDを変更して、正しいスケーリングを維持します。1024.GR
• あなたは、おそらくも拡張する必要があります。return c[i][j]中にGRいるだけで、各ピクセルの訪問の絶対数が含まれているため。最大色は、繰り返し回数にほとんど依存していないようで、開始点の総数に比例してスケーリングします。したがって、1k x 1kのグリッドを使用する場合はreturn c[i][j]*16;、同様の機能を使用することもできますが、その要因には多少の手間がかかることがあります。

Buddhabrotに慣れていない人（数日前の私のように）については、マンデルブロ計算に基づいていますが、各ピクセルの強度は、エスケープトラジェクトリの反復でそのピクセルがどれくらいの頻度でアクセスされたかです。逃げられない軌跡の間の訪問をカウントしている場合、それは反仏教徒です。Nebulabrotと呼ばれるさらに洗練されたバージョンがあり、各カラーチャンネルに異なる再帰深度を使用します。しかし、私はそれを他の誰かに任せます。詳細については、いつものように、ウィキペディア。

もともと、私は逃げる軌跡と逃げない軌跡を区別しませんでした。これにより、仏broと反仏教徒の結合であるプロットが生成されました（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;
}

これは色あせた写真のように見えます...私はそれが好きです。

シェルピンスキーペンタゴン

ランダムに選択された頂点の半分までポイントをプロットすることにより、シェルピンスキーの三角形を近似するカオスゲームの方法を見たことがあるかもしれません。ここでは、5つの頂点を使用して同じアプローチを取りました。解決できる最短のコードには5つの頂点のハードコーディングが含まれており、140文字にすべてを合わせる方法はありませんでした。そのため、赤のコンポーネントを単純な背景に委任し、赤の関数のスペアスペースを使用してマクロを定義し、他の2つの関数も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];}

おかげマーティンBüttnerその後、別のに使用する1つの関数、マクロの定義についての質問のコメントで述べたアイデアについて、また、むしろ主な機能のラスタ順に制限されているよりも、任意の順序でピクセルを埋めるためにメモ化を使用するための。

画像は500KBを超えるため、スタック交換によって自動的にjpgに変換されます。これにより、細かい部分の一部が不鮮明になるため、元の外観を示すために、右上の4分の1だけを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);
}

これがどのように機能するかについてのいくつかの詳細...ええと、それは実際にはいくつかの波状のシェルピンスキー三角形のレンダリングの単なる拡大です。楽譜の外観（およびブロックノイズ）は、整数の切り捨ての結果です。たとえば、赤の関数を

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

切り捨てが削除され、フル解像度のレンダリングが得られます。

そう、それは面白いです。

ランダムボロノイ図ジェネレーター？

OK、これは苦労しました。結果が他の人ほど芸術的ではない場合でも、それはかなりいいと思います。それがランダム性の対処です。一部の中間画像はより見栄えが良いかもしれませんが、ボロノイ図を使用した完全に機能するアルゴリズムが必要でした。

編集：

これは、最終的なアルゴリズムの一例です。画像は基本的に、各色成分（赤、緑、青）に対応する3つのボロノイ図の重ね合わせです。

コード

最後にコメントなしのバージョン

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

オリジナルのpngがアップロードするには重すぎたため（>2MB）、これをjpegに変換しました。これは50階調以上のグレーであるに違いありません。

2番目：より良いy座標を持つ

y軸に対してランダムに生成された座標の別のテーブルを持つ余裕はなかったので、できるだけ少ない文字で「ランダム」なものを取得する簡単な方法が必要でした。xポイントANDのインデックスをビット単位で実行することで、テーブル内の別のポイントの座標を使用しました。

3番目：覚えていないが、良くなっている

しかし、この時点で私は140文字をはるかに超えていたので、かなりゴルフをする必要がありました。

4番目：スキャンライン

冗談です、これは望んでいませんが、ちょっとかっこいいです。

アルゴリズムのサイズを縮小する作業を続けていますが、私は以下を紹介できることを誇りに思います。

StarFoxエディション

ボロノイInstagram

5番目：ポイント数を増やす

これで実用的なコードが完成したので、25ポイントから60ポイントに進みましょう。

1つの画像だけではわかりにくいですが、ポイントはほぼすべて同じ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];
}

これまで読んでくれてありがとう。

リアプノフフラクタル

これを生成するために使用された文字列は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);

マンデルブロ集合のバリエーションも作成しました。マンデルブロ集合マップに似たマップを使用します。M（x、y）はマンデルブロマップです。それから、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);

編集

大変な苦労の末、ようやく2番目の画像モーフィングの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;
}

非ゴルフ

すべての#definesはBLを140文字未満に収めます。以下は、わずかに変更された青いアルゴリズムの未使用バージョンです。

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

xの値が特定のr（j値）で最も頻繁に低下する場合、プロットはより明るくなります（通常はより暗く表示されます）。

拡散制限集約

私は、拡散が制限された集合体と、それが現実の世界に現れるさまざまな方法に常に魅了されてきました。

私は、コードは恐ろしい作るために持っていたので、それが困難（または美しいあなたの場合のようなもののように、機能ごとのちょうど140文字でこれを書くために見つけ++d%=4およびfor(n=1;n;n++)）。3つのカラー関数は相互に呼び出し、使用する相互のマクロを定義するため、読みにくくなりますが、各関数は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アルバムがあります。誰もが他のクールなスパイラルパターンを見つけることができるかどうかを確認したいと思います。また、これは私がこれまで見た中で最もクールな挑戦の1つであると言わなければなりません。楽しい！

編集：パラメーターを変更したこれらのスパイラルから作成された背景を次に示します。

また、スパイラルエッジパターンを、xor / and / or操作を使用してここで見たいくつかのフラクタルと組み合わせることで、最終的なスパイラルができます。

クラシックへのオマージュ

V1：DreamWarriorの「Be happy」に触発されたこの簡単な投稿は、各カラーチャンネルに小さなピクセルアートイメージを埋め込みます。私はコードをゴルフする必要さえありませんでした！
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の編集に出会ったが、そのアバターが私にピクセルアートベースの別のエントリを追加するよう促した。コードの核となる考え方は、スペースインベーダーの考え方にほぼ似ているため、このエントリに追加しますが、この2つには間違いなく異なる課題があります。これについては、ピンクを正しく（白を犠牲にして）し、それがかなり大きなスプライトであるという事実は、素晴らしい挑戦を証明しました。\xFF赤チャネルの16進エスケープ（など）はソースファイルの対応する文字を表します（つまり、ソースファイルの赤チャネルにはバイナリデータが含まれます）が、8進エスケープはリテラルです（つまり、ソースファイルに存在します）。

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

アクションペインティング

私はジャクソン・ポロックの作品に似たものを作り直したいと思いました-水平のキャンバスに絵の具を垂らして注ぎます。結果は気に入りましたが、この質問に投稿するにはコードが長すぎたため、最善の努力を尽くしても約600バイトに削減されました。したがって、ここに投稿されたコード（それぞれ139バイト、140バイト、および140バイトの機能を持っています）は、chatのいくつかの天才からの多大な助けを借りて作成されました。おかげで：

• エリック・トレスラー
• ホタル
• PhiNotPi
• マーティン・ブットナー

執groupなグループゴルフセッション。

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

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

編集：これは、GRおよびの前方宣言のおかげで、有効な回答になりましたBL。

ホフスタッターのQシーケンスを楽しんでください！ある点からの半径距離を入力として使用し、出力を逆色として使用している場合、色付きビニールのように見えるものが得られます。

シーケンスはフィボナッチシーケンスに非常に似ていますが、シーケンスを1つまたは2ステップ戻すのではなく、前の2つの値を使用して、合計を取る前にどれだけ戻るかを決定します。それはほぼ線形に成長しますが、時折カオスのバーストがあり（間隔をあけて）、次のバーストの前に再びほぼ線形のシーケンスに落ち着きます：

これらの波紋は、色が非常に「平ら」に見える領域の後の画像で見ることができます。

もちろん、1色だけを使用するのは退屈です。

次にコードについて説明します。シーケンスを計算するには再帰関数が必要です。それを行うために、私は負の場合は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);
}

これは、原点からわずかにオフセットした点を中心とする同心円のセットのジューコフスキー変換を計算します。青のチャンネルの強度をわずかに変更して、少し色を変化させました。

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

Objective-C

Objective-Cの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それらが処理される前に、など。

シェルピンスキーペイントスプラッシュ

色でもっと遊びたいと思ったので、他の答え（渦巻き模様の答え）を変え続け、最終的にはこれで終わりました。

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_PIPOSIX互換システムにのみ存在するために許可されない場合は、リテラルに置き換えることができます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;
}

非常に短いため、3つの機能はすべて1つのツイートに収まります。

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）からの何かのように見えます。

各ピクセルは、その上/左のピクセルの平均を取り、ビットo 'ランダムを追加します。p変数を変更することで変動性を試すことができますが、私が使用しているのは良いバランスだと思います（主に青が好きなので、より多くのブラーのボラティリティが良い結果をもたらします）。

平均化するとき、整数除算によるわずかな負のバイアスがあります。しかし、うまくいくと思いますし、下隅に素敵な暗色効果を与えます。

もちろん、1つ以上の結果を得る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です。500 KBのファイルサイズ制限が許す限り多くのフレームを表示するさまざまなサイズを提供しました。

それに適合する方法を見つけることができれば、理想的には、波が交差するときに波がより現実的に見えるように波の干渉をモデル化したいと思います。私は反射に満足しています。

私は実際に波の反射を140バイトの3ロットでモデル化していないことに注意してください。実際には何も反映されていません。たまたまそのように見えます。誰かが最初に推測したい場合に備えて、説明を隠しました：

最初の反射波は、イメージエッジの反対側から発生する波と同じで、元の点と同じ距離です。したがって、コードは4つのエッジのそれぞれからの反射の効果を与えるために必要な4つのポイントの正しい位置を計算します。イメージを平面内の1つのタイルとして想像すると、反射波のそれ以上のレベルは、遠くのタイルから発生する波とすべて同じです。このコードは、189個の個別の拡大円を表示することで8レベルの反射の錯覚を与え、それぞれが17 x 17グリッドの正しいポイントに配置され、グリッドの中央の正方形（つまり、画像の正方形）を通過します。必要な現在の反射レベルの印象を与えるためにちょうどいいタイミングです。これはコーディングが簡単（そして短い！）ですが、実行は非常に遅いです...