เลขจำนวนเต็มสามารถสร้างรูปแบบที่น่าทึ่งเมื่อวางทับตาราง แม้แต่ฟังก์ชั่นพื้นฐานที่สุดก็สามารถออกแบบได้อย่างน่าทึ่ง!

ความท้าทายของคุณ

เขียนเนื้อความของฟังก์ชั่น 3 Tweetable (หมายถึง 140 ตัวอักษรหรือน้อยกว่า) สำหรับค่าสีแดงสีเขียวและสีน้ำเงินสำหรับภาพ 1024x1024

อินพุตไปยังฟังก์ชันจะเป็นจำนวนเต็มสองจำนวน i (หมายเลขคอลัมน์สำหรับพิกเซลที่กำหนด) และ j (หมายเลขแถวสำหรับพิกเซลที่กำหนด) และเอาต์พุตจะสั้นที่ไม่ได้ลงนามระหว่าง 0 ถึง 1,023 ซึ่งรวมถึงจำนวนเงินที่กำหนด สีมีอยู่ในพิกเซล (i, j)

ตัวอย่างเช่นสามฟังก์ชั่นต่อไปนี้สร้างภาพด้านล่าง

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

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

กฎระเบียบ

• รับรหัส C ++นี้แทนฟังก์ชั่นของคุณ ฉันได้ให้มาโครสองสามตัวและได้รวมไลบรารีไว้แล้วและคุณอาจรวม complex.h คุณสามารถใช้ฟังก์ชั่นใด ๆ จากห้องสมุดเหล่านี้และ / หรือมาโครของฉัน โปรดอย่าใช้ทรัพยากรภายนอกใด ๆ นอกเหนือจากนี้

• หากเวอร์ชันนั้นใช้ไม่ได้สำหรับคุณตรวจสอบให้แน่ใจว่าคุณได้รวบรวม:

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

  หากไม่ได้ผลโปรดใช้เวอร์ชั่นอื่นโดยใช้ตัวอักษรที่ไม่ได้ลงชื่อแทนกางเกงขาสั้นที่ไม่ได้ลงชื่อ

Michaelangelo ได้จัดทำเวอร์ชั่นเอาต์พุตสี 24 บิตหรือ 48 บิตที่สะอาดขึ้น

• คุณอาจใช้เวอร์ชันของคุณเองในภาษาอื่น แต่จะต้องทำงานในลักษณะเดียวกับเวอร์ชัน C ++ ที่ให้มาและมีเพียงฟังก์ชั่นจากบิวด์อิน C ++ ของห้องสมุดหรือมาโครที่ให้มาเพื่อให้เป็นธรรม
• โพสต์เฉพาะส่วนของร่างกายสามหน้าที่ของคุณ - โปรดอย่ารวมรหัสของฉันไว้ในโพสต์ของคุณ
• โปรดรวมรุ่นที่เล็กกว่าหรือสำเนาภาพที่ฝังไว้ มันถูกสร้างเป็นรูปแบบ ppm และอาจจำเป็นต้องแปลงเป็นรูปแบบอื่นเพื่อการรับชมที่เหมาะสมบน stackexchange
• ฟังก์ชั่นร่างกาย (ไม่รวมลายเซ็นต์) จะต้องมี 140 ตัวอักษรหรือน้อยกว่า
• นี่คือการประกวดความนิยม - คะแนนโหวตชนะมากที่สุด

Mandelbrot 3 x 133 ตัวอักษร

สิ่งแรกที่ผุดขึ้นในใจของฉันคือ "Mandelbrot!"

ใช่ฉันรู้ว่ามีการยื่นดอกแดนดิบอทแล้ว หลังจากยืนยันว่าฉันสามารถรับได้ต่ำกว่า 140 ตัวฉันเองฉันได้นำเทคนิคและการเพิ่มประสิทธิภาพจากการแก้ปัญหานั้นเป็นของฉัน (ขอบคุณ Martin และทอดด์) พื้นที่เหลือเพื่อเลือกตำแหน่งและการซูมที่น่าสนใจรวมถึงชุดรูปแบบสีที่สวยงาม:

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 ตัวอักษร

ฉันพยายามทำให้มันลดลงเหลือ 140 สำหรับทั้ง 3 ช่อง มีเสียงรบกวนของสีเล็กน้อยใกล้กับขอบและตำแหน่งไม่น่าสนใจเท่ากับเสียงแรก แต่: 132 chars

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

ในการเคลื่อนไหว

