2,073,600 개의 고유 한 색상으로 1920 x 1080 그래픽 생성


24

도전:

1920 x 1080 픽셀의 그래픽 파일을 출력하는 프로그램을 작성하십시오. 그래픽 내의 2,073,600 픽셀 중 하나는 고유 한 색상이어야하며 색상 값을 반복해서는 안됩니다. 색상은 RGB로 지정하고 0,0,0에서 시작하여 255,255,255를 향하여 위쪽으로 세어야합니다. 1920 x 1080 픽셀 이미지에는 많은 검정, 파랑 및 녹색 만 포함됩니다.

예를 들어 (작은 축소 버전). 높이가 5로 설정되고 너비가 5로 설정되면 25 픽셀 정사각형 그래픽이 출력되고 각 픽셀은 고유 한 색상이됩니다. RGB 색상 배열은 다음과 같습니다.

Array (
[0] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 0
    )

[1] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 1
    )

[2] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 2
    )

[3] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 3
    )

[4] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 4
    )

[5] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 5
    )

[6] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 6
    )

[7] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 7
    )

[8] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 8
    )

[9] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 9
    )

[10] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 10
    )

[11] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 11
    )

[12] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 12
    )

[13] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 13
    )

[14] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 14
    )

[15] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 15
    )

[16] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 16
    )

[17] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 17
    )

[18] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 18
    )

[19] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 19
    )

[20] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 20
    )

[21] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 21
    )

[22] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 22
    )

[23] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 23
    )

[24] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 24
    )

)

규칙 :

  • 모든 프로그래밍 언어를 사용하여 이미지를 생성 할 수 있습니다.

  • 가장 많이 찬성을 가진 답이 이깁니다.

  • 색상은 한 번만 사용해야합니다.

  • 0,0 위치의 픽셀은 0,0,0 색상으로 시작해야합니다

  • 색상은 실제 색상 24 비트 범위 내에 있어야합니다.

  • 이미지 크기는 1920 x 1080 픽셀이어야합니다.

  • 색상은 RGB 형식이어야합니다.

  • 라이브러리를 사용하여 이미지를 출력하는 것은 괜찮습니다.

  • 출력은 그래픽 파일 형식이어야합니다. 예 : output.png

  • 색상 값을 나타내는 텍스트로 출력은 계산되지 않습니다. 코드는 그래픽 파일을 출력해야합니다.

  • 출력 이미지의 파일 크기는 중요하지 않습니다.

  • 크롬 웹 브라우저에서 출력을 그래픽으로 열어 출력을 볼 수 있어야합니다.

정말 짧은 코드 로이 작업을 수행하면 프로그램에 시간이 초 단위로 표시되어 이미지 자체에 포함 된 이미지를 순차적 픽셀에 겹쳐서 생성하고 10 초 이내에 이미지를 출력합니다. 프로그램이 1 초 이내에 이미지를 출력하면 정말 감동받을 것입니다.


3
이것이 코드 골프라면 보너스는 어떻게 고려됩니까? 미래를 (효과적으로) 예측하는 코드 의 경우 10 자 보너스는 매우 작은 것 같습니다 .
Kendall Frey

1
이제 보너스 가치가 없습니다! 우리는 어떻게 그 보너스를 받아야합니까? 그들을 무시하라?
Kendall Frey

3
간결한 언어와 간결한 PNG API (중요!)를 선택한 다음 2,073,600으로 계산합니다. @BenPaton은 매우 중요하지만, 언어와 API의 선택이 영리한 프로그래밍의 표시가 아닌 가장 큰 요소가 될 것으로 예상합니다. 그러나 나는 종종 틀리며 훨씬 덜 영리합니다. :-)
대런 스톤

2
검은 색 픽셀에 대한 요구 사항 x==y==0은 약간 임의적 인 것 같습니다. 어쨌든 이러한 좌표는 이미지의 왼쪽 상단 또는 왼쪽 하단을 참조 할 수 있기 때문에 모호합니다.
으스스한 ossifrage

3
모든 색상이미지 복제 ; 유일한 차이점은 색상 팔레트의 한계가 모두 파란색이 아닌 녹색과 녹색으로 제한되어 문제와 큰 차이는 없지만 출력이 덜 예쁘다는 것입니다.

답변:


40

파이썬-660+ 바이트

증분 버전

전체 크기 : http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Julia Set 프랙탈을 기반으로 한 이미지 입니다. 상당한 양의 사전 계산이 있지만 각 색상이 이미지에 점차적으로 추가됩니다.


광도 버전

전체 크기 : http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

