Reto:

Escriba un programa que genere un archivo gráfico de 1920 píxeles de ancho por 1080 píxeles de alto. Cada uno de los 2,073,600 píxeles dentro del gráfico debe ser un color único y no se deben repetir valores de color. Los colores deben especificarse en RGB y comenzar en 0,0,0 y contar hacia arriba en secuencia hacia 255,255,255. Encontrarás una imagen de 1920 x 1080 píxeles que contendrá muchos negros, azules y verdes solamente.

Por ejemplo, (una versión reducida más pequeña). Si la altura se estableció en 5 y el ancho se estableció en 5, se generaría un gráfico cuadrado de 25 píxeles y cada píxel sería un color único. La matriz de colores RGB se vería así:

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
    )

)

Reglas:

• Se puede usar cualquier lenguaje de programación para generar la imagen.

• La respuesta con más votos a favor gana.

• Los colores solo deben usarse una vez.

• El píxel en la posición 0,0 debe comenzar con el color 0,0,0

• Los colores deben estar dentro del rango de color real de 24 bits.

• La imagen debe tener un tamaño de 1920 x 1080 píxeles.

• Los colores deben estar en formato RGB.

• Usar una biblioteca para generar la imagen está bien.

• La salida debe estar en el formato de un archivo gráfico, por ejemplo, output.png

• La salida como texto que representa los valores de color no cuenta, el código debe generar un archivo gráfico.

• El tamaño del archivo de la imagen de salida no importa.

• Debe poder ver la salida abriéndola como un gráfico en el navegador web de Chrome.

Me impresionaría si logra hacer esto con un código realmente corto, su programa también genera el tiempo en segundos transcurridos para generar la imagen incrustada dentro de la imagen superpuesta en los píxeles secuenciales, su programa genera la imagen en 10 segundos. Me impresionaría mucho si su programa genera la imagen en 1 segundo.

Python - 660+ bytes

Versión incremental

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

Esta es una imagen basada en un conjunto fractal de Julia . Cada color se agrega a la imagen de forma incremental, aunque hay una cantidad sustancial de cálculo previo.

Versión de luminosidad

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

He agregado una opción para iterar cada color por luminosidad, en lugar de por índice. Esto no califica como "contar" desde cero, pero parece ser un requisito laxo. Es interesante que estos dos ordenamientos expongan estructuras completamente diferentes en la imagen. Para usar esto, establezca la use_luminositybandera en True.

Fuente

Requiere PIL .

Tenga cuidado : esto tardará varios minutos en ejecutarse. Usar PyPy con Pillow se ejecuta en aproximadamente una quinta parte del tiempo de CPython con PIL, por lo que lo recomendaría, si es posible.

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 : actualizado para que #000000esté en la esquina superior izquierda, como se especifica.
Editar : se agregó una bandera para iterar los colores por luminosidad.
Editar : cambió a cálculos complejos nativos y pesos de luminosidad enteros, que son un poco más rápidos.

Soluciones en las que trabajé antes de que el criterio principal se convirtiera en concurso de popularidad

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

Esto va para la salida más rápida posible. No se utiliza ninguna biblioteca, solo un encabezado precalculado y salida directa de bytes. Se ejecuta en menos de 2 segundos en mi comp. Al incrementar en 256 en lugar de 1 , produce un efecto de pseudo gradiente, sin necesidad de computación real. La única desventaja es que ( 0, 0 ) no es negro, pero el resultado se ve mucho mejor.

ob_start();y ob_end_flush();no son estrictamente necesarios, pero el almacenamiento en búfer de la salida hace que se ejecute mucho más rápido.

Otros incrementos interesantes incluyen:

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

Y muchos otros. Aunque, la mayoría de los patrones que se parecen a algo se parecen a rayas de algún 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);

Versión temeraria de desprecio.

