정수 수학은 그리드 위에 배치 될 때 놀라운 패턴을 생성 할 수 있습니다. 가장 기본적인 기능조차도 놀랍도록 정교한 디자인을 만들 수 있습니다!

당신의 도전

1024x1024 이미지의 빨강, 녹색 및 파랑 값에 대해 3 개의 트러블 가능 (140 자 이하) 함수 본문을 작성하십시오.

함수에 대한 입력은 두 개의 정수 i (주어진 픽셀의 열 수)와 j (주어진 픽셀의 행 수)가되고 출력은 0과 1023 사이의 부호없는 short가되며 주어진 양을 나타냅니다. 픽셀에 존재하는 색 (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 자 이하 여야합니다.
• 이것은 인기 콘테스트입니다. 대부분의 투표에서 승리합니다

만델 브로트 3 x 133 문자

내 마음에 떠오른 첫 번째 것은 "Mandelbrot!"입니다.

예, 이미 만델 브로트 제출이 있음을 알고 있습니다. 140 자 미만으로 얻을 수 있음을 확인한 후 해당 솔루션의 트릭과 최적화를 마틴과 토드에게 감사했습니다. 멋진 색상 테마뿐만 아니라 흥미로운 위치와 줌을 선택할 수있는 공간이 남아 있습니다.

unsigned char RD(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,3.);
}
unsigned char GR(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.7);
}
unsigned char BL(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.5);
}

총 132 자

3 채널 모두 140으로 낮추려고했습니다. 가장자리 근처에 약간의 색상 노이즈가 있으며 위치는 첫 번째만큼 흥미롭지는 않지만 132 자입니다.

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}

테이블 보

플랫

나는 무한한 테이블 천처럼 격자 무늬 / 깅엄 패턴을 원근법으로 시작하기 시작했습니다.

unsigned char RD(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}

리플

그런 다음 잔물결을 도입했습니다 (엄격한 관점은 아니지만 여전히 140 자).

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}

색깔

그런 다음 더 넓은 범위의 세부 정보를 제공하고 그림을 더 화려하게 만들기 위해 일부 색상을 더 세밀하게 만들었습니다.

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;
}

모션

코드를 약간 더 줄이면 소수점 이하 2 자리로 웨이브 위상 P를 정의 할 수 있습니다. 이는 부드러운 애니메이션을 위해 충분히 가까운 프레임에 충분합니다. 나는이 단계에서 해병을 유발하지 않기 위해 진폭을 줄였으며, 이미지의 상단에서 앨리어싱을 푸시하기 위해 전체 이미지를 추가 151 픽셀 (1 개의 추가 문자 비용)까지 추가했습니다. 애니메이션 앨리어싱은 매력적입니다.

unsigned char RD(int i,int j){
#define P 6.03
float s=3./(j+250),y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;}

unsigned char GR(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;}

unsigned char BL(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;}

무작위 화가

char red_fn(int i,int j){
#define r(n)(rand()%n)
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):red_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char green_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):green_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char blue_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):blue_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}

다음은 무작위 기반 항목입니다. 픽셀의 약 0.1 %는 랜덤 컬러를 선택하고, 다른 컬러는 랜덤 인접 픽셀과 동일한 컬러를 사용합니다. 각 색상은 독립적으로이 작업을 수행하므로 실제로 임의의 녹색, 파란색 및 빨간색 그림의 오버레이 일뿐입니다. 다른 런에서 다른 결과를 얻으려면 함수 에 추가 srand(time(NULL))해야합니다 main.

이제 몇 가지 변형이 있습니다.

픽셀을 건너 뛰면 좀 더 흐릿하게 만들 수 있습니다.

그런 다음 색상을 천천히 변경하여 오버플로로 인해 갑자기 변경되어 브러시 스트로크처럼 보이게합니다.

내가 알아 내야 할 것들 :

• 어떤 이유로 든 srandsegfault를 얻지 않고는 그 함수에 넣을 수 없습니다 .
• 임의의 보행을 세 가지 색상 모두에서 동일하게 만들 수 있다면 조금 더 정연하게 보일 수 있습니다.

랜덤 워크를 등방성으로 만들 수도 있습니다.