색인이 아닌 광도별로 각 색상을 반복하는 옵션을 추가했습니다. 이것은 0부터 "카운트 업"할 수 없지만, 이것은 느슨한 요구 사항 인 것 같습니다. 이 두 가지 순서가 이미지에서 완전히 다른 구조를 노출한다는 것은 흥미 롭습니다. 이를 사용하려면 use_luminosity플래그를로 설정하십시오 True.


출처

PIL이 필요합니다 .

경고 : 실행하는 데 몇 분이 걸립니다. 필로우 와 함께 PyPy 를 사용 하는 것은 PIL과 함께 CPython 시간의 약 5 분의 1로 실행되므로 가능하면 권장합니다.

from PIL import Image, ImageDraw

use_luminosity = True

dim = (1920,1080)

img = Image.new('RGB', dim)
draw = ImageDraw.Draw(img)

xstart = -.776707
ystart = -.134663

a = []

xd = 1.6 / 8192 / dim[0]
yd = 0.9 / 8192 / dim[1]

for x in range(dim[0]):
  print x
  for y in range(dim[1]):
    z = d = complex(xstart + x*xd, ystart + y*yd)
    c = 0
    while abs(z) < 2 and c < 5000:
      z = z*z + d
      c += 1
    a += [(c, -abs(z), x, y)]

a = a[1:]
a.sort(reverse = True)

t = [(i>>16, 255&i>>8, 255&i) for i in range(1, dim[0]*dim[1])]
if use_luminosity:
  t.sort(key = lambda c: c[0]*3 + c[1]*10 + c[2], reverse = True)

r = 0
for c,d,x,y in a:
  draw.point((x,y), t[r])
  r += 1

img.show()

편집 : #000000지정된대로 왼쪽 상단에 있도록 업데이트했습니다 .
편집 : 광도별로 색상을 반복하는 플래그를 추가했습니다.
편집 : 기본 복합 계산 및 정수 광도 가중치로 전환하여 조금 더 빠릅니다.


주요 기준이 가되기 전에 작업 한 솔루션

PHP-161 바이트

<?header('Content-type: image/bmp');
ob_start();
echo'BM'.pack('I5S2',0,0,26,12,70780800,1,24);
for(;$i=($i-256)%2073601;)echo pack('CS',~$i,~$i>>8);
ob_end_flush();

가장 빠른 출력이 가능합니다. 라이브러리는 사용되지 않으며 사전 계산 된 헤더와 직접 바이트 출력이 사용됩니다. 내 광고에서 2 초 미만으로 실행됩니다. 1 대신 256 만큼 증가함으로써 실제 계산없이 의사 그라데이션 효과를 생성합니다. 유일한 몰락은 ( 0, 0 )이 검은 색이 아니지만 결과가 훨씬 멋지게 보입니다.

ob_start();그리고 ob_end_flush();반드시 필요한 것은 아니지만, 출력을 버퍼링하는 것은 훨씬 빨리 실행할 수 있습니다.

다른 흥미로운 증분은 다음과 같습니다.

17 : http://i.stack.imgur.com/ieyyZ.png
103 : http://i.stack.imgur.com/WD2wa.png
326 : http://i.stack.imgur.com/c4DSF. png
557 : http://i.stack.imgur.com/eTTWE.png
943 : http://i.stack.imgur.com/7rrmR.png
2125 : http://i.stack.imgur.com/Ct1kM .png

그리고 많은 다른 사람들. 하지만 어떤 모양의 대부분의 패턴은 일종의 줄무늬와 비슷합니다.


PHP-105 바이트

<?=BM.pack(I5S2,header('Content-type:'),0,26,12,70780800,1,24);
for(;$i<2073600;)echo pack(CS,$i,$i++>>8);

무모한 무시 버전.

  • Content-type헤더 가 부러지면 Chrome은 전송 된 것을 파악하기 위해 최선을 다할 것입니다. 이 경우 올바르게 식별합니다 image/bmp. FireFox 및 IE의 최신 버전도 손상된 헤더를 수정할 수 있습니다.
  • 베어 워드 BM, I5S2CSNOTICE오류 를 생성합니다 . 이미지의 손상을 방지하려면이를 방지하기 위해 오류보고를 php.ini설정해야합니다 (예 :) error_reporting = E_ALL & ~E_NOTICE.
  • 출력 버퍼링이 없습니다. 이미지는 한 번에 3 바이트로 구성되며 눈에 띄게 느려집니다.
  • 점 ( 0, 0 )은 왼쪽 위가 아니라 왼쪽 아래로 간주됩니다.


PHP-CLI-83 바이트

<?=BM.pack(I5S2,0,0,26,12,70780800,1,24);
for(;$i<2073600;)echo pack(CS,$i,$i++>>8);

