Matematika bilangan bulat dapat menghasilkan pola yang luar biasa ketika diletakkan di atas kisi-kisi. Bahkan fungsi paling dasar dapat menghasilkan desain yang rumit dan memukau!

Tantangan anda

Tulis 3 badan fungsi Tweetable (artinya 140 karakter atau kurang) untuk nilai merah, hijau, dan biru untuk gambar 1024x1024.

Input ke fungsi akan menjadi dua bilangan bulat i (nomor kolom untuk piksel yang diberikan) dan j (nomor baris untuk piksel yang diberikan) dan output akan menjadi pendek unsigned antara 0 dan 1023, inklusif, yang mewakili jumlah yang diberikan warna hadir dalam piksel (i, j).

Misalnya, tiga fungsi berikut menghasilkan gambar di bawah ini:

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

Aturan

• Dengan kode C ++ ini , gantikan fungsi Anda. Saya telah menyediakan beberapa makro dan telah memasukkan perpustakaan, dan Anda dapat memasukkan complex.h. Anda dapat menggunakan fungsi apa pun dari perpustakaan ini dan / atau makro saya. Tolong jangan gunakan sumber daya eksternal selain ini.

• Jika versi itu tidak berfungsi untuk Anda, pastikan Anda mengkompilasi dengan:

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

  Jika itu tidak berhasil, silakan gunakan versi alternatif menggunakan karakter yang tidak ditandatangani alih-alih celana pendek yang tidak ditandatangani.

Michaelangelo telah menyediakan versi keluaran warna 24-bit atau 48-bit yang dibersihkan .

• Anda dapat mengimplementasikan versi Anda sendiri dalam bahasa lain, tetapi harus berperilaku dengan cara yang sama seperti versi C ++ yang disediakan, dan hanya fungsi dari built-in C ++, perpustakaan, atau makro yang disediakan dapat digunakan untuk membuatnya adil.
• Posting hanya tiga badan fungsi Anda - mohon jangan sertakan kode saya dalam posting Anda
• Harap sertakan versi yang lebih kecil atau salinan gambar Anda yang disematkan. Mereka dibuat dalam format ppm dan mungkin perlu dikonversi ke yang lain untuk tampilan yang tepat di stackexchange.
• Badan fungsi (tidak termasuk tanda tangan) harus 140 karakter atau kurang.
• Ini adalah kontes popularitas - sebagian besar suara menang

Mandelbrot 3 x 133 karakter

Hal pertama yang muncul di pikiran saya adalah "Mandelbrot!".

Ya, saya tahu sudah ada pengiriman mandelbrot. Setelah memastikan bahwa saya dapat memperolehnya di bawah 140 karakter sendiri, saya telah mengambil trik dan optimisasi dari solusi itu menjadi milik saya (terima kasih Martin dan Todd). Itu meninggalkan ruang untuk memilih lokasi yang menarik dan memperbesar, serta tema warna yang bagus:

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

Total 132 karakter

Saya mencoba menurunkannya ke 140 untuk semua 3 saluran. Ada sedikit noise warna di dekat tepi, dan lokasi tidak semenarik yang pertama, tetapi: 132 karakter

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

Taplak meja

Datar

Saya mulai menempatkan pola kotak-kotak / motif kotak ke dalam perspektif seperti taplak meja tanpa batas:

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

Riak

Lalu saya memperkenalkan riak (perspektif tidak sepenuhnya benar, tetapi masih dalam 140 karakter):

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

Warna

Lalu saya membuat beberapa warna lebih berbutir halus untuk memberikan detail pada skala yang lebih luas, dan untuk membuat gambar lebih berwarna ...

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

Bergerak

Mengurangi kode hanya sedikit lebih memungkinkan untuk mendefinisikan fase gelombang P dengan 2 tempat desimal, yang hanya cukup untuk frame yang cukup dekat untuk animasi yang halus. Saya telah mengurangi amplitudo pada tahap ini untuk menghindari penyakit laut, dan menggeser seluruh gambar hingga 151 piksel lebih lanjut (dengan biaya 1 karakter tambahan) untuk mendorong alias dari bagian atas gambar. Animasi aliasing sangat memesona.

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