static char c[1024][1024];return!c[i][j]?c[i][j]=r(999)?red_fn((i+r(5)+1022)%1024,(j+r(5)+1022)%1024):r(256):c[i][j];

당신에게

더 많은 무작위 그림

나는 이것으로 조금 더 놀고 다른 임의의 그림을 만들었습니다. 이 도전의 한계 내에서 이러한 모든 것이 가능하지는 않으므로 여기에 포함하고 싶지 않습니다. 그러나이 imgur 갤러리 에서 내가 어떻게 생산했는지에 대한 설명과 함께 볼 수 있습니다.

이 모든 가능성을 프레임 워크로 개발하고 GitHub에 적용하고 싶습니다. (이런 것들은 아직 존재하지 않지만 어쨌든 재미 있습니다!)

소용돌이 치는 뾰족한 것들

예, 이름을 정확히 알고있었습니다.

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

편집 : 더 이상 사용하지 않습니다 pow. 편집 2 : @PhiNotPi는 abs를 많이 사용할 필요가 없다는 것을 지적했습니다.

기준점을 매우 쉽게 변경하여 다른 그림을 얻을 수 있습니다.

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

@EricTressler는 내 사진에 배트맨이 있다고 지적했습니다.

물론 Mandelbrot 제출이 있어야합니다.

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

지금 색 구성표를 개선하려고합니다. 계산을 매크로로 정의하고 red_fn다른 두 매크로에서 해당 매크로를 사용하면 녹색과 파란색으로 멋진 색상 선택을위한 더 많은 문자를 사용할 수 있습니다.

편집 : 이 적은 바이트로 적절한 색 구성표를 만드는 것은 실제로 어렵습니다. 다른 버전은 다음과 같습니다.

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

그리고 githubphagocyte의 제안과 Todd Lehman의 개선에 따라 더 작은 섹션을 쉽게 선택할 수 있습니다.

예 :

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

준다

줄리아 세트

Mandelbrot가 있다면 Julia도 있어야합니다.

매개 변수와 기능을 조정하는 데 시간을 할애 할 수 있으므로 괜찮은 것처럼 보입니다.

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

RNG를 원하십니까?

좋아, Sparr의 의견은이 작은 줄리아의 매개 변수를 무작위 화하기 위해 저를 궤도에 올려 놓았습니다. 나는 처음에 결과로 비트 레벨 해킹을 시도 time(0)했지만 C ++은 16 진수 부동 소수점 리터럴을 허용하지 않으므로 이것은 (최소한 제한된 지식으로) 막 다른 골목이었습니다. 나는 그것을 달성하기 위해 무거운 캐스팅을 사용할 수 있었지만 140 바이트에는 맞지 않았습니다.

어쨌든 남은 공간이 많지 않았기 때문에 매크로를 배치하고 더 전통적인 RNG ( timed seed and real rand(), woohoo!)를 갖기 위해 빨간색 Julia를 떨어 뜨려야했습니다 .

죄송합니다. 뭔가 빠졌습니다. 분명히,이 매개 변수는 정적이거나 그렇지 않은 경우 이상한 결과가 발생합니다 (그러나 재미있는 것은 흥미로운 것을 발견하면 조금 나중에 조사 할 것입니다).

여기 녹색과 파란색 채널 만 있습니다.

이제 빈 공간을 채우기 위해 간단한 빨간색 패턴을 추가하겠습니다. 상상력이 좋지 않지만 그래픽 프로그래머는 아닙니다 ... 아직 :-)

마지막으로 임의의 매개 변수가있는 새로운 코드 :

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

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

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

아직 방이 남아 있습니다 ...

이것은 i, j 매개 변수를 전혀 사용하지 않기 때문에 흥미 롭습니다. 대신 정적 변수의 상태를 기억합니다.

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

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

붓다 브로트 (+ Antibuddhabrot)

편집 : 그것은 이제 올바른 Buddhabrot입니다!

편집하다: 바이트 제한 내에서 색상 강도를 제한 했으므로 오버플로로 인해 더 이상 잘못된 검은 픽셀이 없습니다.

나는 4시 이후에 멈춰 가고 싶었지만 ...