• Dado un Content-typeencabezado roto , Chrome hará todo lo posible para averiguar qué se envió. En este caso, lo identifica correctamente como image/bmp. Las últimas versiones de FireFox e IE también pueden reparar el encabezado roto.
• Las palabras vacías BM, I5S2y CSgenerarán un NOTICEerror. Para evitar la corrupción de la imagen, php.iniserá necesario configurar el informe de errores para evitar esto (por ejemplo error_reporting = E_ALL & ~E_NOTICE).
• Sin buffering de salida. La imagen se construye 3 bytes a la vez, que es notablemente más lenta.
• Se considera que el punto ( 0, 0 ) es la esquina inferior izquierda, en lugar de la esquina superior izquierda.

PHP-CLI - 83 bytes

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

Ejecutar directamente desde la línea de comandos y canalizar a un archivo (por ejemplo $ php all-colors.php > out.bmp), no Content-typees necesario ningún encabezado. El archivo resultante es idéntico a la versión de 105 bytes y se puede ver en Chrome.

C con la biblioteca de gráficos GD (¿err, aproximadamente 2.5 KB?)

Las reglas no prohibían modificar una imagen existente. Hice un programa para reemplazar todos los píxeles de una imagen con valores RGB secuenciales de #000000a #1fa3ff, y estoy bastante satisfecho con los resultados. Esto es lo que produjo de una foto publicada en Flickr por Michael Carian ( cc-by-sa 2.0 ):

(La imagen de salida sin formato es bastante grande (5.6 MB) )

Aquí hay un primer plano de la esquina superior izquierda (ampliado 400%):

El tiempo de procesamiento es de aproximadamente 3 segundos para una imagen de este tamaño:

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

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

y sí, todos los píxeles son de diferentes colores:

$ identify -format %k outfile.png
2073600

( identifyes una utilidad ImageMagick; la -format %kopción cuenta el número de colores únicos en una imagen)

Aquí está el código fuente:

#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

Una resolución completa PNG (5.1MB)

El código crea una colección de todos los enteros de 0-1080 * 1920, luego los ordena por brillo general. Luego crea un conjunto de Mandelbrot y clasifica las posiciones según su iteración y valor de escape. Luego recorre ambos conjuntos, asignando colores en orden de oscuro a brillante a los valores de Mandelbrot de menor a mayor. Finalmente, escribe una imagen BMP de 32 bits por píxel en el nombre de archivo de salida especificado como parámetro de línea 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);}

El código no está completamente desarrollado, pero no se hará mucho más pequeño.

C - 854 bytes (cuando se exprime)

Originalmente tenía algo con esquinas cian, magenta y amarillo y gradaciones suaves de colores que se veían muy bien, pero no cumplía con las especificaciones.

Lo siguiente cumple con las especificaciones: usa los "primeros" 2,073,600 colores, sin repeticiones, y el negro en la esquina superior izquierda.

Cómo funciona es genial. Construye una matriz con los colores, luego los ordena vertical y horizontalmente por diferentes criterios un par de veces. El resultado final son transiciones agradables entre azul y verde y entre oscuro y claro. Tarda aproximadamente 1,5 segundos en ejecutarse. Compilar usando: gcc -o many many.c -lmy ejecutar 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;
}

FYI, esta fue la imagen original ...

Y para aquellos interesados ​​en el código utilizado para generar esta imagen:

#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

EDITAR: Debo señalar que envié esto cuando la pregunta todavía estaba etiquetada con código de golf , antes de que se convirtiera en un concurso de popularidad, así que estaba buscando un código corto. Esto no es muy imaginativo, pero creo que es una presentación válida.

Los valores de color varían de 00 00 00a 1f a3 ff, incrementándose en 1, por lo que la falta de redresultados no es sorprendente.

Por el costo de agregar 1 carácter a la longitud del código fuente (reemplazar <<8con<<11 ), se puede obtener el siguiente resultado. Esto cubre más rango del espectro a costa de la blueresolución. Se incrementa a través del espacio RGB a ocho veces la velocidad. Los valores de color varían de 00 00 00a fd 1f f8.

Raqueta

Nunca utilicé la programación orientada a objetos de raqueta antes (paso de mensaje), así que no estoy seguro de que esto sea óptimo, pero parece que hace el trabajo.

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