การลดโค้ดเพียงเล็กน้อยช่วยให้สามารถกำหนดเฟส P ของคลื่นได้ด้วยทศนิยม 2 ตำแหน่งซึ่งเพียงพอสำหรับเฟรมที่อยู่ใกล้เพียงพอสำหรับภาพเคลื่อนไหวที่ราบรื่น ฉันได้ลดขนาดแอมพลิจูดลงในขั้นตอนนี้เพื่อไม่ให้เกิดอาการเมาทะเลและเลื่อนภาพทั้งหมดขึ้นไปอีก 151 พิกเซล (ที่มีอักขระเพิ่ม 1 ตัว) เพื่อผลัก aliasing ออกไปด้านบนของภาพ การใช้นามแฝงแบบภาพเคลื่อนไหวนั้นชวนให้หลงใหล

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ฟังก์ชั่นเหล่านั้นโดยไม่ได้รับ segfault
• หากฉันทำให้การสุ่มเดินแบบเดียวกันทั้งสามสีมันอาจดูเป็นระเบียบมากขึ้น

คุณสามารถสร้างไอโซโทรปิกเดินแบบสุ่มได้เช่นกัน

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 (ไม่ใช่ว่าแบบนี้ยังไม่มีอยู่ แต่ก็สนุกอยู่ดี!)

บางสิ่งที่แหลมคม swirly

ใช่ฉันรู้ว่าจะตั้งชื่ออะไร

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

แก้ไข:powใช้ไม่มีอีกต่อไป แก้ไข 2: @PhiNotPi ชี้ให้เห็นว่าฉันไม่จำเป็นต้องใช้ abs มากนัก

คุณสามารถเปลี่ยนจุดอ้างอิงได้ง่าย ๆ เพื่อให้ได้ภาพที่แตกต่าง:

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

@EricTressler ชี้ให้เห็นว่ารูปภาพของฉันมีแบทแมนอยู่ด้วย

แน่นอนว่าต้องมีการยอมจำนนของ Mandelbrot

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

พยายามปรับปรุงชุดสีในขณะนี้ มันเป็นการโกงหรือไม่ถ้าฉันนิยามการคำนวณเป็นมาโครred_fnและใช้มาโครนั้นในอีกสองตัวดังนั้นฉันจึงมีตัวละครมากขึ้นสำหรับการเลือกสีแฟนซีในสีเขียวและสีน้ำเงิน?

แก้ไข:มันยากที่จะเกิดขึ้นกับโครงร่างสีที่เหมาะสมกับจำนวนไบต์ที่เหลือเหล่านี้ นี่คืออีกหนึ่งเวอร์ชัน:

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

และตามคำแนะนำของ githubphagocyte และด้วยการปรับปรุงของ Todd Lehman เราสามารถเลือกหัวข้อย่อย ๆ ได้อย่างง่ายดาย:

เช่น

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

จะช่วยให้

ชุดจูเลีย

หากมี Mandelbrot ควรมีชุด Julia ด้วย

คุณสามารถใช้เวลาหลายชั่วโมงในการปรับแต่งพารามิเตอร์และฟังก์ชั่นดังนั้นนี่เป็นเพียงหนึ่งในคุณสมบัติที่รวดเร็ว

แรงบันดาลใจจากการมีส่วนร่วมของมาร์ติน

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

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

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

คุณต้องการ RNG บ้างไหม?

ตกลงความคิดเห็นของ Sparr ทำให้ฉันอยู่ในการติดตามเพื่อสุ่มพารามิเตอร์ของ Julias ตัวน้อยเหล่านี้ ก่อนอื่นฉันพยายามทำการแฮ็กระดับบิตด้วยผลลัพธ์ของtime(0)C ++ แต่ไม่อนุญาตให้ใช้เลขทศนิยมเลขฐานสิบหกดังนั้นนี่จึงเป็นจุดจบ (ด้วยความรู้ที่ จำกัด ของฉันอย่างน้อย) ฉันอาจใช้การร่ายอย่างหนักเพื่อให้บรรลุ แต่ก็ไม่เหมาะกับ 140 ไบท์

ฉันไม่มีที่ว่างเหลืออยู่แล้วดังนั้นฉันจึงต้องวาง Julia สีแดงเพื่อใส่มาโครของฉันและมี RNG แบบดั้งเดิมมากขึ้น ( timeเมล็ดพันธุ์และของจริงrand()วูวู!)

อ๊ะมีบางอย่างขาดหายไป เห็นได้ชัดว่าพารามิเตอร์เหล่านี้ต้องเป็นแบบคงที่หรืออย่างอื่นที่คุณได้ผลลัพธ์แปลก ๆ (แต่ตลกบางทีฉันอาจจะตรวจสอบในภายหลังถ้าฉันพบสิ่งที่น่าสนใจ)

