Tweetable 수학적 예술 [닫힘]


330

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

당신의 도전

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

패턴 -1

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

패턴 -2

규칙

  • 이 C ++ 코드가 주어지면 함수를 대체하십시오. 몇 가지 매크로를 제공하고 라이브러리를 포함 시켰으며 complex.h를 포함 할 수 있습니다. 이 라이브러리 및 / 또는 내 매크로의 기능을 사용할 수 있습니다. 이 이외의 외부 리소스를 사용하지 마십시오.
  • 해당 버전이 작동하지 않으면 다음을 사용하여 컴파일하고 있는지 확인하십시오.

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

    그래도 작동하지 않으면 부호없는 반바지 대신 부호없는 문자 를 사용하는 대체 버전을 사용하십시오.

Michaelangelo는 정리 된 24 비트 또는 48 비트 컬러 출력 버전을 제공했습니다.

  • 다른 언어로 자신의 버전을 구현할 수도 있지만 제공된 C ++ 버전과 동일한 방식으로 작동해야하며 C ++의 내장, 라이브러리 또는 제공된 매크로의 함수 만 사용하여 공정하게 만들 수 있습니다.
  • 세 개의 기능 본문 만 게시하십시오-게시물에 내 코드를 포함시키지 마십시오
  • 더 작은 버전 또는 이미지의 포함 사본을 포함하십시오. 그것들은 ppm 형식으로 만들어지며 stackexchange에서 제대로 볼 수 있도록 다른 형식으로 변환해야 할 수도 있습니다.
  • 함수 본문 (서명 제외)은 140 자 이하 여야합니다.
  • 이것은 인기 콘테스트입니다. 대부분의 투표에서 승리합니다

3
규칙의 특성상 다른 언어가 제외되므로 C ++ 태그가 추가되었습니다. 우리는 일반적으로 특정 세트를 요구할만한 이유가없는 한 언어에 구애받지 않는 과제를 선호합니다.
algorithmshark

4
이것을 너무 광범위하게 부르는 가까운 유권자들에게 먼저 이에 대한 답을 쓰십시오. 놀랍게도 제한적입니다 ...
trichoplax

8
이것은 내가 본 것 중에서 가장 좋아하는 것입니다.
David Conrad

4
이 질문이 구식 데모 장면처럼 느껴지는 것을 좋아합니다.
mskfisher

23
이러한 유형의 질문 은 코드 골프에 참여하도록 권장 합니다. 나는 잘하는 것에 대해 확신이 없기 때문에 일반적으로 골프에 대한 질문에 대답하지 않습니다. 이 유형의 질문으로 바이트 제한을 통해 간단한 답변을 시도하고 그 동안 골프 기술을 배우고 더 복잡한 답변을 얻을 수 있습니다. 이것은 바로 골프 질문에 답하는 디딤돌과 같습니다. 더 많은 사람들을 데려 오는 것이 중요하다고 생각합니다.
trichoplax

답변:


120

만델 브로트 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);
}

8
그 색은 화려합니다!
Martin Ender

나는이 이미지를 가장 좋아하는 이미지를 좋아한다!
Roy van Rijn

4
이것은 지금 내 벽지입니다.
Cipher

209

테이블 보

플랫

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

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

애니메이션 테이블 천


15
이것은 전설적입니다. (Y) 계속 유지하십시오. : P
Mohammad Areeb Siddiqui

그러나 모션은 정확히 어떻게 구현됩니까? 원래 프레임 워크에는 프레임 변경 논리가 없습니다.
esteewhy

2
@esteewhy 스틸 이미지 만 생성 할 수 있습니다. GIF는 일련의 스틸 프레임을 보여줍니다. 각 프레임은 이후의 값을 변경하여 생성됩니다 #define P. 에 추가 캐릭터를 허용하려면 아래로 골프를 쳐야했습니다 #define P 6.03.
trichoplax