Pelukis acak

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

Berikut ini adalah entri berbasis keacakan. Untuk sekitar 0,1% dari piksel itu memilih warna acak, untuk yang lain itu menggunakan warna yang sama dengan piksel berdekatan yang acak. Perhatikan bahwa setiap warna melakukan ini secara independen, jadi ini sebenarnya hanya hamparan dari gambar hijau, biru dan merah acak. Untuk mendapatkan hasil yang berbeda pada proses yang berbeda, Anda harus menambahkan srand(time(NULL))ke mainfungsi.

Sekarang untuk beberapa variasi.

Dengan melewatkan piksel, kita bisa membuatnya sedikit lebih buram.

Dan kemudian kita bisa perlahan-lahan mengubah warna, di mana luapan menghasilkan perubahan mendadak yang membuat ini terlihat lebih seperti sapuan kuas

Hal-hal yang perlu saya pahami:

• Untuk beberapa alasan saya tidak bisa memasukkan srandfungsi-fungsi itu tanpa mendapatkan segfault.
• Jika saya bisa membuat jalan acak yang sama di ketiga warna itu mungkin terlihat sedikit lebih teratur.

Anda juga bisa membuat random walk isotropic, like

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

memberi Anda

Lebih banyak lukisan acak

Saya bermain-main dengan ini sedikit lebih dan membuat beberapa lukisan acak lainnya. Tidak semua ini dimungkinkan dalam keterbatasan tantangan ini, jadi saya tidak ingin memasukkannya di sini. Tapi Anda bisa melihatnya di galeri imgur ini bersama dengan beberapa deskripsi tentang bagaimana saya membuatnya.

Saya tergoda untuk mengembangkan semua kemungkinan ini menjadi sebuah kerangka kerja dan menaruhnya di GitHub. (Bukan berarti hal-hal seperti ini belum ada, tapi itu tetap menyenangkan!)

Beberapa hal runcing berputar

Ya, saya tahu persis apa namanya.

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: Tidak lagi digunakan pow. EDIT 2: @PhiNotPi menunjukkan bahwa saya tidak perlu menggunakan abs terlalu banyak.

Anda dapat mengubah titik referensi dengan cukup mudah untuk mendapatkan gambar yang berbeda:

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 menunjukkan bahwa gambar saya memiliki Batman di dalamnya.

Tentu saja, harus ada pengajuan 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;
}

Mencoba memperbaiki skema warna sekarang. Apakah itu curang jika saya mendefinisikan komputasi sebagai makro red_fndan menggunakan makro itu di dua lainnya sehingga saya memiliki lebih banyak karakter untuk pemilihan warna mewah dalam hijau dan biru?

Sunting: Sangat sulit untuk menghasilkan skema warna yang layak dengan beberapa byte yang tersisa ini. Berikut ini satu versi lain:

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

Dan sesuai saran githubphagocyte dan dengan peningkatan Todd Lehman, kita dapat dengan mudah memilih bagian yang lebih kecil:

Misalnya

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

memberi

Julia mengatur

Jika ada Mandelbrot, harus ada set Julia juga.

Anda dapat menghabiskan waktu berjam-jam mengutak-atik parameter dan fungsi, jadi ini hanya yang cepat yang terlihat layak.

Terinspirasi dari partisipasi 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;}

Apakah Anda ingin RNG?

OK, komentar Sparr membuat saya di jalur untuk mengacak parameter Julias kecil ini. Saya pertama kali mencoba melakukan peretasan tingkat bit dengan hasil time(0)tetapi C ++ tidak mengizinkan litteral floating point heksadesimal jadi ini adalah jalan buntu (dengan pengetahuan saya yang terbatas setidaknya). Saya bisa menggunakan beberapa casting berat untuk mencapainya, tetapi itu tidak akan cocok dengan 140 byte.

Saya tidak punya banyak ruang tersisa, jadi saya harus menjatuhkan Julia merah untuk meletakkan makro saya dan memiliki RNG yang lebih konvensional ( timebibit dan nyata rand(), woohoo!).