ดังนั้นที่นี่เรามีเพียงช่องสีเขียวและสีน้ำเงิน:

ตอนนี้เราจะเพิ่มรูปแบบสีแดงที่เรียบง่ายเพื่อเติมเต็มช่องว่าง ไม่ได้จินตนาการจริงๆ แต่ฉันไม่ใช่โปรแกรมเมอร์กราฟิก ... ยัง :-)

และในที่สุดรหัสใหม่ที่มีพารามิเตอร์แบบสุ่ม:

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

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

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

ยังมีห้องเหลืออยู่ในขณะนี้ ...

อันนี้น่าสนใจเพราะมันไม่ได้ใช้พารามิเตอร์ i, j เลย แต่มันจะจำได้ว่าเป็นตัวแปรแบบคงที่

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

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

Buddhabrot (+ Antibuddhabrot)

แก้ไข:มันเป็นพระพุทธศาสนาที่เหมาะสมในขณะนี้!

แก้ไข:ฉันจัดการเพื่อจำกัดความเข้มของสีภายในขีด จำกัด ไบต์ดังนั้นจึงไม่มีพิกเซลสีดำที่ผิดเนื่องจากการล้น

ฉันอยากหยุดหลังจากสี่ ... แต่ ...

สิ่งนี้จะถูกบีบอัดเล็กน้อยระหว่างการอัปโหลด (และหดเมื่อฝัง) ดังนั้นหากคุณต้องการชื่นชมรายละเอียดทั้งหมดนี่คือการตัดออกที่น่าสนใจ 512x512 (ซึ่งไม่บีบอัดและแสดงในขนาดเต็ม):

ขอบคุณ githubphagocyte สำหรับความคิด จำเป็นต้องใช้ฟังก์ชั่นสีทั้งสามนี้ในทางที่ผิดค่อนข้างซับซ้อน:

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

มีบางไบต์ที่เหลือสำหรับโทนสีที่ดีขึ้น แต่จนถึงตอนนี้ฉันยังไม่พบสิ่งใดที่เต้นเป็นภาพระดับสีเทา

รหัสตามที่กำหนดใช้ 4096x4096 จุดเริ่มต้นและทำซ้ำได้ถึง 500,000 รอบในแต่ละจุดเพื่อตรวจสอบว่าเส้นทางการเคลื่อนที่นั้นหลบหนีหรือไม่ ใช้เวลาประมาณ 6 ถึง 7 ชั่วโมงในเครื่องของฉัน คุณสามารถได้ผลลัพธ์ที่ดีด้วยการทำซ้ำ 2k x 2k และ 10k iterations ซึ่งใช้เวลาสองนาทีและแม้แต่แค่ 1k x 1k กับ 1k grid กับ 1k iterations นั้นค่อนข้างดี (ซึ่งใช้เวลาประมาณ 3 วินาที) หากคุณต้องการเล่นแร่แปรธาตุโดยใช้พารามิเตอร์เหล่านี้มีบางสถานที่ที่ต้องเปลี่ยน:

• ในการเปลี่ยนความลึก recursion Mandelbrot ปรับทั้งสองกรณี5e5ในBLการนับซ้ำของคุณ
• ในการเปลี่ยนความละเอียดกริดให้เปลี่ยนทั้งสี่4096ในRDเป็นความละเอียดที่คุณต้องการและ1024.ในGRโดยปัจจัยเดียวกันเพื่อรักษาระดับที่ถูกต้อง
• คุณอาจจะยังต้องชั่งreturn c[i][j]ในGRตั้งแต่ที่มีเพียงจำนวนที่แน่นอนของการเข้าชมของแต่ละพิกเซล สีสูงสุดดูเหมือนว่าจะเป็นอิสระจากการนับซ้ำและปรับขนาดเชิงเส้นด้วยจำนวนจุดเริ่มต้นทั้งหมด ดังนั้นหากคุณต้องการใช้กริด 1k คูณ 1k คุณอาจต้องการreturn c[i][j]*16;หรือคล้ายกัน แต่บางครั้งปัจจัยดังกล่าวต้องการเล่นซอ