4
중지! 당신은 정말로 최고의 답변을 공표하고 싶습니까? 몇 가지가 있습니다 지금까지 당신이 다음이 페이지를 아래로 스크롤하면 더 흥미로운 것들.
trichoplax

1
답변을 "가장 오래된 것"으로 정렬하는 것이 좋으며 새로운 답변이 들어 오면서 새로운 접근법이 어떻게 개발되었는지 확인할 수 있습니다.
trichoplax

192

무작위 화가

여기에 이미지 설명을 입력하십시오

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에 적용하고 싶습니다. (이런 것들은 아직 존재하지 않지만 어쨌든 재미 있습니다!)


12
나는 이것을 좋아한다. 픽셀 데이터에 액세스하지 않고 인접한 픽셀을 고려하는 것이 가능하다는 것을 깨달았습니다. 매끄러운 작업!
trichoplax

1
규칙이 이미지에 모든 색상의 픽셀을 넣는이 오래된 경연 대회를 많이 상기시킵니다.
인터넷은 catz에서

2
와! 이 사진은 절대적으로 아름답습니다!
raptortech97

1
멋진 갤러리, 방사형 갤러리는 깔끔합니다.
인터넷은 catz

2
내가 볼 Reptar 포스트의 마지막 이미지 (등방성 일), 오른쪽 상단 사분면 :.
Tim Pederick

162

소용돌이 치는 뾰족한 것들

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

소용돌이 치는 뾰족한 것들

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는 내 사진에 배트맨이 있다고 지적했습니다.

배트맨


1
@JayKominek 나는 몰랐다. 나는 그 당시에 d가 아니었다.
cjfaure 21:53에


1
트윗 담아 가기 감사합니다! 설명의 최종 버전은 web.archive.org/web/20031205062033/http://www.blorf.com/~mrad/…에 있으며 코드는 sourceforge로 이동 된 것 같습니다. 작년에도 업데이트! sourceforge.net/projects/libswirlies
Jay Kominek

1
내가 좋아하는 것 중 하나!
Calvin 's Hobbies

1
이건 예쁘지 만 전혀 재현 할 수 없습니다! 내가 얻을 수있는 가장 가까운 것은 PPM이 잘못 생성되었을 때 (MSB 대신 LSB) 심지어 색상이 다른 다양한 알파 혼합 원처럼 보입니다.
DreamWarrior

123

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

준다

여기에 이미지 설명을 입력하십시오


12
고백해야 할 @tomsmeding, 이것은 내가 Mandelbrot 세트를 처음으로 구현 한 것입니다.
Martin Ender

2
Mandelbrot 전체 세트가 (+1, 그런데!) 상징적 인 것처럼, 매개 변수를 조정하고 깊이 확대 / 축소의 놀랍도록 꼬인 세부 사항으로 답변을 게시하기에 충분한 공간을 확보 한 것처럼 보입니다.
trichoplax

1
@ githubphagocyte 나는 이미 그것에 대해 생각했지만, 괜찮은 매개 변수를 알아낼 때까지 매번 다시 컴파일하고 다시 실행하고 변환하는 데 신경 쓰지 못했습니다.). 나중에 그렇게 할 수 있습니다. 먼저 완전히 다른 기능을 시도해야합니다. ;)
Martin Ender

2
@githubphagocyte가 마침내 그것을 추가했습니다. 제안 해 주셔서 감사합니다!
Martin Ender

2
@Todd에게 감사드립니다. 최종 사진을 업데이트했습니다. 25600 반복을 너무 오래 사용했습니다. ;)
Martin Ender

110

줄리아 세트

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

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


srand (time (0) and rand ()? 또는 time (0)으로 실행할 때마다 매개 변수를 무작위화할 공간이 있습니까?
Sparr

2
마지막은 내 벽에 있습니다.
cjfaure

@Sparr은 제안으로 업데이트되었습니다. 재미있었습니다 :-).
인터넷은 catz로 구성됩니다.