이것은 업로드하는 동안 약간 압축되어 (임베딩시 축소) 모든 세부 사항에 감탄하고 싶다면 흥미로운 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 반복으로 괜찮은 결과를 얻을 수 있으며, 2 분이 소요되며 1k 반복을 가진 1k x 1k 그리드조차도 아주 좋아 보입니다 (3 초 정도 소요). 이러한 매개 변수를 사용하려면 몇 가지 변경해야 할 부분이 있습니다.

• Mandelbrot 재귀 깊이를 변경하려면 5e5in의 두 인스턴스를 BL반복 횟수로 조정 하십시오.
• 그리드 해상도를 변경하려면 4 개 4096를 모두 RD원하는 해상도로 변경 1024.하고GR 올바른 스케일링을 유지하기 위해 같은 배.
• 당신은 아마 또한 확장해야합니다 return c[i][j]에를 GR즉 각 픽셀의 방문의 절대 수를 포함하고 있기 때문에. 최대 색상은 대부분 반복 횟수와 무관 한 것으로 보이며 총 시작점 수에 따라 선형으로 조정됩니다. 따라서 1k x 1k 격자를 사용하려면 원 return c[i][j]*16;하거나 비슷할 수 있지만 그 요소는 때때로 약간의 조정이 필요합니다.

Buddhabrot에 익숙하지 않은 사람들 (2 일 전과 마찬가지로)은 Mandelbrot 계산을 기반으로하지만 각 픽셀의 강도는 이스케이프 궤적의 반복에서 픽셀이 얼마나 자주 방문했는지입니다. 이스케이프가없는 궤적 동안 방문수를 계산하는 경우 Antibuddhabrot입니다. Nebulabrot이라는보다 정교한 버전이 있으며 각 색상 채널마다 다른 재귀 깊이를 사용합니다. 그러나 나는 그것을 다른 누군가에게 맡길 것입니다. 항상 그렇듯이 Wikipedia에 대한 자세한 정보 .

원래는 탈출 경로와 비 탈출 경로를 구분하지 않았습니다. 그것은 Buddhabrot와 Antibuddhabrot (githubphagocyte에 의해 지적 된)의 결합 인 음모를 생성했습니다.

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

이 사진은 희미한 사진처럼 보입니다.

시 에르 핀 스키 국방부

무작위로 선택한 정점에 반을 점을 그려서 Sierpinski의 Triangle을 근사화 하는 혼돈 게임 방법을 보았을 것 입니다. 여기 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];}

덕분에 마틴 있음 Büttner 오히려 주요 기능의 래스터 순서에 한정되는 것이 아니라 임의의 순서로 픽셀을 채우기 위해 메모이 제이션을 사용하는 또한 다음 다른에서 사용하는 하나 개의 기능에 매크로를 정의하고, 대한 질문의 의견에 언급 된 아이디어 .

이미지가 500KB를 초과하므로 스택 교환에 의해 jpg로 자동 변환됩니다. 이것은 미세한 디테일을 흐리게하기 때문에 원래 모양을 보여주기 위해 오른쪽 상단을 png로 포함했습니다.

망할 음악

시 에르 핀 스키 음악. : D 채팅을하는 사람들은 음악 상자의 구멍을 뚫은 종이처럼 보입니다.

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

이것이 어떻게 작동하는지에 대한 일부 세부 사항 ... 음, 실제로 물결 모양의 Sierpinski 삼각형의 렌더링에서 확대 일뿐입니다. 악보 모양 (및 블록도)은 정수 잘림의 결과입니다. 빨간색 기능을 다음과 같이 변경하면

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

잘림이 제거되고 전체 해상도 렌더링을 얻습니다.

예, 흥미 롭습니다.

랜덤 보로 노이 다이어그램 생성기 누구?

좋아, 이것은 나에게 어려운 시간을 주었다. 나는 결과가 다른 것들 만큼 예술적 이지 않더라도 꽤 멋지다고 생각합니다 . 그것은 무작위성에 관한 것입니다. 일부 중간 이미지가 더 좋아 보일 수도 있지만 voronoi 다이어그램으로 완전히 작동하는 알고리즘을 원했습니다.