สำหรับผู้ที่ไม่คุ้นเคยกับ Buddhabrot (เหมือนตัวเองเมื่อสองสามวันก่อน) มันขึ้นอยู่กับการคำนวณของ Mandelbrot แต่ความเข้มของแต่ละพิกเซลคือความถี่ที่พิกเซลนั้นถูกเยี่ยมในการวนซ้ำของวิถีการหลบหนี หากเรานับการเยี่ยมชมในระหว่างวิถีกระสุนที่ไม่หลบหนีนั่นเป็น Antibuddhabrot มีเวอร์ชันที่ซับซ้อนยิ่งขึ้นเรียกว่า Nebulabrot ซึ่งคุณใช้ความลึกในการเรียกซ้ำที่แตกต่างกันสำหรับแต่ละช่องสี แต่ฉันจะปล่อยให้คนอื่น สำหรับข้อมูลเพิ่มเติมเช่นเคยวิกิพีเดีย

แต่เดิมฉันไม่ได้แยกแยะระหว่างวิถีการหลบหนีและการไม่หลบหนี นั่นสร้างพล็อตซึ่งเป็นสหภาพของ Buddhabrot และ Antibuddhabrot (ชี้โดย githubphagocyte)

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

อันนี้ดูเหมือนภาพจาง ๆ ... ฉันชอบมัน

Sierpinski Pentagon

คุณอาจเคยเห็นวิธีการเล่นเกมแห่งความโกลาหลในการประมาณสามเหลี่ยมของ Sierpinski โดยการวางจุดครึ่งทางไปยังจุดสุดยอดที่สุ่มเลือก ที่นี่ฉันใช้วิธีเดียวกันโดยใช้ 5 จุดยอด รหัสที่สั้นที่สุดที่ฉันสามารถจับได้รวมการเขียนโค้ด 5 จุดยอดอย่างหนักและไม่มีทางที่ฉันจะปรับมันให้เป็น 140 ตัวอักษรได้ ดังนั้นฉันจึงมอบหมายส่วนประกอบสีแดงให้กับฉากหลังที่เรียบง่ายและใช้พื้นที่ว่างในฟังก์ชันสีแดงเพื่อกำหนดแมโครเพื่อให้อีกสองฟังก์ชันที่มีค่าต่ำกว่า 140 มีเช่นกัน ดังนั้นทุกอย่างใช้ได้ในราคาที่ไม่มีส่วนประกอบสีแดงในรูปห้าเหลี่ยม

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

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

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

ขอบคุณMartin Büttnerสำหรับแนวคิดที่กล่าวถึงในความคิดเห็นของคำถามเกี่ยวกับการกำหนดแมโครในฟังก์ชันหนึ่งเพื่อใช้ในอีกฟังก์ชันหนึ่งและสำหรับการใช้ memoisation เพื่อเติมพิกเซลในลำดับโดยพลการแทนที่จะ จำกัด เฉพาะลำดับแรสเตอร์ของฟังก์ชันหลัก .

รูปภาพมีขนาดเกิน 500KB ดังนั้นจึงได้รับการแปลงเป็น jpg โดยอัตโนมัติด้วยการแลกเปลี่ยนสแต็ก นี่ทำให้รายละเอียดปลีกย่อยบางส่วนดังนั้นฉันจึงได้รวมเฉพาะไตรมาสที่ด้านบนขวาไว้เป็น png เพื่อแสดงรูปลักษณ์ดั้งเดิม:

โน้ตเพลง

เพลง Sierpinski : D พวกในการแชทบอกว่ามันดูเหมือนกระดาษเจาะรูสำหรับกล่องดนตรี

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

รายละเอียดบางอย่างเกี่ยวกับวิธีการใช้งาน ... อืมจริงๆแล้วมันเป็นเพียงการซูมเข้าเพื่อทำให้สามเหลี่ยม Sierpinski เป็นคลื่นบางส่วน ลักษณะของแผ่นเพลง (และความเป็นบล็อค) นั้นเป็นผลมาจากการตัดจำนวนเต็ม ถ้าฉันเปลี่ยนฟังก์ชั่นสีแดงเป็นพูด

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

การตัดจะถูกลบออกและเราได้รับความละเอียดเต็มเรนเดอร์:

ใช่นั่นน่าสนใจ

เครื่องกำเนิดไดอะแกรม Voronoiแบบสุ่มทุกคน?

โอเคอันนี้ทำให้ฉันลำบาก ฉันคิดว่ามันสวยดี แต่แม้ว่าผลจะไม่ให้อาร์ตี้เป็นบางคนอื่น ๆ นั่นคือการจัดการกับการสุ่ม บางทีรูปภาพระดับกลางบางภาพอาจดูดีขึ้น แต่ฉันต้องการมีอัลกอริทึมที่ทำงานได้อย่างสมบูรณ์กับไดอะแกรม voronoi