Aduh, ada yang hilang. Jelas, parameter-parameter ini harus statis atau Anda memiliki beberapa hasil yang aneh (tapi lucu, mungkin saya akan menyelidiki sedikit kemudian jika saya menemukan sesuatu yang menarik).

Jadi di sinilah kita, dengan hanya saluran hijau dan biru:

Sekarang mari kita tambahkan pola merah sederhana untuk mengisi kekosongan. Tidak terlalu imajinatif, tapi saya bukan programmer grafis ... belum :-)

Dan akhirnya kode baru dengan parameter acak:

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

Masih ada ruang tersisa sekarang ...

Yang ini menarik karena tidak menggunakan parameter i, j sama sekali. Sebaliknya ia mengingat keadaan dalam variabel statis.

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)

Sunting: Ini Buddhabrot yang tepat sekarang!

Sunting: Saya berhasil membatasi intensitas warna dalam batas byte, sehingga tidak ada lagi piksel hitam palsu karena meluap.

Saya benar-benar ingin berhenti setelah empat ... tapi ...

Ini sedikit terkompresi selama pengunggahan (dan menyusut saat disematkan) jadi jika Anda ingin mengagumi semua detail, berikut ini adalah 512x512 menarik yang dipotong (yang tidak dikompresi dan ditampilkan dalam ukuran penuh):

Terima kasih kepada githubphagocyte untuk idenya. Ini membutuhkan beberapa penyalahgunaan tiga fungsi warna yang agak rumit:

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

Ada beberapa byte yang tersisa untuk skema warna yang lebih baik, tetapi sejauh ini saya belum menemukan apa pun yang mengalahkan gambar skala abu-abu.

Kode seperti yang diberikan menggunakan 4096x4096 titik awal dan melakukan hingga 500.000 iterasi pada masing-masing untuk menentukan apakah lintasan lolos atau tidak. Butuh waktu antara 6 dan 7 jam di mesin saya. Anda bisa mendapatkan hasil yang layak dengan grid 2k x 2k dan iterasi 10k, yang membutuhkan dua menit, dan bahkan hanya 1k x 1k grid dengan iterasi 1k terlihat cukup bagus (yang membutuhkan waktu 3 detik). Jika Anda ingin mengutak-atik parameter tersebut, ada beberapa tempat yang perlu diubah:

• Untuk mengubah kedalaman rekursi Mandelbrot, menyesuaikan baik contoh 5e5dalam BLuntuk menghitung iterasi Anda.
• Untuk mengubah resolusi grid, mengubah semua empat 4096di RDresolusi yang Anda inginkan dan 1024.di GRdengan faktor yang sama untuk mempertahankan skala yang benar.
• Anda mungkin juga perlu mengukur return c[i][j]dalam GRkarena itu hanya berisi jumlah absolut kunjungan setiap piksel. Warna maksimum tampaknya sebagian besar tidak tergantung pada jumlah iterasi dan skala secara linier dengan jumlah total titik awal. Jadi, jika Anda ingin menggunakan kotak 1k dengan 1k, Anda mungkin ingin return c[i][j]*16;atau serupa, tetapi faktor itu kadang-kadang membutuhkan beberapa biola.

Bagi mereka yang tidak terbiasa dengan Buddhabrot (seperti saya beberapa hari yang lalu), ini didasarkan pada perhitungan Mandelbrot, tetapi intensitas setiap piksel adalah seberapa sering piksel itu dikunjungi dalam iterasi dari lintasan melarikan diri. Jika kami menghitung kunjungan selama lintasan yang tidak luput, itu adalah Antibuddhabrot. Ada versi yang lebih canggih yang disebut Nebulabrot di mana Anda menggunakan kedalaman rekursi yang berbeda untuk setiap saluran warna. Tapi aku akan menyerahkannya pada orang lain. Untuk informasi lebih lanjut, seperti biasa, Wikipedia .

Awalnya, saya tidak membedakan antara lintasan melarikan diri dan non-melarikan diri. Itu menghasilkan plot yang merupakan gabungan dari Buddhabrot dan Antibuddhabrot (seperti yang ditunjukkan oleh 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;
}