편집하다:

이것이 최종 알고리즘의 한 예입니다. 이미지는 기본적으로 각 색 구성 요소 (빨강, 녹색, 파랑)마다 하나씩 3 개의 보로 노이 다이어그램의 중첩입니다.

암호

끝에 ungolfed, 댓글 버전

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

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

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

많은 노력이 필요했기 때문에 결과를 다른 단계에서 공유하고 싶은 느낌이 들었습니다.

첫 번째 단계 : 일부 점을 무작위로 배치하고 x=y

원본 png가 너무 커서 업로드 ( >2MB) 하기 때문에 jpeg로 변환했습니다 .

둘째 : 더 나은 y 좌표를 가지십시오

y축에 대해 무작위로 생성 된 다른 좌표 테이블을 가질 여유가 없었기 때문에 가능한 한 적은 문자로 " 임의의 " 좌표 를 얻는 간단한 방법이 필요했습니다 . x포인트 AND의 인덱스 에서 비트 단위로 테이블의 다른 포인트 좌표 를 사용했습니다 .

세번째 : 기억 나지 않지만 점점 좋아지고 있습니다

그러나이 시점에서 나는 140자를 넘었습니다.

네 번째 : 스캔 라인

농담, 이것은 원치 않는 일종의 시원하고 methinks입니다.

알고리즘의 크기를 줄이는 데 여전히 노력하고 있으며, 나는 자랑스럽게 발표합니다.

스타 폭스 에디션

보로 노이 instagram

다섯 번째 : 포인트 수를 늘리십시오

이제 코드가 작동하므로 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];
}

지금까지 읽어 주셔서 감사합니다.

리아 푸 노프 프랙탈

이를 생성하는 데 사용 된 문자열은 AABAB이고 매개 변수 공간은 [2,4] x [2,4]입니다. ( 문자열 및 매개 변수 공간에 대한 설명은 여기 )

제한된 코드 공간 으로이 색상이 꽤 시원하다고 생각했습니다.

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

또한 Mandelbrot 세트를 변형했습니다. Mandelbrot 세트 맵과 유사한 맵을 사용합니다. M (x, y)가 Mandelbrot 맵이라고 가정하십시오. 그런 다음 M (sin (x), cos (y))는 내가 사용하는 맵이며, 이스케이프 값을 확인하는 대신 항상 경계가 있기 때문에 x와 y를 사용합니다.

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

편집하다

많은 고통을 겪은 후 마침내 두 번째 이미지 모핑의 GIF를 만들었습니다. 여기있어:

유니콘 이니까

unsigned short1023까지의 색상 값과 작동 하는 OPs 버전을 얻을 수 없으므로 수정 될 때까지 char255의 최대 색상 값을 사용하는 버전이 있습니다.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}

물류 언덕

기능

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

언 골프

#define은 모두 140 자 미만의 BL에 맞아야합니다. 다음은 수정되지 않은 파란색 알고리즘 버전이며 약간 수정되었습니다.

for(double a=0;a<DIM;a+=0.1){       // Incrementing a by 1 will miss points
    for(int b=0;b<DIM;b++){         // 1024 here is arbitrary, but convenient
        double r = a*(1.6/DIM)+2.4; // This is the r in the logistic bifurcation diagram (x axis)
        double x = 1.0001*b/DIM;    // This is x in the logistic bifurcation diagram (y axis). The 1.0001 is because nice fractions can lead to pathological behavior.
        for(int k=0;k<DIM;k++){
            x = r*x*(1-x);          // Apply the logistic map to x
            // We do this DIM/2 times without recording anything, just to get x out of unstable values
            if(k>DIM/2){
                if(c[(int)a][(int)(DM1*x)]<255){
                    c[(int)a][(int)(DM1*x)]+=0.01; // x makes a mark in c[][]
                } // In the golfed code, I just always add 0.01 here, and clip c to 255
            }
        }            
    }    
}

주어진 r에 대해 x의 값이 가장 자주 떨어지는 경우 (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;
}