แก้ไข:

นี่คือตัวอย่างหนึ่งของอัลกอริทึมสุดท้าย ภาพนั้นเป็นภาพซ้อนทับของไดอะแกรม voronoi สามภาพหนึ่งภาพสำหรับแต่ละองค์ประกอบของสี (แดง, เขียว, น้ำเงิน)

รหัส

จบการแสดงความคิดเห็นในตอนท้าย

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

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

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

ฉันใช้ความพยายามอย่างมากดังนั้นฉันจึงรู้สึกอยากแบ่งปันผลลัพธ์ในแต่ละขั้นตอนและมีสิ่งที่ดี (ไม่ถูกต้อง) ที่จะแสดง

ขั้นตอนแรก: มีบางจุดวางแบบสุ่มด้วย x=y

ฉันแปลงเป็น jpeg เพราะ png ดั้งเดิมนั้นหนักเกินกว่าจะอัพโหลดได้ ( >2MB) ฉันคิดว่านั่นเป็นสีเทามากกว่า 50 เฉด!

ประการที่สอง: มีพิกัด y ที่ดีกว่า

ฉันไม่สามารถมีตารางพิกัดอีกชุดที่สร้างขึ้นแบบสุ่มสำหรับyแกนดังนั้นฉันต้องการวิธีง่ายๆในการรับ"สุ่ม"ในตัวละครให้น้อยที่สุด ฉันไปเพื่อใช้xพิกัดของจุดอื่นในตารางโดยทำ bitwise ANDที่ดัชนีของจุดนั้น

วันที่ 3: ฉันจำไม่ได้ แต่มันเริ่มดีขึ้น

แต่ในเวลานี้ฉันได้รับมากกว่า 140 ตัวอักษรดังนั้นฉันจึงจำเป็นต้องตีกอล์ฟลงเล็กน้อย

ที่ 4: scanlines

เพียงแค่ล้อเล่นนี่เป็นสิ่งที่ไม่ต้องการ แต่เป็นอะไรที่เยือกเย็น

ยังคงทำงานเพื่อลดขนาดของอัลกอริทึมฉันภูมิใจที่จะนำเสนอ:

รุ่น StarFox

Voronoi instagram

ที่ 5: เพิ่มจำนวนคะแนน

ตอนนี้ฉันมีโค้ดที่ใช้งานได้ดังนั้นไปจาก 25 ถึง 60 คะแนน

มันยากที่จะเห็นจากภาพเดียว แต่จุดต่าง ๆ นั้นเกือบทั้งหมดอยู่ในyช่วงเดียวกัน แน่นอนฉันไม่ได้เปลี่ยนการดำเนินการระดับบิต&42ดีกว่ามาก:

และที่นี่เราอยู่ที่จุดเดียวกับภาพแรกจากโพสต์นี้ ตอนนี้เรามาอธิบายโค้ดสำหรับสิ่งที่หายากที่จะสนใจ

Ungolfed และอธิบายรหัส

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

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

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

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

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

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

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

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

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

    return t[l];
}

ขอบคุณที่อ่านจนถึงตอนนี้

เศษส่วน Lyapunov

สตริงที่ใช้ในการสร้างสิ่งนี้คือ AABAB และพื้นที่พารามิเตอร์คือ [2,4] x [2,4] ( คำอธิบายเกี่ยวกับพื้นที่สตริงและพารามิเตอร์ที่นี่ )

ด้วยรหัสพื้นที่ที่ จำกัด ฉันคิดว่าสีนี้ค่อนข้างเท่ห์

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

ฉันสร้างชุด Mandelbrot ด้วย มันใช้แผนที่คล้ายกับแผนที่ชุด Mandelbrot Say M (x, y) เป็นแผนที่ Mandelbrot จากนั้น M (sin (x), cos (y)) เป็นแผนที่ที่ฉันใช้และแทนที่จะตรวจสอบค่าการหลบหนีที่ฉันใช้ x และ y เนื่องจากพวกมันถูก จำกัด ขอบเขตเสมอ

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

แก้ไข

หลังจากความเจ็บปวดมากในที่สุดฉันก็กลับไปสร้าง gif ของภาพที่สองที่ morphing นี่มันคือ:

เพราะยูนิคอร์น

ฉันไม่สามารถรับรุ่น OPs ด้วยunsigned shortและค่าสีได้ถึง 1,023 การทำงานดังนั้นจนกว่าจะได้รับการแก้ไขนี่คือรุ่นที่ใช้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);
}

Logistic Hills