4
답장 또는 사용자 이름
William Barbosa

107

이것은 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;
}

화려한


다른 플랫폼 / 컴파일러에서이 코드의 결과를 보는 것이 흥미로울 것입니다. RAND_MAX의 값은 ... 매우 다양 완전히 다른 이미지를 줄 수
trichoplax

5
많이 바뀌지 않아야합니다. (double) rand () / RAND_MAX는 항상 [0.0, 1.0] 범위에 있어야합니다.
Manuel Kasten

2
이것은 내가 좋아하는 것 중 하나입니다!
Calvin 's Hobbies

2
그것은 재미있을뿐만 아니라 아름답습니다!
Martin Thoma

104

영상

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

3
정말 아름답습니다, +1
Milo

3
이것은 내가 가장 좋아하는 것입니다. 전문적으로 만든 그래픽 디자인처럼 보입니다. : D
cjfaure

4
마이크로 프로세서 웨이퍼처럼 보입니다. macrophotographer.net/images/ss_rvsi_5.jpg
s0rce

미니멀 한 벽지 처럼 보입니다 .
AL

1
무지개 애플 로고 와 비슷해 보인다 .
LegionMammal978

82

붓다 브로트 (+ 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;
}

여기에 이미지 설명을 입력하십시오

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


8
나는 이것을 모자로 만들 것이다.
cjfaure

6
나는 당신이 이것을 140 바이트의 3 로트로 줄이게 된 것에 정말로 놀랐습니다. 새로운 buddabrot 이미지는 아름답습니다.
trichoplax

4
정말 인상적입니다.
copumpkin

첫 번째는 정말 교묘합니다. 해파리를 생각 나게한다. +1
Igby Largeman

1
이것은 내가 가장 좋아하는 제출물입니다. 잘 했어!
thomallen

76

시 에르 핀 스키 국방부

무작위로 선택한 정점에 반을 점을 그려서 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로 포함했습니다.

맨 위 오른쪽


73

망할 음악

시 에르 핀 스키 음악. : 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)));

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

고르지 않은 악보

예, 흥미 롭습니다.



1
@squeamishossifrage 방금 봤는데 ...?
cjfaure

:-) Chris Cunningham의 비디오 조금 이상하지 않습니까?
squeamish ossifrage

14
두 번째는 페이지를 스크롤 할 때 움직이는 것 같습니다
user13267

5
사이트를 아래로 스크롤하면 마지막 사이트가 실제로 움직이는 것처럼 보입니다. 좋은 착시.
Kyle Kanos

61

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

좋아, 이것은 나에게 어려운 시간을 주었다. 나는 결과가 다른 것들 만큼 예술적 이지 않더라도 꽤 멋지다고 생각합니다 . 그것은 무작위성에 관한 것입니다. 일부 중간 이미지가 더 좋아 보일 수도 있지만 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];
}

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


1
나는 보로 노이 다이어그램을 좋아합니다. 3 개의 트윗에 맞추기 위해 +1!
Martin Ender

1
이것은 내가 개인적으로 좋아하는 것 중 하나입니다. 스캔 라인 변형은 매우 미적으로 즐겁습니다.
Fraxtil

1
코드 설명을 좋아합니다
Andrea

배럴 롤 시전!
Starson Hochschild

4th : scanlines의 두 번째 그림은 아름답습니다.
Khaled.K

57

리아 푸 노프 프랙탈

리아 푸 노프 프랙탈

이를 생성하는 데 사용 된 문자열은 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를 만들었습니다. 여기있어:

파티 타임


11
두 번째로 좋은 환각 모습.
TEH의 internets는 CATZ 구성되어

4
이것들은 미쳤다 ! +1
cjfaure

10
무서운 프랙탈이 무섭다 ༼ ༎ ຶ ෴ ༎ ຶ ༽
Tobia

1
두 번째는 무섭다. 간단한 z = z ^ 2 + c에서 얼마나 많은 양을 얻을 수 있는지 최대화하십시오.
tomsmeding