나는 점차적으로 간단한 나선형을 만들어 나선형 가장자리에 패턴을 추가하고 다른 나선형을 결합하여 멋지게 보이게하는 방법을 실험했습니다. 다음은 각 조각의 기능을 설명하는 주석이 포함 된 ungolfed 버전입니다. 매개 변수를 사용하여 재미있는 결과를 얻을 수 있습니다.

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

매개 변수를 사용한 메시지 :

여기서 나선은 일렬로 정렬되어 있지만 다른 가장자리 패턴이 있습니다. 메인 예제에서 고르지 않은 가장자리 대신, 이것은 완전히 죄 파로 구성된 가장자리를 가지고 있습니다.

여기에서 그라디언트가 제거되었습니다.

애니메이션 ( 업로드 후 어떤 이유로 루프가 반복되지 않는 것처럼 보입니다. 죄송합니다. 또한 축소해야했습니다. 애니메이션을 놓치면 새 탭에서 열면됩니다 ) :

여기 모든 이미지가 담긴 이미지 앨범 이 있습니다. 다른 멋진 나선형 패턴을 찾을 수 있는지 알고 싶습니다. 또한 이것은 제가 지금까지 본 것 중 가장 멋진 과제 중 하나라고 말해야합니다. 즐겨!

편집 : 다음은 매개 변수가 변경된이 나선으로 만든 배경 입니다.

또한, 나선형 가장자리 패턴을 xor 및 / 또는 연산을 사용하여 여기에서 본 프랙탈과 결합하여 최종 나선형이 있습니다.

고전에 찬사

V1 : DreamWarrior의 "Be happy"에서 영감을 얻은이 간단한 제출물은 각 컬러 채널에 작은 픽셀 아트 이미지를 포함시킵니다. 코드를 골프로 칠 필요조차 없었습니다!
V2 : 이제 "게임 화면"만 분리하는 상당히 짧은 코드와 두꺼운 검은 색 테두리가 있습니다.
V3 : 우주선, 총알, 손상된 외계인과 파란 경계, 오 마이! 대략 이것을 목표로하려고합니다 .

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

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

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

나는 아바타가 저에게 픽셀 아트 기반 항목을 추가하도록 영감을 준 Umber Ferrule 의 편집을 우연히 발견했습니다 . 코드의 핵심 아이디어는 Space Invaders 1과 거의 유사하기 때문에이 항목에 추가하고 있지만 두 가지 문제는 분명히 다릅니다. 이것을 위해, 분홍색을 얻는 것은 (흰색을 희생해서) 그리고 그것이 큰 스프라이트라는 사실은 좋은 도전이었습니다. \xFF빨간색 채널 의 16 진 이스케이프 등은 소스 파일에서 해당 문자를 나타냅니다 (즉, 소스 파일의 빨간색 채널에 이진 데이터가 포함되어 있음). 8 진 이스케이프는 리터럴 (즉, 소스 파일에 있음)입니다.

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

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

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

액션 페인팅

Jackson Pollock 의 작업과 비슷한 것을 재현하려고 했습니다. 수평 캔버스 위에 페인트를 쏟고 붓는 것입니다. 결과가 마음에 들었지만이 질문에 게시하기에는 코드가 너무 길었고 최선의 노력으로 여전히 약 600 바이트로 줄였습니다. 따라서 여기에 게시 된 코드 (각각 139 바이트, 140 바이트 및 140 바이트의 기능을 가짐)는 chat의 일부 천재 사람들로부터 많은 도움을 받아 생성되었습니다 . 덕분에

• 에릭 테 슬러
• 파이어 플라이
• 피노 피
• 마틴 부트 너

끊임없는 그룹 골프 세션.

unsigned char RD(int i,int j){
#define E(q)return i+j?T-((T-BL(i,j))*q):T;
#define T 255
#define R .1*(rand()%11)
#define M(v)(v>0&v<DIM)*int(v)
#define J [j]*250;
E(21)}

unsigned char GR(int i,int j){
#define S DIM][DIM],n=1e3,r,a,s,c,x,y,d=.1,e,f;for(;i+j<1&&n--;x=R*DM1,y=R*DM1,s=R*R*R*R,a=R*7,r=s*T)for(c=R;r>1;x+=s*cos(a),y+=s*sin
E(21)}