ส่วนฟังก์ชั่น

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

Ungolfed

#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++)) ฟังก์ชั่นสีทั้งสามนี้เรียกซึ่งกันและกันและกำหนดมาโครเพื่อให้ใช้กันดังนั้นจึงอ่านได้ไม่ดี แต่แต่ละฟังก์ชั่นนั้นมีความยาวไม่เกิน 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พร้อมภาพทั้งหมดในนั้น ฉันชอบที่จะดูว่าทุกคนสามารถหารูปแบบเกลียวอื่น ๆ นอกจากนี้ฉันต้องบอกว่านี่เป็นหนึ่งในความท้าทายที่ยอดเยี่ยมที่สุดที่ฉันเคยเห็นมา สนุก!

แก้ไข: นี่คือพื้นหลังบางส่วนที่ทำจากเกลียวเหล่านี้ด้วยพารามิเตอร์ที่เปลี่ยนแปลง

นอกจากนี้เมื่อรวมรูปแบบขอบเกลียวของฉันเข้ากับเศษส่วนบางส่วนที่ฉันเห็นที่นี่ผ่านการใช้งานของ xor / และ / หรือการดำเนินงานนี่คือเกลียวสุดท้าย:

บรรณาการให้คลาสสิก

V1 : แรงบันดาลใจจาก "ความสุข" ของ DreamWarrior ส่งตรงไปตรงมานี้ฝังภาพพิกเซลศิลปะขนาดเล็กในแต่ละช่องสี ฉันไม่ต้องตีกอล์ฟด้วยซ้ำ!
V2 : ตอนนี้มีโค้ดที่สั้นกว่ามากและมีเส้นขอบสีดำหนา ๆ แยกเฉพาะ "หน้าจอเกม"
V3 : ยานอวกาศ, กระสุน, มนุษย์ต่างดาวที่เสียหายและเส้นขอบสีน้ำเงิน, โอ้ฉัน! พยายามที่จะมีจุดมุ่งหมายเพื่อการนี้ประมาณ

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

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

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

ฉันบังเอิญสะดุดเมื่อมีการแก้ไขโดยUmber Ferruleซึ่งอวตารเป็นแรงบันดาลใจให้ฉันเพิ่มรายการภาพพิกเซล เนื่องจากแนวคิดหลักของรหัสนั้นคล้ายกับ Space Invaders หนึ่งฉันจึงผนวกมันเข้ากับรายการนี้แม้ว่าทั้งสองจะมีจุดท้าทายที่แตกต่างกัน สำหรับอันนี้การได้สีชมพูที่ถูกต้อง เลขฐานสิบหก escapes ( \xFFฯลฯ ) ในช่องสีแดงแสดงถึงอักขระที่สอดคล้องกันในไฟล์ต้นฉบับ (นั่นคือช่องสีแดงในไฟล์ต้นฉบับมีข้อมูลไบนารี่) ในขณะที่ช่องทางแปดจะเป็นตัวอักษร (เช่นอยู่ในไฟล์ต้นฉบับ)

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

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

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

จิตรกรรมการกระทำ

ฉันอยากลองสร้างบางสิ่งที่คล้ายกับงานของแจ็กสันพอลลอค - การหยดและเทสีลงบนผืนผ้าใบแนวนอน แม้ว่าฉันจะชอบผลลัพธ์ แต่รหัสยาวเกินไปที่จะโพสต์คำถามนี้และความพยายามที่ดีที่สุดของฉันยังลดลงเหลือเพียง 600 ไบต์เท่านั้น ดังนั้นรหัสที่โพสต์ที่นี่ (ซึ่งมีฟังก์ชั่นของ 139 ไบต์ 140 ไบต์และ 140 ไบต์ตามลำดับ) ได้รับการผลิตที่มีจำนวนมหาศาลของความช่วยเหลือจากบางส่วนของอัจฉริยะในการแชท ขอบคุณมากไปที่:

• Eric Tressler
• หิ่งห้อย
• PhiNotPi
• Martin Büttner

สำหรับการเล่นกอล์ฟกลุ่มอย่างไม่หยุดยั้ง

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

แก้ไข:ตอนนี้เป็นคำตอบที่ถูกต้องขอบคุณที่ประกาศไปข้างหน้าและGRBL

สนุกสนานกับลำดับ Q ของ Hofstadter! หากเราใช้ระยะทางรัศมีจากจุดหนึ่งเป็นอินพุทและเอาท์พุทเป็นสีผกผันเราจะได้บางสิ่งที่ดูเหมือนไวนิลสี