명령 행에서 직접 실행하고 파일 (예 :)로 파이프하면 헤더가 필요 $ php all-colors.php > out.bmp하지 Content-type않습니다. 결과 파일은 105 바이트 버전과 동일하며 Chrome에서 볼 수 있습니다.


3
나는 패턴이 정말 좋았습니다.
Ben Paton

첫 번째 이미지를 좋아하지만 픽셀 0,0을 RGB 0,0,0으로 지정하는 규칙을 위반하는 것으로 보입니다.
Iszi

@primo 지금 나에게 좋아 보인다.
Iszi

1
나는 내 바탕 화면 :)로 설정 한 너무 많은 광도 버전을 좋아
벤 패튼

24

GD 그래픽 라이브러리가있는 C (err, 약 2.5KB?)

이 규칙은 기존 이미지 수정을 금지하지 않았습니다. 나는에서 순차적 RGB 값을 사용하여 이미지의 모든 픽셀을 대체하는 프로그램 제작 #000000에를 #1fa3ff, 나는 꽤 결과에 만족하고 있습니다. Michael Carian ( cc-by-sa 2.0 ) 이 Flickr게시 한 사진 에서 제작 한 내용은 다음과 같습니다 .

테스트 결과의 640x360 픽셀 썸네일

(원시 출력 이미지는 다소 큽니다 (5.6MB) )

다음은 왼쪽 상단 모서리를 확대 한 것입니다 (400 % 확대).

좌측 상단 코너 확대

이 크기의 이미지에 대한 처리 시간은 약 3 초입니다.

$ time ./a.out foodface.png outfile.png
File accepted; 1920x1080 pixels
Saving...
Finished

real    0m3.251s
user    0m2.392s
sys 0m0.169s

예, 모든 픽셀은 다른 색상입니다.

$ identify -format %k outfile.png
2073600

( identifyImageMagick 유틸리티입니다.이 -format %k옵션은 이미지의 고유 한 색상 수를 계산합니다)

소스 코드는 다음과 같습니다.

#include <stdio.h>
#include <stdlib.h>
#include <gd.h>

#define FIRST_PIXEL_MUST_BE_BLACK 1

#define luminance(rgb) (((rgb>>16)&0xff)*77+((rgb>>8)&0xff)*150+(rgb&0xff)*29)

typedef struct { int lum; int rgb; } pal;      /* Colour palette */
typedef struct { int lum; int x; int y; } pix; /* Pixel list */

/* Callback function for qsort */
int pcomp(const void *a, const void *b) {
  return ((pal *)(a))->lum-((pal *)(b))->lum;
}

int main(int argv, char *argc[]) {
  FILE        *infile,*outfile;
  gdImagePtr  img;
  int         img_width;
  int         img_height;
  int         npixels;
  int         x,y,i;
  int         rgb,colour_ref,c;
  pal         *palette;
  pix         *pixels;

  if (argv!=3) return printf("Usage: %s <source> <destination>\n",argc[0]);

  if (!(infile=fopen(argc[1],"r"))) {
    return printf("Can't open source file <%s>\n",argc[1]);
  }
  if (!(img=gdImageCreateFromPng(infile))) {
    return printf("Bad PNG file <%s>\n",argc[1]);
  }
  fclose(infile);

  img_width=img->sx;
  img_height=img->sy;
  npixels = img_width * img_height;
  printf("File accepted; %dx%d pixels\n",img_width,img_height);

  /* Allocate storage for palette and pixel data */
  palette = malloc(npixels * sizeof(pal));
  if (!palette) return printf("Out of memory\n");
  pixels = malloc(npixels * sizeof(pix));
  if (!pixels) return printf("Out of memory\n");

  /* Create palette and sort by luminance */
  for (i=0; i<npixels; i++) {
    palette[i].rgb=i;
    palette[i].lum=luminance(i);
  }
  qsort(palette,npixels,sizeof(pal),pcomp);

  /* Sort image pixels by luminance */
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  colour_ref = gdImageColorAllocate(img,0,0,0);
  gdImageSetPixel(img,0,0,colour_ref);
#endif

  for (x=y=i=0;i<npixels;i++) {
    rgb = gdImageGetTrueColorPixel(img,x,y);
    pixels[i].x=x;
    pixels[i].y=y;
    pixels[i].lum=luminance(rgb);
    if (!(x=++x%img_width)) y++;
  }
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  qsort(pixels+1,npixels-1,sizeof(pix),pcomp);
#else
  qsort(pixels,npixels,sizeof(pix),pcomp);
#endif

  /* Now use the palette to redraw all the pixels */
  for (i=0;i<npixels;i++) {
    c = palette[i].rgb;
    colour_ref = gdImageColorAllocate(img,c>>16,(c>>8)&0xff,c&0xff);
    gdImageSetPixel(img,pixels[i].x,pixels[i].y,colour_ref);
  }

  printf("Saving...\n");
  if (!(outfile=fopen(argc[2],"w"))) {
    return printf("Can't open <%s> for writing\n",argc[2]);
  }
  gdImagePng(img,outfile);
  fclose(outfile);
  gdImageDestroy(img);
  printf("Finished\n");
  return 0;
}