unsigned char BL(int i,int j){static float m[S(a),d=rand()%39?d:-d,a+=d*R,s*=1+R/99,r*=.998)for(e=-r;e++<r;)for(f=-r;f++<r;)m[M(x+e)*(e*e+f*f<r)][M(y+f)]=c;return T-m[i]J}

E (q) 매크로는 RD 및 GR 기능에 사용됩니다. 인수 값을 변경하면 색상의 빨강 및 녹색 구성 요소가 변경되는 방식이 변경됩니다. J 매크로는 파란색 구성 요소의 변경 정도를 결정하는 데 사용되는 숫자로 끝나며, 그 결과 계산 된 빨간색 및 녹색 구성 요소에 영향을 미칩니다. 나는 다양한 색상 조합을 보여주기 위해 E의 빨강 및 녹색 인수가 다양한 이미지를 포함했습니다. 직접 실행하려면 빨강 및 녹색 값의 이미지 위로 마우스를 가져갑니다.

이러한 이미지는 모두 다운로드하면 전체 크기로 볼 수 있습니다. 플랫 색상이 PNG 압축 알고리즘에 적합하므로 파일 크기가 작으므로 사이트에 업로드하기 위해 손실 압축이 필요하지 않습니다.

우리가 다른 것들을 시도했을 때 골프 과정에서 다양한 단계의 이미지를보고 싶다면 액션 페인팅 채팅을 살펴보십시오 .

내가이 코드 의 매개 변수를 가지고 놀 것 같아 ... 모든 크레딧은 @Manuel Kasten에 간다. 이것들은 너무 멋져서 게시에 저항 할 수 없었습니다.

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 1000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);

BubbleGumRupture http://i57.tinypic.com/3150eqa.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 40*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 10*pow((n)/800,.5);

SeussZoom http://i59.tinypic.com/am3ypi.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 4000*pow((n)/800,.5);

SeussEternalForest http://i61.tinypic.com/35akv91.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);

편집 :GR 및 의 앞으로 선언 덕분에 이제는 올바른 답변 BL입니다.

Hofstadter의 Q 순서와 재미! 어떤 점에서 방사상 거리를 입력으로 사용하고 출력을 역 색상으로 사용하면 컬러 비닐처럼 보입니다.

시퀀스는 피보나치 시퀀스와 매우 유사하지만 시퀀스에서 1 단계와 2 단계를 뒤로 이동하는 대신 두 개의 이전 값을 사용 하여 합계를 가져 오기 전에 되돌아가는 거리를 결정 합니다. 그것은 대략 선형으로 자라지 만, 매번 혼란스러워지고 (간격이 증가함에 따라) 다음 버스트 전에 거의 선형 시퀀스로 다시 내려갑니다.

색상이 "평평하게"보이는 영역 뒤의 이미지에서 이러한 잔물결을 볼 수 있습니다.

물론 하나의 색상 만 사용하는 것은 지루합니다.

이제 코드입니다. 시퀀스를 계산하려면 재귀 함수가 필요합니다. 내가 부정적인 것을 RD할 때마다 사용 j합니다. 불행히도, 그것은 빨강 채널 값 자체를 계산하기에 충분한 문자를 남기지 않으므로, 빨강 채널 을 생성하기 위해 오프셋으로 RD호출 GR합니다.

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

물론 이것은 시퀀스의 가능한 가장 간단한 사용법이며 많은 문자가 남아 있습니다. 자유롭게 빌리고 다른 미친 일을하세요!

Q 시퀀스에 의해 경계와 색상이 결정되는 다른 버전이 있습니다. 이 경우 충분한 RD선언이 있었으므로 앞으로 선언이 필요하지 않았습니다.

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

원점에서 약간 오프셋 된 점을 중심으로 한 동심원 세트의 Joukowsky 변환 을 계산합니다 . 약간의 색 변화를주기 위해 파란색 채널의 강도를 약간 수정했습니다.

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

목표 -C

Objective-C cos에서 C ++ 코드를 다시 작성하여 컴파일 할 수 없었습니다. 내 iPad에서 실행할 때 다른 답변과 동일한 결과를 얻었으므로 모두 좋습니다.