ลำดับนั้นคล้ายกับลำดับฟีโบนักชีมาก แต่แทนที่จะกลับไปเป็นลำดับที่ 1 และ 2 ในลำดับคุณต้องใช้ค่าก่อนหน้านี้สองค่าเพื่อพิจารณาว่าจะย้อนกลับไปอีกเท่าใดก่อนที่จะรวม มันเติบโตเป็นเส้นตรง ๆ แต่ทุก ๆ คราวมีความโกลาหล (ในช่วงเวลาที่เพิ่มมากขึ้น) ซึ่งจะตกลงไปเป็นลำดับเชิงเส้นเกือบอีกครั้งก่อนการระเบิดครั้งต่อไป:

คุณสามารถดูระลอกคลื่นเหล่านี้ในภาพหลังภูมิภาคซึ่งมีสี "แบน" มาก

แน่นอนว่าการใช้สีเดียวน่าเบื่อ

ตอนนี้สำหรับรหัส ฉันต้องการฟังก์ชั่นวนซ้ำเพื่อคำนวณลำดับ เมื่อต้องการทำเช่นนั้นฉันจะใช้RDเมื่อใดก็ตามที่jเป็นลบ น่าเสียดายที่ไม่มีอักขระมากพอที่จะคำนวณค่าช่องสีแดงเองดังนั้นRDในทางกลับกันการโทรGRด้วยการชดเชยเพื่อสร้างช่องสีแดง

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

แน่นอนว่านี่เป็นการใช้ซีเควนซ์ที่ง่ายที่สุดและมีจำนวนอักขระที่เหลืออยู่ รู้สึกอิสระที่จะยืมและทำสิ่งที่บ้าอื่น ๆ ด้วย!

นี่คืออีกเวอร์ชั่นที่ขอบเขตและสีถูกกำหนดโดยลำดับ Q ในกรณีนี้มีพื้นที่เพียงพอในการRDที่ฉันไม่ต้องการประกาศไปข้างหน้า:

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

สิ่งนี้คำนวณการแปลง Joukowskyของชุดของวงกลมศูนย์กลางที่ศูนย์กลางที่จุดที่ชดเชยจากจุดกำเนิดเล็กน้อย ฉันปรับเปลี่ยนความเข้มเล็กน้อยในช่องสีฟ้าเพื่อให้ความแตกต่างของสีเล็กน้อย

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

Objective-C

เขียนโค้ด C ++ ใหม่ใน Objective-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ฯลฯ ก่อนที่จะมีการประมวลผล

Splash Sierpinski

ฉันต้องการที่จะเล่นกับสีมากขึ้นดังนั้นฉันจึงเปลี่ยนคำตอบอื่น ๆ (คำตอบที่ swirly) และในที่สุดก็จบลงด้วยสิ่งนี้

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

พิกเซลสีดำทั้งหมด:

พิกเซลสุ่มหลอก:

และแน่นอนว่าโฮสต์ของผลลัพธ์ที่เป็นไปได้อื่น ๆ ขึ้นอยู่กับคอมไพเลอร์คอมพิวเตอร์ตัวจัดการหน่วยความจำ ฯลฯ

Groovy

ตรีโกณมิติและเทคนิคมาโครแปลก ๆ

RD:

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

GR:

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

BL:

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

แก้ไข: ถ้าM_PIไม่ได้รับอนุญาตเนื่องจากเพียงเป็นปัจจุบันในระบบ POSIX 3.14ได้ที่จะสามารถแทนที่ด้วยตัวอักษร

ฉันไม่เก่งคณิตศาสตร์ ฉันเป็นนักเรียนคณิตศาสตร์ที่ยากจนเสมอ ดังนั้นฉันจึงทำง่าย

ฉันใช้รหัส Javascript ของ user1455003 ที่แก้ไขแล้ว และนี้เป็นรหัสของฉันเต็ม

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

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

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

มันสั้นมากดังนั้นฟังก์ชั่นทั้งสามนี้จึงเหมาะกับการทวีตเดียว

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

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

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

อีกฟังก์ชั่นที่สั้นมาก ๆ ฉันพบรูปแบบ sierpinski นี้ (และรูปแบบแทนเจนต์) ในขณะที่ยุ่งกับฟังก์ชันคณิตศาสตร์ต่างๆ นี่คือรหัสเต็ม

JavaScript

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

document.body.appendChild(can);

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

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

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

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

อีกรุ่น ฟังก์ชั่นร่างกายทวีตได้

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

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

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

ฟังก์ชั่นปรับแต่งภาพ วาด (rgbFunctions, setCloseEvent);

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