Al no usar los 3 primeros bits en el canal rojo, obtengo los tres colores en mi imagen de resultado.

Brainfuck

El código imprime una imagen BMP de 24 bits en STDOUT para intérpretes BF de celda de 8 bits. Crea la misma imagen que la versión Racket. Está basado en la versión pnm.

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

Ubuntu viene con bfeso tiene celdas de 8 bits:

bf img.bf > image.bmp

Versión antigua que viola la posibilidad de abrir desde Chrome. Crea un archivo .pnm que es compatible con la mayoría de los visores de imágenes.

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

La primera versión actualizada no tenía todos los colores únicos en un espacio 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}]]

Verificación de reglas:

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

El primer píxel es negro:

list[[1, 1]]

{0., 0., 0.}

Todos los colores son únicos:

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

Toma 14.778 segundos.

Verificación de reglas:

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

El primer píxel es negro:

list[[1, 1]]

{0., 0., 0.}

Todos los colores son únicos:

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 es la versión, que habría sido para el desafío del código de golf. Como solo aumenta el valor de 0 a 2073599, contiene solo colores únicos.

Python - 110

Como no me gustó la versión anterior (el rango de color no se usa por completo), probé algo como lo siguiente:

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

Otra extensión de lo anterior:

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

Procesamiento, 301
Este no es un intento de la solución más concisa, pero mantiene todo el control para lograr la disposición de colores deseada. Sí, los colores no son consecutivos, pero eso no es 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

Esto genera un archivo de 5.61 MB:

El código anterior es una versión comprimida de este código más legible. Se eliminaron espacios para guardar 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

Enlace a la imagen: http: //µ.pw/k

ImageMagick - Convertir 119

Usemos la convertcaja de herramientas de ImageMagick para crear imágenes. Se ejecuta en 0 segundos. Se juega golf a 119 caracteres. Superpongo dos gradientes (rojo-azul y negro-blanco) los convierto a HSL y de nuevo a RGB.

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

Se pueden encontrar ejemplos de superposición de degradado en las páginas del manual de ImageMagick .

PHP, 507

Probablemente necesitará aumentar la cantidad de memoria asignada a PHP para poder ejecutarla. Utiliza GD. Toma alrededor de 9 segundos para generar la imagen.

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

Enlace a la imagen de salida: http://i.stack.imgur.com/AAKqW.png

Véalo en la web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Versión # 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

Golfed

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

Sin golf

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

Explicación

Este no es mi intento de la solución más corta, sino la más portátil. Solo dejó la importación para BufferedImage porque el otro no guardó bytes. En lugar de cargar la imagen en un JPanel y escribir en ella, guardé el tiempo que lleva desde el principio hasta escribir en el disco como nombre de archivo. Para mí, esto tomó como resultado nombres de archivo de aproximadamente ~ 110 ms, mientras que el tiempo desde el principio hasta el final generalmente tomó ~ 500 ms. Por último, debería ser independiente de la plataforma, ya que probé tanto en Windows como en una máquina virtual de Ubuntu y funcionó (escribe el archivo en su escritorio). Tenía que tener la declaración de devolución debido a la basura de la sintaxis invocable. Aunque estoy trabajando en la solución, dudo que encuentre una mejor implementación por mi cuenta debido a los ahorros de usar lyw para mis bucles for. Yo diría que medio segundo para Java no es tan malo.

 (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

Pero creo que todavía está validado, ya que todavía puede abrirse con Chrome, simplemente se abre automáticamente en su visor PNG predeterminado (versión no probada en máquinas basadas en Unix).

Soy consciente de los posibles bytes guardados, pero principalmente los he omitido para calificar para bonos. Si se solicita, puedo subir ejemplos más cortos y específicos de la plataforma. Gracias.

Editar

Se eliminó el bloque Try Catch innecesario y la declaración de retorno con formato incorrecto para reducir ~ 30 bytes.
Eliminado BufferedImage.TYPE_INT_RGBporque es literalmente solo 1.