4
에드워드 뭉크가 프랙탈을 그리는 데 사용했다면, 이것은 스크림 이 어떻게 생겼을까 요 ?
인터넷은

55

유니콘 이니까

유니콘 때문에

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

컬러 채널을 개별적으로보고 싶습니다. 멋지다.
박수

52

물류 언덕

여기에 이미지 설명을 입력하십시오

기능

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 값) 플롯이 더 밝아집니다 (일반적으로 더 어둡게 나타남).


3
어제, 어제 어떻게해야할지 생각하고있었습니다. 알아 내기 위해 +1 나는 실제로 팔레트가 그대로 좋은 것입니다! :)
Martin Ender

2
못생긴 #defines에 대한 책임은 있지만 나는 당신과 githubphagocyte에서 더러운 속임수를 훔쳤습니다. 특히 "#define G for (".
Eric Tressler

1
토너먼트 브래킷 비주얼 라이저처럼 보입니다
Kevin L

3
상단에 표시되지 않음 : 승자가 사망
Eric Tressler

1
이것을 포스터 크기로 인쇄 할 수 있습니까? 백그라운드에서 3 개의 희미한 트윗이 있습니다. :-)
Andrew Cheong

50

확산 제한 집계

나는 항상 확산 제한 집계 와 실제 세계에서 나타나는 다양한 방법 에 매료되어 왔습니다.

나는 코드가 끔찍하게 했어, 그래서 어려운 (또는 아름다운 당신이 만약 같은 것들처럼, 기능 당 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];}

보이는 입자가있는 DLA

이전과 같은 방식으로 애니메이션을 적용 할 수 있습니다.

입자로 애니메이션 집계


3
매우 흥미로운 +1.
인터넷으로 catz

50

나선형 (정확히 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 및 / 또는 연산을 사용하여 여기에서 본 프랙탈과 결합하여 최종 나선형이 있습니다.

프랙탈 나선형


2
환상적입니다! 다른 답변을 둘러 보면 더 많은 공간을 원한다면 더 골프를 칠 아이디어를 찾을 수 있습니다. 일부 답변은 하나의 함수에서 #define을 사용하여 3 개 모두가 사용할 수있는 매크로를 정의하므로 대부분의 계산을 다른 색상 함수로 오프로드 할 수 있습니다. Martin Büttner 가 저에게 그 트릭을 소개했습니다.
trichoplax

감사합니다! 필자의 경우, 코드에는 파운드 정의에서 도움이되는 중복 논리 패턴이 없습니다. 그러나, 당신이 어떤 것을 본다면, 당신이 저를 식별 해 주시면 감사하겠습니다. 특히 C / C ++를 몇 년 동안 광범위하게 사용하지 않은 것을 보았습니다.
xleviator

중복 섹션을 찾는 것이 실제로 더 도움이 될 수 있지만 중복이 없어도 코드를 RD 또는 GN에서 매크로로 정의한 다음 BL에서 사용하여 간단히 BL에서 RD 또는 GN으로 코드를 이동할 수 있습니다. 추가 코드를위한 두 배의 공간이 필요합니다.
trichoplax

아! 내가 참조. 각 함수 본문 자체에 140 자 제한이 있다는 것을 알지 못했습니다. 다음에 프롬프트를 더주의해서 읽어야한다고 생각합니다. 지적 해 주셔서 감사합니다!
xleviator

1
chat 에서 논의했듯이 비 반복 GIF는 쉽게 수정할 수 있어야합니다. 나는 현재 보여지는 간단한 애니메이션 비트처럼 보일 가치가 있다고 생각합니다.
trichoplax

47

고전에 찬사

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;

Bub (버블 보블)


3
나는 이것을 좋아한다. 추가 기능도 추가 할 수있는 충분한 공간이 있습니다 ...
trichoplax

1
그렇습니다. 크기를 줄이기 위해 당기는 많은 트릭이 있습니다. 나는 내일 그것을 확장에 갈 수 있습니다.
FireFly

이것은 지금 매우 짧습니다. 이 비트 패턴 중 하나를 레이 캐스팅 응답의 텍스처에 맞출 수 있습니까?
trichoplax 1

@ MartinBüttner 죄송합니다. 정확합니다. 나는 그것을 고치고 기능을 다시 업데이트했다.
FireFly

깔끔하게, 나는 당신이 8x8 픽셀 아트를 가져 와서 즉시 "크기 조정"하는 방법을 좋아합니다. 그러나 몇 가지 변경을해야했지만 여전히 정확하게 이미지를 얻지 못했습니다. 1L과 255L을 1LL과 255LL로 변경했습니다. 그것이 더 나아 졌기 때문에, 아마도 64 비트 모드에서 컴파일하고 있고 이미지의 나머지 부분을 잘못 만드는 약간의 비트 너비 문제가 있다고 가정합니다. 그러나 여전히 좋은 일입니다!
DreamWarrior

44

액션 페인팅

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}