우와, 대단해! : D +1 또한, 2.463 KB : P
손잡이

16

C ++, 750 바이트

만델 브로트 세트 최대 해상도 PNG (5.1MB)

이 코드는 0-1080 * 1920의 모든 정수 컬렉션을 만든 다음 전체 밝기로 정렬합니다. 그런 다음 Mandelbrot 세트를 작성하고 이스케이프 반복 및 값을 기준으로 위치를 정렬합니다. 그런 다음 두 세트를 거치면서 어두운 것에서 밝은 순서로 Mandelbrot 값에 가장 작은 값부터 가장 큰 값까지 색상을 할당합니다. 마지막으로, 픽셀 당 32 비트 BMP 이미지를 명령 행 매개 변수로 지정된 출력 파일 이름에 씁니다.

#include <windows.h>
#include <vector>
#include <algorithm>
#define X _complex
#define U int
#define S(j,g)std::sort(j.begin(),j.end(),g);
U w=1920,h=1080;
WORD q[27]={'MB',36918,126,0,0,54,0,40,0,w,0,h,0,1,32,0,0,36864,126};
#define V(a,b)((a>>b)&255)
#define L(z)V(z,16)*.3+V(z,8)*.6+V(z,0)*.1
#define F for(c=0;c<w*h;c++)
U C(U a,U b){return L(a)<L(b);}
U M(X a,X b){return a.x<b.x;}
U main(U c,char**v){
std::vector<U>l;
std::vector<X>D;
F l.push_back(c);
U*i=new U[c];
DWORD p;
F{float r=0,i=0,R;p=0;
for(;p<w&&r*r+i*i<4;p++){R=r*r-i*i;i=2*r*i+(c/w-h/2)/400.;r=R+(c%w-w/2)/400.;}
X d={-p-r*r-i*i,c};
D.push_back(d);}
S(l,C)
S(D,M)
F i[(U)D[c].y]=l[c];
void*f=CreateFileA(v[1],4<<28,0,0,2,0,0);
WriteFile(f,q,54,&p,0);
WriteFile(f,i,w*h*4,&p,0);}

코드가 완전히 골프화되지는 않았지만 너무 작아지지는 않습니다.


11

C-854 바이트 (압착시)

나는 원래 청록색, 자홍색 및 노란색 모서리와 부드러운 색조의 색조가 실제로 멋지게 보였지만 사양을 충족시키지 못했습니다.

다음은 사양을 충족시킵니다. 왼쪽 상단에 "첫 번째"2,073,600 색상, 반복 없음 및 검은 색을 사용합니다.

아!

작동 방식은 멋지다. 색상으로 배열을 작성한 다음 여러 기준에 따라 세로 및 가로로 몇 번 정렬합니다. 최종 결과는 파랑과 녹색 사이와 어두운 곳과 밝은 곳 사이의 유쾌한 전환입니다. 실행하는 데 약 1.5 초가 걸립니다. 다음을 사용하여 컴파일 gcc -o many many.c -lm하고 다음을 사용하여 실행하십시오../many > many.ppm

#include <stdlib.h>
#include <stdio.h>

#define W 1920
#define H 1080

typedef struct {unsigned char r, g, b;} RGB;

int S1(const void *a, const void *b)
{
        const RGB *p = a, *q = b;
        int result = 0;

        if (!result)
                result = (p->b + p->g * 6 + p->r * 3) - (q->b + q->g * 6 + q->r * 3);

        return result;
}

int S2(const void *a, const void *b)
{
        const RGB *p = a, *q = b;
        int result = 0;

        if (!result)
                result = p->b - q->b;
        if (!result)
                result = p->g - q->g;
        if (!result)
                result = q->r - p->r;

        return result;
}

int main()
{
        int i, j, n;
        RGB *rgb = malloc(sizeof(RGB) * W * H);
        RGB c[H];

        for (i = 0; i < W * H; i++)
        {
                rgb[i].b = i & 0xff;
                rgb[i].g = (i >> 8) & 0xff;
                rgb[i].r = (i >> 16) & 0xff;
        }

        qsort(rgb, H * W, sizeof(RGB), S1);

        for (n = 0; n < 2; n++)
        {
                for (i = 0; i < W; i++)
                {
                        for (j = 0; j < H; j++)
                                c[j] = rgb[j * W + i];
                        qsort(c, H, sizeof(RGB), S2);
                        for (j = 0; j < H; j++)
                                rgb[j * W + i] = c[j];
                }

                for (i = 0; i < W * H; i += W)
                        qsort(rgb + i, W, sizeof(RGB), S1);
        }

        printf("P6 %d %d 255\n", W, H);
        fwrite(rgb, sizeof(RGB), W * H, stdout);

        free(rgb);

        return 0;
}