สีม่วง

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

draw(purple,true);

จิตรกรดาวเคราะห์

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

แรงบันดาลใจจากการเข้าร่วมที่ยอดเยี่ยมของมาร์ตินนี่เป็นสิ่งที่แตกต่าง แทนที่จะเริ่มจากการสุ่มพิกเซลบางส่วนฉันเริ่มจากมุมซ้ายบนเป็น RGB (512,512,512) และสุ่มเดินแต่ละสีจากที่นั่น ผลลัพธ์ดูเหมือนว่าบางอย่างจากกล้องโทรทรรศน์ (imo)

แต่ละพิกเซลใช้ค่าเฉลี่ยของพิกเซลด้านบน / ซ้ายของมันและเพิ่มบิตแบบสุ่ม คุณสามารถเล่นกับความแปรปรวนโดยการเปลี่ยนpตัวแปร แต่ฉันคิดว่าสิ่งที่ฉันใช้คือความสมดุลที่ดี (ส่วนใหญ่เป็นเพราะฉันชอบสีฟ้าดังนั้นความผันผวนที่เบลอมากขึ้นจะให้ผลลัพธ์ที่ดี)

มีอคติเชิงลบเล็กน้อยจากการหารจำนวนเต็มเมื่อเฉลี่ย ฉันคิดว่ามันใช้งานได้ดีและให้เอฟเฟกต์สีเข้มที่มุมล่าง

แน่นอนว่าเพื่อให้ได้ผลลัพธ์มากกว่าหนึ่งรายการคุณจะต้องเพิ่มsrand()บรรทัดในฟังก์ชันหลักของคุณ

คลื่นสะท้อน

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

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

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

รูปแบบกระดานหมากรุกขั้นพื้นฐานบิดเบี้ยวตามตำแหน่งของคลื่นที่ขยายจากจุดที่เหมือนก้อนหินที่ตกลงไปในสระน้ำ ตัวแปรwคือจำนวนพิกเซลจากจุดที่คลื่นเคลื่อนย้าย หากwมีขนาดใหญ่พอคลื่นจะสะท้อนจากด้านข้างของภาพ

w = 225

w = 360

w = 5390

นี่คือ GIF ที่แสดงการต่อเนื่องของภาพเมื่อคลื่นขยายออก ฉันได้จัดเตรียมขนาดที่แตกต่างกันจำนวนมากแต่ละเฟรมจะแสดงภาพได้มากเท่าที่ จำกัด ขนาดไฟล์ 500KB

หากฉันสามารถหาวิธีที่จะทำให้พอดีกับมันฉันต้องการที่จะสร้างแบบจำลองการแทรกสอดของคลื่นเพื่อให้คลื่นดูสมจริงยิ่งขึ้นเมื่อพวกเขาข้าม ฉันพอใจกับการสะท้อน

โปรดทราบว่าฉันไม่ได้จำลองการสะท้อนของคลื่นจริงๆใน 3 ล็อตของ 140 ไบต์ ไม่มีการสะท้อนใด ๆ ที่เกิดขึ้นมันแค่เกิดขึ้นกับมัน ฉันซ่อนคำอธิบายไว้ในกรณีที่ทุกคนต้องการเดาก่อน:

คลื่นสะท้อนแรกนั้นเหมือนกับคลื่นที่เกิดจากอีกด้านหนึ่งของขอบภาพซึ่งเป็นระยะทางห่างจากจุดเดิม ดังนั้นรหัสจะคำนวณตำแหน่งที่ถูกต้องสำหรับ 4 คะแนนที่จำเป็นในการให้เอฟเฟกต์การสะท้อนจากแต่ละขอบทั้งสี่ ระดับของคลื่นสะท้อนที่เพิ่มขึ้นนั้นจะเหมือนกับคลื่นที่เกิดขึ้นในแผ่นกระเบื้องที่อยู่ไกลออกไป รหัสนี้ให้ภาพลวงตา 8 ระดับของการสะท้อนโดยการแสดงวงกลมขยาย 189 อันแยกกันแต่ละอันอยู่ในจุดที่ถูกต้องในตาราง 17 โดย 17 เพื่อให้พวกเขาผ่านจัตุรัสกลางของตาราง (นั่นคือตารางภาพ) ที่ เวลาที่เหมาะสมเพื่อให้การแสดงผลของระดับการสะท้อนที่ต้องการในปัจจุบัน โค้ดนี้ใช้ง่าย (และสั้น!) แต่ทำงานค่อนข้างช้า ...