액션 페인팅 21, 21

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

액션 페인팅 14, 14

액션 페인팅 63, 49

액션 페인팅 56, 42

액션 페인팅 0, 49

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

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


7
나는이 질문과 모든 대답을 지금 몇 주 동안 따라 왔으며, 이것이 내 턱을 실제로 떨어 뜨린 첫 번째 질문입니다. 거룩한 놀라움. 내 말은, 여기에있는 모든 대답은 훌륭합니다. 그러나 이것은 내가 결코 예상 할 수 없었던 것입니다.
Todd Lehman

1
@ToddLehman 감사합니다! 이것은 제가 혼자서 할 수있는 것이 아닙니다. 제가 시도했기 때문에 알고 있습니다.
trichoplax

2
대박! 이 질문에서 가장 좋은 것 중 하나이며 저에게있어 인간이
그린

1
@cyriel 대단히 감사합니다. 당신은이 사람이 5 명의 인간에 의해 그려 졌다고 말할 수 있습니다.
trichoplax

43

내가이 코드 의 매개 변수를 가지고 놀 것 같아 ... 모든 크레딧은 @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);

3
Dr. Seuss처럼 보입니다. 아주 멋지다!
DLosc

3
하하, 사실은 아래 두 파일 Seuss1 및 Sueuss2 이름
카일 맥코믹

42

편집 :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);
}

여기에 이미지 설명을 입력하십시오


1
두 번째 회색 이미지가 놀랍습니다!
tomsmeding

재귀 호출에 대해 유효하지 않은 좌표를 사용하여 r / g / b 함수 자체를 재귀 적으로 사용할 수 있도록 이것을 충분히 압축 할 수 있습니까?
Sparr

나는 멀티 컬러 이미지를 좋아했습니다. 좋은 대답입니다!
Alex

41

원점에서 약간 오프셋 된 점을 중심으로 한 동심원 세트의 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);
}

여기에 이미지 설명을 입력하십시오


39

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

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


사용했던 코드와 동일합니까? ^ i는 i (i)가 항상 0 (XOR)이고 ^ 2가 XOR 비트보다 정사각형처럼 보이기 때문에 이상하게 보입니다.
Manuel Ferreria

1
@ManuelFerreria XOR을 사용하면 코드가 실제로 다음과 같이 컴파일 x^(x-y)^y됩니다 (처음으로 나에게 던졌습니다). iOS 기능이 있다면 내 코드는 다음과 같습니다. gist.github.com/Jugale/28df46f87037d81d2a8f
Max Chuquimia

38

시 에르 핀 스키 페인트 얼룩

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

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


4
잘 했어. 선생님, 잘하셨습니다.
EaterOfCode

37

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

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

모든 검은 색 픽셀 :

모든 검은 픽셀

의사 랜덤 픽셀 :