Yang ini terlihat agak seperti foto yang pudar ... Saya suka itu.

Sierpinski Pentagon

Anda mungkin telah melihat metode permainan kekacauan untuk mendekati Segitiga Sierpinski dengan memplot poin setengah jalan ke vertex yang dipilih secara acak. Di sini saya telah mengambil pendekatan yang sama menggunakan 5 simpul. Kode terpendek yang bisa saya setujui termasuk hard coding 5 simpul, dan tidak ada cara saya akan memasukkan semuanya ke dalam 140 karakter. Jadi saya telah mendelegasikan komponen merah ke latar belakang sederhana, dan menggunakan ruang kosong di fungsi merah untuk mendefinisikan makro untuk membawa dua fungsi lainnya di bawah 140 juga. Jadi semuanya valid dengan biaya tidak memiliki komponen merah di pentagon.

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

Terima kasih kepada Martin Büttner untuk ide yang disebutkan dalam komentar pertanyaan tentang mendefinisikan makro dalam satu fungsi untuk kemudian digunakan dalam fungsi lain, dan juga untuk menggunakan memoisasi untuk mengisi piksel dalam urutan acak alih-alih terbatas pada urutan raster fungsi utama .

Gambar lebih dari 500KB sehingga secara otomatis dikonversi ke jpg oleh pertukaran tumpukan. Ini mengaburkan beberapa detail yang lebih halus, jadi saya juga menyertakan hanya bagian kanan atas sebagai png untuk menunjukkan tampilan asli:

Lembar musik

Musik Sierpinski. : D Orang-orang di obrolan mengatakan itu lebih mirip kertas untuk kotak musik.

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

Beberapa perincian tentang bagaimana ini bekerja ... um, sebenarnya hanya zoom-in untuk membuat beberapa segitiga Sierpinski yang bergelombang. Tampilan sheet-music (dan juga blockiness) adalah hasil dari pemotongan bilangan bulat. Jika saya mengubah fungsi merah menjadi, katakan,

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

pemotongan dihapus dan kami mendapatkan render resolusi penuh:

Jadi ya, itu menarik.

Diagram Voronoi acak siapa pembuat?

OK, yang ini memberi saya waktu yang sulit. Saya pikir itu cukup bagus, walaupun hasilnya tidak begitu artistik seperti yang lainnya. Itu kesepakatan dengan keacakan. Mungkin beberapa gambar menengah terlihat lebih baik, tetapi saya benar-benar ingin memiliki algoritma yang berfungsi penuh dengan diagram voronoi.

Sunting:

Ini adalah salah satu contoh dari algoritma final. Gambar pada dasarnya adalah superposisi dari tiga diagram voronoi, satu untuk setiap komponen warna (merah, hijau, biru).

Kode

ungolfed, versi komentar di akhir

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

Butuh banyak upaya, jadi saya merasa ingin berbagi hasil pada tahap yang berbeda, dan ada yang bagus (salah) untuk ditampilkan.

Langkah pertama: minta beberapa titik ditempatkan secara acak, dengan x=y

Saya telah mengonversinya menjadi jpeg karena png asli terlalu berat untuk diunggah ( >2MB), saya yakin itu lebih dari 50 warna abu-abu!

Kedua: memiliki koordinat y yang lebih baik

Saya tidak mampu membuat tabel koordinat lain yang dihasilkan secara acak untuk ysumbu, jadi saya membutuhkan cara sederhana untuk mendapatkan yang " acak " dalam karakter sesedikit mungkin. Saya menggunakan xkoordinat titik lain dalam tabel, dengan melakukan bitwise ANDpada indeks titik.

Ke-3: Saya tidak ingat tapi itu semakin baik

Tetapi pada saat ini saya memiliki lebih dari 140 karakter, jadi saya perlu sedikit menurunkannya.

4: scanlines

Hanya bercanda, ini tidak diinginkan tapi agak keren, methinks.

Masih berupaya mengurangi ukuran algoritme, saya bangga mempersembahkan:

Edisi StarFox

Voronoi instagram

5: menambah jumlah poin

Saya sekarang memiliki sepotong kode yang berfungsi, jadi mari kita mulai dari 25 hingga 60 poin.

Itu sulit dilihat hanya dari satu gambar, tetapi titik-titiknya hampir semuanya berada dalam ykisaran yang sama . Tentu saja, saya tidak mengubah operasi bitwise, &42jauh lebih baik:

Dan di sinilah kita, pada titik yang sama dengan gambar pertama dari posting ini. Sekarang mari kita jelaskan kode untuk yang langka yang akan tertarik.

Kode tidak dijelaskan dan dijelaskan

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

Terima kasih sudah membaca sejauh ini.

Fraktal Lyapunov

String yang digunakan untuk menghasilkan ini adalah AABAB dan ruang parameter adalah [2,4] x [2,4]. ( penjelasan tentang string dan ruang parameter di sini )

Dengan ruang kode terbatas saya pikir pewarnaan ini cukup keren.

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

Saya juga membuat variasi dari set Mandelbrot. Ini menggunakan peta yang mirip dengan peta set Mandelbrot. Say M (x, y) adalah peta Mandelbrot. Maka M (sin (x), cos (y)) adalah peta yang saya gunakan, dan alih-alih memeriksa untuk melarikan diri nilai saya menggunakan x, dan y karena mereka selalu dibatasi.

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

SUNTING

Setelah banyak rasa sakit saya akhirnya membuat gif dari gambar kedua morphing. Ini dia:

Karena unicorn.

Saya tidak bisa mendapatkan versi OPs unsigned shortdan nilai warna hingga 1023 berfungsi, jadi sebelum itu diperbaiki, berikut adalah versi yang menggunakan chardan nilai warna maksimum 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);
}

Bukit Logistik

Fungsinya

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

Tidak disatukan

Semua definisi # harus sesuai BL di bawah 140 karakter. Berikut ini adalah versi algoritma biru yang tidak dipisahkan, sedikit dimodifikasi:

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

Di mana nilai-nilai x paling sering jatuh pada nilai r (j) yang diberikan, plot menjadi lebih terang (biasanya digambarkan lebih gelap).

Agregasi Difusi Terbatas

Saya selalu terpesona oleh agregasi terbatas difusi dan sejumlah cara yang berbeda muncul di dunia nyata.

Saya merasa sulit untuk menulis ini hanya dalam 140 karakter per fungsi jadi saya harus membuat kode yang mengerikan (atau indah, jika Anda suka hal-hal seperti ++d%=4dan for(n=1;n;n++)). Tiga fungsi warna saling memanggil dan menentukan makro untuk digunakan satu sama lain, sehingga tidak membaca dengan baik, tetapi masing-masing fungsi hanya di bawah 140 karakter.

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

Untuk memvisualisasikan bagaimana partikel beragregasi secara bertahap, saya menghasilkan snapshot secara berkala. Setiap frame diproduksi dengan mengganti 1 in for(n=1;n;n++)dengan 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Ini menyimpannya di bawah batas 140 karakter untuk setiap proses.

Anda dapat melihat bahwa agregat yang tumbuh berdekatan satu sama lain saling menghilangkan partikel dan tumbuh lebih lambat.

Dengan membuat sedikit perubahan pada kode Anda dapat melihat partikel yang tersisa yang belum melekat pada agregat. Ini menunjukkan daerah yang lebih padat di mana pertumbuhan akan terjadi lebih cepat dan daerah yang sangat jarang di antara agregat di mana tidak ada pertumbuhan lagi dapat terjadi karena semua partikel telah habis.

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

Ini dapat dianimasikan dengan cara yang sama seperti sebelumnya:

Spiral (140 tepatnya)

Ini adalah 140 karakter tepat jika Anda tidak menyertakan header fungsi dan tanda kurung. Ini adalah kompleksitas spiral yang bisa saya muat dalam batas karakter.

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