참고로, 이것은 원본 이미지였습니다 ...

아!

그리고이 이미지를 생성하는 데 사용되는 코드에 관심이있는 사람들을 위해 :

#include <stdio.h>
#include <math.h>

int main(int argc, char **argv)
{
        int x, y;
        int w = (argc > 1)? atoi(argv[1]): 1920;
        int h = (argc > 2)? atoi(argv[2]): 1080;
        double l = hypot(w, h);

        fprintf(stdout, "P6 %d %d 255\n", w, h);

        for (y = 0; y < h; y++)
        {
                for (x = 0; x < w; x++)
                {
                        unsigned char v[3];
                        v[0] = floor(256 * hypot(0 - x, h - y) / l);
                        v[1] = floor(256 * hypot(w - x, h - y) / l);
                        v[2] = floor(256 * hypot(w - x, 0 - y) / l);
                        fwrite(v, sizeof(unsigned char), 3, stdout);
                }
        }

        return 0;
}

이 색의 눈금은 정말 좋습니다. 이 계산적으로 생성 된 이미지의 출력이 실제로 미적으로 기쁘게 생각합니다. 나는 이것을 바탕 화면 배경 무늬로 쉽게 사용할 수 있습니다. 잘 했어!
Ben Paton

: 겉 모양이 좋은하지만 일부 (1) 고유하지 않은 화소 값은 (쉽게 체크 문제 갖는 ./a.out | hexdump | head방송 7d ff de, (2)에서 순차 RGB 값을 사용하지 않는 많은 회 반복) 000000을 통해 1dffff, (X = 0, (3) 화소 y = 0)이 검은 색이 아닙니다. (나는 (3) 나 자신의 요점을 볼 수는 없지만)
ossifrage squeamish ossifrage

@squeamishossifrage 그래, 사양이 지나치게 제한적이라고 생각하면서 동시에 기본 당 8 비트 이상의 픽셀 또는 픽셀 당 4 채널을 가진 파일 형식을 허용하지 않았다고 생각했다. 그것은 인기 경연 대회이기 때문에, 나는 그것을 떠날거야, 아마 투표 또는 두 개를받을 수 있습니다 ...

@squeamishossifrage 0에서 x1dffff까지 반복해야한다고 말하는 것은 아니며 검은 색으로 시작하고 흰색으로 향하지만 정확히는 아닙니다.
Sylwester

@Sylwester 그것은 당신이 순서대로 계산해야 한다고 말하고 다음 문장은 1920 x 1080 픽셀 이미지가 많은 검은 색, 파란색 및 녹색 만을 포함한다는 것을 알게 될 것이라고 말합니다 . 어떤 비트를 오해 했습니까? (0x1dffff 오류가 아닌 것; 0x1fa3ff 여야 함)
ossiquee ossifrage

8

루비, 109

require'chunky_png';i=ChunkyPNG::Image.new 1920,1080
i.area.times{|v|i[*(v.divmod(1080))]=v<<8|255};i.save ?i

편집 : 질문에 태그가있을 때이 질문을 제출 했는데 가되기 전에 짧은 코드를 사용 하기 전에 제출 했습니다 . 이것은 상상력이 좋지 않지만 유효한 제출이라고 생각합니다.

색상 값은 범위 00 00 001f a3 ff의해 증가, 1의 부족 때문에, red결과에서이 놀라운 일이 아니다.

출력 1

소스 코드 길이 (교체 1 개 문자를 추가하는 비용 <<8으로 <<11), 다음과 같은 출력을 가지게 될 수있다. 이것은 blue분해 비용으로 더 많은 범위의 스펙트럼을 포괄 합니다. RGB 공간을 통해 8 배의 속도로 증가합니다. 색상 값의 범위는 00 00 00~ fd 1f f8입니다.

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


2
당신의 입장은 정말 좋습니다. 첫 번째 이미지는 내가 기대했던 것과 똑같습니다. 잘 지내고 주셔서 감사합니다. 코드를 거의 사용하지 않고 그렇게 빨리 감명 받았습니다.
Ben Paton

7

라켓

(메시지 전달) 전에 라켓 객체 지향 프로그래밍을 사용한 적이 없으므로 이것이 최적인지 확실하지 않지만 작업을 완료하는 것 같습니다.

