Desafio:

Escreva um programa que produza um arquivo gráfico de 1920 pixels de largura por 1080 pixels de altura. Cada um dos 2.073.600 pixels no gráfico deve ser de uma cor única e nenhum valor de cor deve ser repetido. As cores devem ser especificadas em RGB e começar em 0,0,0 e contar para cima em sequência até 255.255.255. Você verá que uma imagem de 1920 x 1080 pixels conterá muitos pretos, azuis e verdes.

Por exemplo, (uma versão reduzida reduzida). Se a altura estiver definida como 5 e a largura definida como 5, será gerado um gráfico quadrado de 25 pixels e cada pixel terá uma cor exclusiva. A matriz de cores RGB ficaria assim:

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
    )

)

Regras:

• Qualquer linguagem de programação pode ser usada para gerar a imagem.

• A resposta com mais votos positivos vence.

• As cores devem ser usadas apenas uma vez.

• O pixel na posição 0,0 deve começar com a cor 0,0,0

• As cores devem estar dentro do intervalo de 24 bits da cor verdadeira.

• A imagem deve ter tamanho de 1920 x 1080 pixels.

• As cores devem estar no formato RGB.

• Usar uma biblioteca para produzir a imagem está ok.

• A saída deve estar no formato de um arquivo gráfico, por exemplo, output.png

• Como o texto que representa os valores das cores não conta, o código deve gerar um arquivo gráfico.

• O tamanho do arquivo da imagem de saída não importa.

• Você deve poder visualizar a saída abrindo-a como um gráfico no navegador Chrome.

Eu ficaria impressionado se você conseguir fazer isso com um código muito curto, seu programa também gera o tempo em segundos decorridos para gerar a imagem incorporada na própria imagem sobreposta nos pixels sequenciais, seu programa gera a imagem em 10 segundos. Eu ficaria realmente impressionado se o seu programa exibir a imagem dentro de 1 segundo.

Python - mais de 660 bytes

Versão Incremental

Tamanho completo: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Esta é uma imagem baseada em um fractal de Julia Set . Cada cor é adicionada à imagem de forma incremental, embora exista uma quantidade substancial de pré-cálculo.

Versão Luminosidade

Tamanho completo: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

Eu adicionei uma opção para iterar cada cor pela luminosidade, e não pelo índice. Isso não se qualifica como "contar" a partir de zero, mas parece ser um requisito negligente. É interessante que esses dois pedidos exponham estruturas completamente diferentes na imagem. Para usar isso, defina o use_luminositysinalizador para True.

Fonte

Requer PIL .

Esteja avisado : isso levará alguns minutos para ser executado. O uso do PyPy com Pillow é executado em cerca de um quinto do tempo do CPython com PIL, então eu recomendaria isso, se possível.

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

Editar : atualizado para que #000000fique no canto superior esquerdo, conforme especificado.
Editar : adicionada uma bandeira para iterar as cores pela luminosidade.
Editar : alternado para cálculos complexos nativos e pesos de luminosidade inteira, que são um pouco mais rápidos.

Soluções em que trabalhei antes do critério principal se tornar um concurso de popularidade

PHP - 161 bytes

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

Isso está buscando a saída mais rápida possível. Nenhuma biblioteca é usada, apenas um cabeçalho pré-calculado e saída direta de bytes. É executado em menos de 2 segundos no meu comp. Aumentando em 256 em vez de 1 , produz um efeito pseudo-gradiente, sem necessidade de computação real. A única queda é que ( 0, 0 ) não é preto, mas o resultado parece muito melhor.

ob_start();e ob_end_flush();não são estritamente necessários, mas armazenar em buffer a saída a torna muito mais rápida.

Outros incrementos interessantes incluem:

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

E muitos outros. Embora a maioria dos padrões parecidos com algo pareça listras de algum tipo

PHP - 105 bytes

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

Versão desprezível imprudente.