Saya secara bertahap membangun di atas spiral sederhana, menambahkan pola pada tepi spiral dan bereksperimen dengan bagaimana spiral yang berbeda dapat digabungkan untuk terlihat keren. Berikut ini adalah versi yang tidak diklik dengan komentar menjelaskan apa yang masing-masing bagian lakukan. Mengolah parameter dapat menghasilkan beberapa hasil menarik.

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

Messing dengan parameter:

Di sini, spiral berbaris tetapi memiliki pola tepi yang berbeda. Alih-alih tepi gumpal dalam contoh utama, ini memiliki tepi seluruhnya terdiri dari gelombang dosa.

Di sini, gradien telah dihapus:

Animasi ( yang karena alasan tertentu sepertinya tidak berulang setelah saya unggah, maaf. Juga, saya harus memperkecilnya. Buka saja di tab baru jika Anda melewatkan animasi ):

Dan, inilah album imgur dengan semua gambar di dalamnya. Saya ingin melihat apakah ada yang bisa menemukan pola spiral keren lainnya. Juga, saya harus mengatakan, ini adalah salah satu tantangan paling keren di sini yang pernah saya lihat. Nikmati!

EDIT: Berikut adalah beberapa latar belakang yang dibuat dari spiral ini dengan parameter yang diubah.

Juga, dengan menggabungkan pola tepi spiral saya dengan beberapa fraktal yang saya lihat di sini melalui penggunaan xor / dan / atau operasi, berikut adalah spiral terakhir:

Penghargaan untuk klasik

V1 : Terinspirasi oleh DreamWarrior "Be happy", pengiriman langsung ini menanamkan gambar pixel-art kecil di setiap saluran warna. Saya bahkan tidak perlu kode golf!
V2 : sekarang dengan kode yang jauh lebih pendek & perbatasan hitam tebal yang mengisolasi hanya "layar permainan".
V3 : pesawat ruang angkasa, peluru, alien yang rusak dan perbatasan biru, oh my! Mencoba mengincar ini , secara kasar.

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

Saya kebetulan menemukan hasil edit oleh Umber Ferrule yang avatarnya menginspirasi saya untuk menambahkan entri berbasis pixel-art lainnya. Karena ide inti dari kode ini sebagian besar mirip dengan Space Invaders, saya menambahkannya ke entri ini, meskipun keduanya jelas memiliki poin tantangan yang berbeda. Untuk yang satu ini, mendapatkan warna pink tepat (dengan mengorbankan warna putih) dan fakta bahwa itu adalah sprite yang agak besar membuktikan tantangan yang bagus. Heksadesimal lolos ( \xFFdll) di saluran merah mewakili karakter yang sesuai dalam file sumber (yaitu, saluran merah di file sumber berisi data biner), sedangkan lolos oktal adalah literal (yaitu hadir dalam file sumber).

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

Lukisan Aksi

Saya ingin mencoba menciptakan kembali sesuatu yang mirip dengan karya Jackson Pollock - meneteskan dan menuangkan cat di atas kanvas horizontal. Meskipun saya menyukai hasilnya, kodenya terlalu panjang untuk dikirim ke pertanyaan ini dan upaya terbaik saya masih hanya menguranginya menjadi sekitar 600 byte. Jadi kode yang diposting di sini (yang masing-masing memiliki fungsi 139 byte, 140 byte, dan 140 byte) diproduksi dengan sejumlah besar bantuan dari beberapa orang genius dalam obrolan . Terima kasih banyak untuk:

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

untuk sesi golf grup tanpa henti.

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}

Makro E (q) digunakan dalam fungsi RD dan GR. Mengubah nilai argumen mengubah cara komponen warna merah dan hijau berubah. Makro J berakhir dengan angka yang digunakan untuk menentukan berapa banyak perubahan komponen biru, yang pada gilirannya mempengaruhi komponen merah dan hijau karena mereka dihitung dari itu. Saya sudah memasukkan beberapa gambar dengan argumen merah dan hijau dari E yang bervariasi untuk menunjukkan variasi kombinasi warna yang mungkin. Arahkan kursor ke gambar untuk nilai merah dan hijau jika Anda ingin menjalankannya sendiri.