#lang racket
(require racket/draw)
(let* ((x 1920) (y 1080) (b 256) (bb (* b b)) (pic (make-object bitmap% x y)))
  (let loop ((c 0) (v 0))
    (when (> (* x y) c)
      (send pic set-argb-pixels (modulo c x)   ; x
                                (quotient c x) ; y
                                1              ; width
                                1              ; height
                                (list->bytes 
                                 (list 0                            ; alpha
                                       (modulo v b)                 ; red
                                       (quotient v bb)              ; green 
                                       (modulo (quotient v b) b)))) ; blue
      (loop (+ c 1) (+ v 8))))
  (send pic save-file "image.png" 'png))

다양한 색상의 이미지

빨간색 채널에서 첫 번째 3 비트를 사용하지 않으면 결과 이미지에 세 가지 색상이 모두 표시됩니다.

Brainfuck

이 코드는 8 비트 셀 BF 인터프리터를 위해 24 비트 BMP 이미지를 STDOUT에 인쇄합니다. 라켓 버전과 동일한 이미지를 만듭니다. pnm 버전을 기반으로합니다.

>-------->>+>----->-------->+++++++>>---->------>++>--->>++++[-<+++
+>]<[-<+++++<++++<++<+<++++++++<<+++++++++++++<<<<++>>>>>>>>>>>]<<[
.[-]>]++[-<++++>]<[->.<]<<.[-]...<.[-]...<[.[-]<].<.[-].<+[>>>>+<.<
<.>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]

우분투 bf에는 8 비트 셀이 있습니다.

bf img.bf > image.bmp

Chrome에서 열 수없는 이전 버전입니다. 대부분의 이미지 뷰어와 호환되는 .pnm 파일을 만듭니다.

>------>+++++>+++++>++>------>>-------->>+>------>>++>------->+>--
---->++++++>>>++++[-<++++>]<[-<+++++<+++<+<+++<++++<+++<+++<+<+++<
+++<++++<+++<+<+++<+++<+++<+>>>>>>>>>>>>>>>>>]<[.[-]<]+[>>>>+<.<<.
>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]

6

업데이트 된 첫 번째 버전은 24 비트 공간에서 고유 한 색상을 모두 갖지 못했습니다.

매스 매 티카 : 110

x = 1920; y = 1080; Image[
 ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]]

독특한 색상

규칙 확인 :

list = ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]

첫 번째 픽셀은 검은 색입니다.

list[[1, 1]]
{0., 0., 0.}

모든 색상이 독특합니다.

id = ImageData[Image[list], "Bit16"]]
Length[DeleteDuplicates[Flatten[id, 1]]] == 1920*1080
True

매스 매 티카 : 146

x = 1920; Image[
 Partition[
  ParallelTable[
   List @@ ColorConvert[Hue[c, 1, c^.01], "RGB"], {c, 0, 1, 1/(
    x*1080)}], x]]

그림 물감

14.778 초가 걸립니다.

규칙 확인 :

list = Partition[
  ParallelTable[
   List @@ ColorConvert[Hue[c, 1, c^.01], "RGB"], {c, 0, 1, 1/(
    x*1080)}], x];

첫 번째 픽셀은 검은 색입니다.

list[[1, 1]]
{0., 0., 0.}

모든 색상이 독특합니다.

Length[DeleteDuplicates[Flatten[list, 1]]] == 1920*1080
True


이미지에는 394,460 개의 고유 한 색상 만 있습니다. 병합하기 전에 RGB 값을 8 비트 정수로 변환하면 그 이유를 알 수 있습니다.
squeamish ossifrage

@squeamishossifrage가 업데이트되었습니다.
shrx

6

파이썬-104

from PIL import Image
a=list(range(2073600))
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

이것은 코드 골프 도전에 대한 버전입니다. 값을 0에서 2073599까지 늘리면 고유 한 색상 만 포함됩니다.

짧은 버전

파이썬-110

위의 버전이 마음에 들지 않아 (색상 범위가 완전히 사용되지 않음) 다음과 같은 것을 시도했습니다.

from PIL import Image
a=list(range(0,2073600*8,8))
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

확장 버전이지만 더보기

파이썬-122

위의 또 다른 확장 :

from PIL import Image
a=[(i<<3,i)[i%2]for i in range(2073600)]
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

더 좋은


i.show()기본 뷰어에서 이미지를 여는 데 사용할 수 있습니다. 파일로 저장해야하는 엄격한 요구 사항은 없습니다.
primo

잘. 그것은 여전히 ​​코드 골프 도전이었습니다. 그러나 힌트를 주셔서 감사합니다 :)
Dave J

또한 .show()나를 위해 작동하지 않습니다. 왜 그런지. : P
Dave J

5