내 제출 내용은 다음과 같습니다.

그 뒤에있는 코드는 매우 간단합니다.

unsigned short red_fn(int i,int j)
{
    return j^j-i^i;
}
unsigned short green_fn(int i,int j)
{
    return (i-DIM)^2+(j-DIM)^2;
}
unsigned short blue_fn(int i,int j)
{
    return i^i-j^j;
}

당신은 곱하여 사각형을 확대 할 수 있습니다 i및 j하여 0.5, 0.25그들이 처리되기 전에 등.

시 에르 핀 스키 페인트 얼룩

나는 색상으로 더 많은 것을 즐기고 싶었고 그래서 나는 다른 대답 (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);
}

이제 내 아바타입니다. :피

이 정의를 제출하여 "정의되지 않은 동작"이라고 부르면 컴파일러가 값을 반환하지만 그렇지 않은 함수로 수행하는 작업을 설명합니다.

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

모든 검은 색 픽셀 :

의사 랜덤 픽셀 :

물론 컴파일러, 컴퓨터, 메모리 관리자 등에 따라 다른 많은 가능한 결과가 있습니다.

멋진, 근사한

일부 삼각법과 이상한 매크로 트릭입니다.

RD :

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

GR :

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

BL :

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

편집 : M_PIPOSIX 호환 시스템에만 존재하여 허용되지 않으면 리터럴로 대체 할 수 있습니다 3.14.

나는 수학을 잘 못합니다. 나는 항상 수학 수업에서 가난한 학생이었습니다. 그래서 나는 간단한 것을 만들었습니다.

수정 된 user1455003의 Javascript 코드를 사용했습니다 . 그리고 이것은 내 전체 코드 입니다.

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

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

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

매우 짧아서 세 기능이 모두 하나의 트윗에 적합합니다.

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 패턴 (및 일부 접선 패턴)을 발견했습니다. 이것은 전체 코드입니다

자바 스크립트

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

document.body.appendChild(can);

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

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

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

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

다른 버전. 기능 몸체는 트위스트 가능합니다.

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

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

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

이미지 렌더링 기능을 수정했습니다. draw (rgb 함수, 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;

Martin의 멋진 작품 에서 영감을 얻은 이 제품은 다른 제품입니다. 픽셀의 일부를 무작위로 시드하는 대신 왼쪽 상단 모서리에서 RGB (512,512,512)로 시작하여 거기에서 각 색상을 무작위로 걷습니다. 결과는 망원경 (imo)에서 나온 것 같습니다.

각 픽셀은 픽셀의 위 / 왼쪽에있는 픽셀의 평균을 취하여 비트 o '랜덤을 추가합니다. 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 파일 크기 제한이 허용하는 한도까지 많은 프레임을 표시하는 다양한 크기를 제공했습니다.

그에 맞는 방법을 찾을 수 있다면, 파도가 교차 할 때 더욱 사실적으로 보이도록 파도 간섭을 모델링하는 것이 이상적입니다. 그래도 반성에 만족합니다.

140 바이트의 3 로트에서 웨이브 반사를 실제로 모델링하지 않았습니다. 실제로 어떤 반사도 일어나지 않습니다. 단지 반사처럼 보입니다. 누군가 먼저 추측하고 싶을 경우를 대비하여 설명을 숨겼습니다.

첫 번째 반사파는 원점과 같은 거리에있는 이미지 가장자리의 다른 쪽에서 발생하는 파와 동일합니다. 따라서 코드는 4 개의 각 모서리에서 반사 효과를주기 위해 필요한 4 개의 점에 대한 올바른 위치를 계산합니다. 평면에서 하나의 타일로 이미지를 상상할 경우, 더 높은 수준의 반사파는 더 멀리 떨어진 타일에서 나오는 파도와 모두 동일합니다. 이 코드는 각각 17 x 17 격자의 정확한 지점에 배치 된 189 개의 개별 확장 원을 표시하여 8 단계 반사의 환상을 제공합니다. 현재 필요한 반사 수준을 감상 할 수있는 적절한시기입니다. 이것은 코드 작성이 간단하고 짧지 만 매우 느리게 실행됩니다 ...