Semua gambar ini dapat dilihat dalam ukuran penuh jika Anda mengunduhnya. Ukuran file kecil karena warna datar sesuai dengan algoritma kompresi PNG, jadi tidak diperlukan kompresi lossy untuk mengunggah ke situs.

Jika Anda ingin melihat gambar dari berbagai tahap dalam proses bermain golf saat kami mencoba berbagai hal, Anda dapat melihat di obrolan melukis aksi .

Kupikir aku akan bermain dengan parameter kode ini ... Semua kredit jatuh ke @Manuel Kasten. Ini sangat keren sehingga saya tidak bisa menahan posting.

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

Sunting: Ini sekarang jawaban yang valid, terima kasih kepada deklarasi maju dari GRdan BL.

Bersenang-senang dengan Q-sequence Hofstadter! Jika kita menggunakan jarak radial dari beberapa titik sebagai input dan output sebagai warna terbalik, kita mendapatkan sesuatu yang terlihat seperti vinil berwarna.

Urutannya sangat mirip dengan urutan Fibonacci, tetapi alih-alih mundur 1 dan 2 langkah dalam urutan, Anda mengambil dua nilai sebelumnya untuk menentukan seberapa jauh untuk kembali sebelum mengambil jumlah. Itu tumbuh kira-kira linier, tetapi setiap sekarang dan kemudian ada ledakan kekacauan (pada interval yang meningkat) yang kemudian mengendap ke urutan yang hampir linier lagi sebelum ledakan berikutnya:

Anda dapat melihat riak-riak ini dalam gambar setelah daerah yang terlihat sangat "datar" warnanya.

Tentu saja, menggunakan hanya satu warna itu membosankan.

Sekarang untuk kodenya. Saya membutuhkan fungsi rekursif untuk menghitung urutan. Untuk melakukan itu saya gunakan RDsetiap kali jnegatif. Sayangnya, itu tidak meninggalkan karakter yang cukup untuk menghitung nilai saluran merah itu sendiri, jadi RDpada gilirannya panggilan GRdengan offset untuk menghasilkan saluran merah.

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

Tentu saja, ini adalah kemungkinan penggunaan urutan yang paling sederhana, dan ada banyak karakter yang tersisa. Jangan ragu untuk meminjamnya dan melakukan hal-hal gila lainnya dengannya!

Berikut adalah versi lain di mana batas dan warna ditentukan oleh urutan-Q. Dalam hal ini, ada cukup ruang RDsehingga saya bahkan tidak memerlukan deklarasi maju:

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

Ini menghitung transformasi Joukowsky dari satu set lingkaran konsentris yang berpusat pada titik yang sedikit diimbangi dari titik asalnya. Saya sedikit memodifikasi intensitas di saluran biru untuk memberikan sedikit variasi warna.

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

Objektif-C

Tulis ulang kode C ++ di Objective-C karena saya tidak bisa mengkompilasinya ... Ini memberikan hasil yang sama dengan jawaban lain ketika berjalan di iPad saya, jadi itu bagus.

Ini kiriman saya:

Kode di belakangnya cukup sederhana:

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

Anda dapat memperbesar kotak dengan mengalikan idan jdengan 0.5, 0.25dll. Sebelum mereka diproses.

Sierpinski Paint Splash

Saya ingin bermain lebih banyak dengan warna jadi saya terus mengubah jawaban saya yang lain (yang berputar) dan akhirnya berakhir dengan ini.

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

Ini avatar saya sekarang. : P

Saya merasa terdorong untuk mengirimkan entri ini yang akan saya sebut "perilaku tidak terdefinisi", yang akan menggambarkan apa yang dilakukan kompiler Anda dengan fungsi yang seharusnya mengembalikan nilai tetapi tidak:

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

Semua piksel hitam:

Pixel semu-acak:

Dan, tentu saja, sejumlah hasil lainnya yang mungkin tergantung pada kompiler, komputer, manajer memori, dll.

asyik

Hanya beberapa trik trigonometri dan trik makro yang aneh.

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: jika M_PItidak diizinkan karena hanya ada pada sistem yang kompatibel dengan POSIX, itu dapat diganti dengan literal 3.14.