처리, 301
이것은 가장 간결한 솔루션의 시도는 아니지만 원하는 색상 배열을 달성하기 위해 모든 제어 기능을 유지합니다. 예, 색상이 연속적이지는 않지만 재미는 없습니다. uniqe.png

int w = 1920;
int h = 1080;
void setup(){
  size(w, h);
  int x = 0; int y = 0;
  for(int i=0; i<w*h; i++){
    stroke(
      (i >> 0) & 0xFF,
      (i >> 6) & 0xFF,  
      (i >> 3) & 0xFF
    );
    if (y % h == 0){
      y = 0;
      x++;
    }
    point(x, y);
    y++;
  }
  save("unique.png");
}

도전 과제는 픽셀 0,0이 RGB 여야 0,0,0합니다. 알겠습니다 31,31,31. 실제로 전체 열 0은 해당 색상으로 나타납니다.
Iszi

3

Visual Basic .NET, 273 바이트

Imports System.Drawing : Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080) : For i As Integer = 0 To 2073599 : Dim x = 0 : b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000)) : Next : b.Save("output.png")
    End Sub
End Module

5.61MB 파일이 출력됩니다.

putput.png

위 코드는 더 읽기 쉬운 코드의 압축 버전입니다. 바이트를 절약하기 위해 공백이 제거되었습니다.

Imports System.Drawing
Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080)
        For i As Integer = 0 To 2073599
            Dim x = 0
            b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000))
        Next
        b.Save("output.png")
    End Sub
End Module

이미지 링크 : http : //µ.pw/k


2

ImageMagick-변환 119

를 사용할 수 있습니다 convert이미지를 만들 ImageMagick이 도구 상자에서. 0 초 안에 실행됩니다. 119 자로 골프입니다. 두 개의 그라디언트 (빨강 파랑 및 검정 흰색)를 오버레이하여 HSL로 변환하고 다시 RGB로 변환합니다.

G=gradient;convert -size 900x900 $G:red-blue \( $G: -rotate 90 \) -compose CopyRed -resize 1920x1080\! -composite o.png

출력 2

그라디언트 오버레이의 예는 ImageMagick 매뉴얼 페이지 에서 찾을 수 있습니다 .


1
멋지지만 색상은 독특하지 않습니다. 이것을 시도하십시오 : identify -format %k o.png. 나는 2073600이 아니라 1762920을 얻었다
squeamish ossifrage

thnx. 다른 점은 이미지가 왼쪽 상단에서 RGB (0,0,0)로 시작하지 않는다는 것입니다. 수정 작업 중 ...
CousinCocaine

식별 명령을 주셔서 감사합니다 @squeamishossifrage. 지금 고쳤습니다.
CousinCocaine

1

PHP, 507

출력 이미지

실행하려면 PHP에 할당 된 메모리 양을 늘려야 할 것입니다. GD를 사용합니다. 이미지를 생성하는 데 약 9 초가 걸립니다.

$a=microtime(true);$c=1920;$d=1080;$e=$c*$d;$f=@imagecreatetruecolor($c,$d);$h=255;$j=2200000;$k=array();$l=1;for($m=0;$m<=$h;$m++){for($n=0;$n<=$h;$n++){for($o=0;$o<=$h;$o++){if($l<=$j){$k[]=array($m,$n,$o);$l++;}else{break;}}}}while($p<=$e){for($q=0;$q<=$c;$q++){for($s=0;$s<=$d;$s++){$t=imagecolorallocate($f,$k[$p][0],$k[$p][1],$k[$p][2]);imagesetpixel($f,$q,$s,$t);$p++;}}}$u=number_format((microtime(true)-$a),4).' seconds';imagestring($f,6,10,10,$u,$v);header('Content-Type: image/png');imagepng($f);

출력 이미지 링크 : http://i.stack.imgur.com/AAKqW.png

웹에서 실행되는 것을 참조하십시오 : http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080


생성 시간 동안의 텍스트가 모두 검은 색이기 때문에 2,073,600 개의 고유 한 색상 요구 사항을 확인하지 않습니까? 아니면 기술적으로 오버레이이기 때문에 계산에 포함되지 않습니까?
Iszi

예, 나는 그것에 대해 생각하지 않았다고 생각합니다. 이 작업을 처음 생각했을 때 같은 색상의 두 픽셀이없는 데스크탑 크기의 벽지를 갖는 것이 재미있을 것이라고 생각했습니다. 그런 다음이 코드를 사용하기 시작하면서 이미지 생성 속도에 관심이있었습니다. 정말 완벽한 솔루션이 텍스트에 다른 색상 픽셀을 사용한다고 가정하지만 읽기가 쉽지 않다고 생각하기 쉽지 않습니다.
Ben Paton

나는 방금 "위배하다"를 의미 할 때 "유효하다"고 말했다. 아 당신은 그것을 얻었다.
Iszi