의사 난수 픽셀

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


3
어느 것을 얻었습니까?
tomsmeding

3
다른 컴파일러를 사용하여 프로그램 실행마다 바뀌는 단색의 단색과 단색이 나타납니다.
Sparr

8
내 컴파일러는 오류를 반환하고 값을 반환하지 않아 소리를 지 릅니다.
Pharap

3
:) 그 나쁜 일이 아니다 @Pharap
Sparr

두 번째 그림에서 알 수 있듯이 멋진 무작위성을 얻지 못할 것입니다. 상수 값, 루프 인덱스 등이 훨씬 더 가능성이 높습니다 (함수가 호출 될 때 EAX에 저장되는 모든 것).

37

멋진, 근사한

groovy.png

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

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.


1
여분의 문자 acos(-1)M_PI있습니다.에 대한 대체품입니다 .
Martin Ender

33

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

mathpic1.png

수정 된 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;
}

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


mathpic2.png

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


그냥 i&j실제로 시어 핀 스키 삼각형을 렌더링합니다. 어느입니다 최고 .
cjfaure

마지막은 프로필 사진입니다.
mbomb007

32

자바 스크립트

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

여기에 이미지 설명을 입력하십시오


사기꾼! 사기꾼! ; D (유효한 답변입니다. 너무 똑똑합니다 : P Nice one!)
tomsmeding

1
Hahah .. 예, 저는 질문의 정신에 더 맞는 것을 제출했습니다. 실제로 패턴을 만들려고했는데 실제로 무언가를 그릴 수 있을지 궁금해했습니다.
wolfhammer

끝에 "| Math.random () * 256"을 적용하여 하위 비트에 필름 그레인 노이즈를 추가하여 얕은 컬러 이미지를 약간 더 풍부하게 만들 수 있습니다. 밝은 영역을 변경하지 않고 어두운 음영을 더 무작위로 교란시킵니다. (암흑 임계 값에 따라 숫자를 증가시킵니다)
Kent Fredric

rgb randomness @ [10,728,728] i.imgur.com/ms4Cuzo.png
Kent Fredric

31

행성 화가

//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()려면 기본 함수에 줄을 추가해야 합니다.

밴드


2
이미지가 약간 더 크면 광선처럼 보입니다. o :
cjfaure

1
@cjfaure 이미지를 전체 크기로 보거나 (다운로드 / 마우스 오른쪽 버튼 클릭 후 이미지 / 시스템에서 작동하는 모든 것보기) 추가 세부 사항으로 훨씬 더 아름답게 보입니다.
trichoplax

검은 색으로 둘러싸인 원으로 만들면 행성이됩니다!
Khaled.K

1
블렌더로 구 주위를 감싸려고했고 애니메이션을 렌더링했습니다. 여기 ti 참조 : gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs

30

반사파

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 = 225 인 파도

w = 360

w = 360 인 파도

w = 5390

w = 5390 인 파도

다음은 파도가 확대됨에 따라 연속되는 이미지를 보여주는 GIF입니다. 500KB 파일 크기 제한이 허용하는 한도까지 많은 프레임을 표시하는 다양한 크기를 제공했습니다.

파도 큰 GIF

작은 파도 GIF 파도 매체 GIF


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

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

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


3
GIF와 설명을 좋아하십시오.
DLosc

니토! 그러나 사람, 이러한 항목을 사용하면 더 빠른 컴퓨터 (또는 더 많은 인내심, lol)가 필요하다고 생각합니다. 컴퓨터가 훨씬 빠르거나 모든 GIF 프레임을 생성하는 데 시간이 오래 걸린다고 생각하고 싶지 않습니다.
DreamWarrior

3
@DreamWarrior 그것은 환자가 아닙니다. 내가 자고있는 동안 밤새도록 신경 쓰지 않는 것은 나의 노트북이다
trichoplax

2
나는 두 번째 이미지에서 팩맨을 봅니다.
AL
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.