Saya tidak pandai matematika. Saya selalu siswa miskin di kelas matematika. Jadi saya membuatnya sederhana.

Saya menggunakan kode Javascript user1455003 yang dimodifikasi . Dan ini kode lengkap saya .

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

Ini sangat singkat sehingga ketiga fungsi cocok dalam satu 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;
}

Fungsi lain yang sangat singkat. Saya menemukan pola sierpinski ini (dan beberapa pola singgung) sambil bermain-main dengan berbagai fungsi matematika. Ini adalah kode lengkap

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

Versi lain. badan fungsi tweetable.

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

Fungsi render gambar yang direvisi. 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)
}

Ungu

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

Pelukis Planet

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

Terinspirasi oleh entri Martin yang jelas luar biasa , ini adalah pandangan yang berbeda. Alih-alih menyemai sebagian piksel secara acak, saya mulai dengan sudut kiri atas sebagai RGB (512.512.512), dan berjalan secara acak pada setiap warna dari sana. Hasilnya terlihat seperti sesuatu dari teleskop (imo).

Setiap piksel mengambil rata-rata piksel di atas / kiri dan menambahkan sedikit secara acak. Anda dapat bermain dengan variabilitas dengan mengubah pvariabel, tetapi saya pikir apa yang saya gunakan adalah keseimbangan yang baik (terutama karena saya suka biru, sehingga volatilitas yang lebih blur memberikan hasil yang baik).

Ada sedikit bias negatif dari pembagian integer ketika rata-rata. Saya pikir itu berhasil, meskipun, dan memberikan efek gelap yang bagus ke sudut bawah.

Tentu saja, untuk mendapatkan lebih dari sekedar hasil tunggal, Anda harus menambahkan srand()garis ke fungsi utama Anda.

Gelombang yang dipantulkan

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

Pola papan catur dasar terdistorsi sesuai dengan posisi gelombang yang meluas dari titik seperti batu yang dijatuhkan di kolam (sangat jauh dari akurat secara fisik!). Variabelnya wadalah jumlah piksel dari titik itu bahwa gelombang telah bergerak. Jika wcukup besar, gelombang memantul dari sisi gambar.

w = 225

w = 360

w = 5390

Berikut adalah GIF yang menunjukkan suksesi gambar saat gelombang mengembang. Saya telah menyediakan sejumlah ukuran yang berbeda, masing-masing menunjukkan frame sebanyak batas ukuran file 500KB akan memungkinkan.

Jika saya dapat menemukan cara untuk memasangnya, idealnya saya ingin model gelombang dipodelkan sehingga gelombang terlihat lebih realistis ketika mereka melintas. Saya senang dengan refleksi itu.

Perhatikan bahwa saya belum benar-benar memodelkan refleksi gelombang dalam 3 lot 140 byte. Sebenarnya tidak ada pantulan apa pun yang terjadi, kebetulan terlihat seperti itu. Saya telah menyembunyikan penjelasannya jika ada yang ingin menebak lebih dulu:

Gelombang yang dipantulkan pertama identik dengan gelombang yang berasal dari sisi lain tepi gambar, jarak yang sama dengan titik aslinya. Jadi kode menghitung posisi yang benar untuk 4 poin yang diperlukan untuk memberikan efek refleksi dari masing-masing 4 tepi. Tingkat lebih lanjut dari gelombang yang dipantulkan semuanya identik dengan gelombang yang berasal dari ubin lebih jauh, jika Anda membayangkan gambar sebagai satu ubin di pesawat. Kode memberikan ilusi 8 level refleksi dengan menampilkan 189 lingkaran yang terpisah, masing-masing ditempatkan pada titik yang benar dalam kotak 17 dengan 17, sehingga mereka melewati kotak pusat dari kotak (yaitu, kotak gambar) di waktu yang tepat untuk memberikan kesan tingkat refleksi yang diperlukan saat ini. Ini sederhana (dan pendek!) Untuk dikodekan, tetapi berjalan cukup lambat ...