• Dado um Content-typecabeçalho quebrado , o Chrome fará o possível para descobrir o que foi enviado. Nesse caso, ele identifica corretamente como image/bmp. As últimas versões do FireFox e IE também podem corrigir o cabeçalho quebrado.
• Os barewords BM, I5S2e CSirá gerar um NOTICEerro. Para impedir a corrupção da imagem, php.iniserá necessário definir o relatório de erros para evitar isso (por exemplo error_reporting = E_ALL & ~E_NOTICE).
• Sem buffer de saída. A imagem é construída 3 bytes por vez, o que é notavelmente mais lento.
• O ponto ( 0, 0 ) é considerado no canto inferior esquerdo, e não no canto superior esquerdo.

PHP-CLI - 83 bytes

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

Execute diretamente da linha de comando e canalize para um arquivo (por exemplo $ php all-colors.php > out.bmp), nenhum Content-typecabeçalho é necessário. O arquivo resultante é idêntico à versão de 105 bytes e pode ser visualizado no Chrome.

C com a biblioteca de gráficos GD (err, cerca de 2,5 KB?)

As regras não proibiram a modificação de uma imagem existente. Eu criei um programa para substituir todos os pixels de uma imagem por valores RGB sequenciais de #000000até #1fa3ffe estou bastante satisfeito com os resultados. Aqui está o que foi produzido a partir de uma foto postada no Flickr por Michael Carian ( cc-by-sa 2.0 ):

(A imagem de saída bruta é bastante grande (5,6 MB) )

Aqui está um close do canto superior esquerdo (aumentado em 400%):

O tempo de processamento é de aproximadamente 3 segundos para uma imagem desse tamanho:

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

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

e sim, todos os pixels são de cores diferentes:

$ identify -format %k outfile.png
2073600

( identifyé um utilitário ImageMagick; a -format %kopção conta o número de cores exclusivas em uma imagem)

Aqui está o código fonte:

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

C ++, 750 bytes

Um PNG de resolução total (5.1MB)

O código cria uma coleção de todos os números inteiros de 0 a 1080 * 1920 e os classifica pelo brilho geral. Em seguida, ele cria um conjunto de Mandelbrot e classifica as posições com base em sua iteração e valor de escape. Depois, percorre os dois conjuntos, atribuindo cores na ordem do escuro ao brilhante, passando pelos valores de Mandelbrot, do menor para o maior. Por fim, ele grava uma imagem BMP de 32 bits por pixel no nome do arquivo de saída especificado como um parâmetro de linha de comando.

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

O código não é totalmente golfe, mas não vai ficar muito menor.

C - 854 bytes (quando compactado)

Originalmente, eu tinha algo com cantos ciano, magenta e amarelo e gradações suaves de cores que pareciam muito boas, mas não atendiam às especificações.

O seguinte cumpre as especificações: usa as "primeiras" 2.073.600 cores, sem repetições e preto no canto superior esquerdo.

Como isso funciona é bem legal. Ele cria uma matriz com as cores e depois classifica vertical e horizontalmente por diferentes critérios algumas vezes. O resultado final são transições agradáveis ​​entre azul e verde e entre escuro e claro. Demora cerca de 1,5 segundos para executar. Compile usando: gcc -o many many.c -lme execute usando:./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;
}

Para sua informação, esta era a imagem original ...

E para os interessados ​​no código usado para gerar esta imagem:

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

Ruby, 109

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

EDIT: Devo observar que enviei isso quando a pergunta ainda estava marcada como code-golf , antes de se tornar um concurso de popularidade, então eu estava procurando por um código curto. Isso não é muito imaginativo, mas acredito que seja um envio válido.

Os valores das cores variam de 00 00 00a 1f a3 ff, incrementando em 1, para que a falta de redresultado não seja surpreendente.

Pelo custo de adicionar 1 caractere ao comprimento do código-fonte (substitua <<8por <<11), pode ser obtida a seguinte saída. Isso cobre uma maior variedade do espectro ao custo da blueresolução. Aumenta através do espaço RGB a oito vezes a taxa. Os valores das cores variam de 00 00 00a fd 1f f8.

Raquete

Nunca usei programação orientada a objetos de raquete antes (passagem de mensagens), portanto, não tenho certeza se isso é ideal, mas parece que o trabalho está sendo feito.

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

Ao não usar os 3 primeiros bits no canal vermelho, recebo as três cores na imagem resultante.