1

DELPHI / PASCAL (버전 # 1), 361 바이트

program P;
{$APPTYPE CONSOLE}
uses
  System.SysUtils, Vcl.Imaging.pngimage,System.UITypes;
var a : TPNGObject; h,w: Integer; c : TColor;
begin
   a :=TPNGObject.CreateBlank(COLOR_RGB, 16, 1920, 1080);
   for h := 0 to 1020 do
     for w := 0 to 1920 do
         begin
         a.Pixels[h,w]:= c ;
         inc(c);
         end;
   a.SaveToFile('e:\t.png');
end.

1
다른 델파이 솔루션을 제출해 주셔서 감사합니다. 출력에서 예제 이미지를 업로드 할 수 있습니까?
Ben Paton

0

Tcl / Tk, 149

150

set p [image c photo -w 1920 -h 1080]
set y 0
time {set x 0
time {$p p [format #%06x [expr $y*1920+$x]] -t $x $y
incr x} 1920
incr y} 1080
$p w c.png

그림 물감


0

자바 411 386 + 24 바이트

골프

import java.awt.image.*;()->new BufferedImage(1920,1080,1){{long t=System.currentTimeMillis();int q=-1;for(int i=0;i<getWidth();i++)for(int j=0;j<getHeight();j++)setRGB(i,j,q++);java.io.File f=new java.io.File(System.getProperty("user.home"),"Desktop"+System.getProperty("file.separator")+(System.currentTimeMillis()-t)+".png");javax.imageio.ImageIO.write(this,"png",f);java.awt.Desktop.getDesktop().open(f);}}

언 골프

import java.awt.image.*;
() -> new BufferedImage(1920, 1080, 1) {
        {
            long t = System.currentTimeMillis();
            int q = -1;
            for (int i = 0; i < getWidth(); i++)
                for (int j = 0; j < getHeight(); j++)
                    setRGB(i, j, q++);
            java.io.File f = new java.io.File(System.getProperty("user.home"),
                    "Desktop" + System.getProperty("file.separator")
                            + (System.currentTimeMillis() - t) + ".png");
            javax.imageio.ImageIO.write(this, "png", f);
            java.awt.Desktop.getDesktop().open(f);
        }
    }

결과

102.png

설명

이것은 가장 짧은 해결책이 아니라 가장 휴대하기 쉬운 시도입니다. 다른 것은 바이트를 저장하지 않았기 때문에 BufferedImage에 대한 가져 오기만 남았습니다. 이미지를 JPanel에로드하고 쓰는 대신 파일 이름으로 디스크를 쓸 때까지 걸리는 시간을 절약했습니다. 나에게 이것은 약 110ms의 파일 이름을 얻었지만 처음부터 끝까지의 시간은 보통 ~ 500ms가 걸렸습니다. 마지막으로 Windows와 Ubuntu VM에서 테스트 한 결과 플랫폼과 독립적이어야하며 작동합니다 (파일을 데스크탑에 씁니다). Callable 구문 가비지로 인해 return 문이 있어야합니다. 나는 해결 방법을 연구하고 있지만 for 루프에 l과 w를 사용하여 절약함으로써 자체적으로 더 나은 구현을 찾을 수 있을지는 의문입니다. Java의 경우 0.5 초가 그렇게 나쁘지 않다고 말하고 싶습니다.

 (System.getProperty("os.name").toLowerCase().contains("win")) { try { Process
 * p = Runtime.getRuntime() .exec(new String[] { "cmd", "/c", "start chrome " +
 * f }); p.waitFor(); } catch (Exception e) { } } else if
 * (System.getProperty("os.name").toLowerCase().contains("ix")) { try { Process
 * p = Runtime.getRuntime().exec(new String[] { "google-chrome" + f }); } catch

그러나 크롬으로 여전히 열 수 있기 때문에 여전히 검증 된 것으로 생각되며 기본 png 뷰어 (유닉스 기반 컴퓨터에서는 테스트되지 않은 버전)로 자동 열립니다.

바이트 저장이 가능하다는 것을 알고 있지만 주로 보너스를 받기 위해 생략했습니다. 요청이 있으면 더 짧은 플랫폼 별 예제를 업로드 할 수 있습니다. 고맙습니다.

편집하다

불필요하게 Catch 블록을 시도하고 잘못된 형식의 return 문을 사용하여 ~ 30 바이트를 줄입니다. 말 그대로 1이기 때문에
제거 BufferedImage.TYPE_INT_RGB되었습니다.


이것에 대해 되돌아 보면 나는 주요 메소드가 호출 가능한 람다가 작동하도록 예외를 던져야하므로 try catch 블록이 필요하지 않다고 생각합니다.
jfh
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.