Brainfuck

O código imprime uma imagem de 24 bits BMP em STDOUT para intérpretes de 8 bits de células BF. Ele cria a mesma imagem que a versão Racket. É baseado na versão pnm.

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

O Ubuntu é fornecido com bfcélulas de 8 bits:

bf img.bf > image.bmp

Versão antiga que viola a capacidade de abrir no Chrome. Ele cria um arquivo .pnm compatível com a maioria dos visualizadores de imagem.

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

Atualizado, a primeira versão não tinha todas as cores exclusivas no espaço de 24 bits:

Mathematica: 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}]]

Verificação de regras:

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

O primeiro pixel é preto:

list[[1, 1]]

{0., 0., 0.}

Todas as cores são únicas:

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

True

Mathematica: 146

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

Leva 14,778 segundos.

Verificação de regras:

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

O primeiro pixel é preto:

list[[1, 1]]

{0., 0., 0.}

Todas as cores são únicas:

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

True

Python - 104

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

Esta é a versão, que teria sido para o desafio do código-golfe. Como está apenas aumentando o valor de 0 até 2073599, ele contém apenas cores exclusivas.

Python - 110

Como não gostei da versão acima (o intervalo de cores não é totalmente usado), tentei algo como o seguinte:

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

Python - 122

Outra extensão ao acima:

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

Processing, 301
Esta não é uma tentativa da solução mais concisa, mas mantém todo o controle para alcançar o arranjo desejado de cores. Sim, as cores não são consecutivas, mas isso não é divertido.

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

Visual Basic .NET, 273 bytes

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

Isso gera um arquivo de 5,61 MB:

O código acima é uma versão compactada desse código mais legível. Os espaços foram removidos para salvar bytes.

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

Link para a imagem: http: //µ.pw/k

ImageMagick - Converter 119

Vamos usar o convertda caixa de ferramentas ImageMagick para criar imagens. É executado em 0 segundos. É jogado com 119 caracteres. Sobreponho dois gradientes (vermelho-azul e preto-branco) convertendo-os em HSL e de volta a RGB.

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

Exemplos de sobreposição de gradiente podem ser encontrados nas páginas de manual do ImageMagick .

PHP, 507

Você provavelmente precisará aumentar a quantidade de memória alocada ao PHP para executar. Usa GD. Demora cerca de 9 segundos para gerar a imagem.

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

Link para a imagem de saída: http://i.stack.imgur.com/AAKqW.png

Veja em execução na Web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Versão # 1), 361 bytes

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.

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

Java 411 386 + 24 bytes

Golfe

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

Ungolfed

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

Resultado

Explicação

Esta não é a minha tentativa de encontrar a solução mais curta, mas a mais portátil. Somente deixou a importação para BufferedImage porque os outros não salvaram bytes. Em vez de carregar a imagem em um JPanel e escrevê-lo, economizei o tempo necessário, do início até a gravação no disco como o nome do arquivo. Para mim, isso levou a nomes de arquivos de cerca de 110 ms, enquanto o tempo do começo ao fim geralmente levou cerca de 500 ms. Por fim, ele deve ser independente da plataforma, como eu testei no Windows e em uma VM do Ubuntu e funcionou (ele grava o arquivo na sua área de trabalho). Tinha que ter a declaração de retorno devido ao lixo de sintaxe Callable. Embora eu esteja trabalhando na solução, duvido que encontre uma implementação melhor por conta própria, devido à economia do uso de le para os loops for. Eu diria que meio segundo para java não é tão ruim.

 (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

Mas acredito que ainda seja validado, pois ainda pode ser aberto pelo chrome, apenas é aberto automaticamente no seu visualizador de png padrão (versão não testada em máquinas baseadas em Unix).

Estou ciente dos bytes salvos possíveis, mas principalmente os omiti para se qualificar para bônus. Se solicitado, posso enviar exemplos mais curtos e específicos da plataforma. Obrigado.

Editar

Removido o bloco Try Catch desnecessário e a declaração de retorno mal formatada para reduzir ~ 30 bytes.
Removido BufferedImage.TYPE_INT_RGBporque é literalmente apenas 1.