Herausforderung:

Schreiben Sie ein Programm, das eine Grafikdatei ausgibt, die 1920 Pixel breit und 1080 Pixel hoch ist. Jedes der 2.073.600 Pixel in der Grafik muss eine eindeutige Farbe haben und es dürfen keine Farbwerte wiederholt werden. Die Farben sollten in RGB angegeben werden und bei 0,0,0 beginnen und der Reihe nach zu 255,255,255 aufwärts zählen. Ein 1920 x 1080 Pixel großes Bild enthält nur viele Schwarz-, Blau- und Grüntöne.

Zum Beispiel (eine kleinere gekürzte Version). Wenn die Höhe auf 5 und die Breite auf 5 eingestellt wäre, würde eine quadratische Grafik mit 25 Pixeln ausgegeben und jedes Pixel würde eine eindeutige Farbe haben. Das RGB-Farbarray würde folgendermaßen aussehen:

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
    )

)

Regeln:

• Zur Erzeugung des Bildes kann eine beliebige Programmiersprache verwendet werden.

• Die Antwort mit den meisten positiven Stimmen gewinnt.

• Farben dürfen nur einmal verwendet werden.

• Pixel in Position 0,0 müssen mit Farbe 0,0,0 beginnen

• Farben müssen innerhalb des 24-Bit-Bereichs für Echtfarben liegen.

• Das Bild muss 1920 x 1080 Pixel groß sein.

• Farben müssen im RGB-Format sein.

• Die Verwendung einer Bibliothek zur Ausgabe des Bildes ist in Ordnung.

• Die Ausgabe muss im Format einer Grafikdatei erfolgen, z. B. output.png

• Die Ausgabe als Text, der die Farbwerte darstellt, zählt nicht, der Code muss eine Grafikdatei ausgeben.

• Die Dateigröße des Ausgabebildes spielt keine Rolle.

• Sie müssen in der Lage sein, die Ausgabe anzuzeigen, indem Sie sie als Grafik im Chrome-Webbrowser öffnen.

Ich wäre beeindruckt, wenn Sie dies mit wirklich kurzem Code tun würden. Ihr Programm gibt außerdem die Zeit in Sekunden aus, die zum Erzeugen des in das Bild selbst eingebetteten Bildes benötigt wird, das über die aufeinanderfolgenden Pixel gelegt wird. Ihr Programm gibt das Bild innerhalb von 10 Sekunden aus. Ich wäre sehr beeindruckt, wenn Ihr Programm das Bild innerhalb von 1 Sekunde ausgibt.

Python - 660+ Bytes

Inkrementelle Version

Volle Größe: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Dies ist ein Bild, das auf einem Julia Set- Fraktal basiert . Jede Farbe wird dem Bild schrittweise hinzugefügt, obwohl es einen erheblichen Vorberechnungsaufwand gibt.

Luminosity Version

Volle Größe: http://www.pictureshack.net/images/95389_all_colors4.png (5,24 MB)

Ich habe eine Option hinzugefügt, mit der jede Farbe nach Leuchtkraft und nicht nach Index iteriert werden kann. Dies ist nicht als "Aufwärtszählen" von Null zu qualifizieren, aber dies scheint eine nachlässige Voraussetzung zu sein. Es ist interessant, dass diese beiden Ordnungen völlig unterschiedliche Strukturen im Bild aufdecken. Um dies zu verwenden, setzen Sie das use_luminosityFlag auf True.

Quelle

Benötigt PIL .

Seien Sie gewarnt : Die Ausführung dauert einige Minuten. Die Verwendung von PyPy mit Pillow dauert mit PIL etwa ein Fünftel der Zeit von CPython, daher würde ich dies nach Möglichkeit empfehlen.

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

Bearbeiten : aktualisiert, so dass #000000wie angegeben oben links angezeigt wird.
Bearbeiten : Eine Markierung wurde hinzugefügt, um Farben nach Leuchtkraft zu iterieren.
Bearbeiten : Umstellung auf native komplexe Berechnungen und ganzzahlige Helligkeitswerte, die etwas schneller sind.

Lösungen, an denen ich gearbeitet habe, bevor das Hauptkriterium zum Beliebtheitswettbewerb wurde

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

Dies sorgt für eine schnellstmögliche Ausgabe. Es wird keine Bibliothek verwendet, nur ein vorberechneter Header und eine direkte Byte-Ausgabe. Läuft in weniger als 2s auf meiner comp. Durch Inkrementieren um 256 anstelle von 1 wird ein Pseudo-Gradienten-Effekt erzeugt, für den keine echte Berechnung erforderlich ist. Der einzige Nachteil ist, dass ( 0, 0 ) nicht schwarz ist, aber das Ergebnis sieht viel besser aus.

ob_start();und ob_end_flush();sind nicht unbedingt erforderlich, aber das Puffern der Ausgabe beschleunigt die Ausführung erheblich.

Andere interessante Inkremente sind:

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

Und viele andere. Obwohl die meisten Muster, die wie irgendetwas aussehen, Streifen ähneln

PHP - 105 Bytes

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

Rücksichtslose Missachtung der Version.

• Bei einem defekten Content-typeHeader versucht Chrome nach besten Kräften herauszufinden, was gesendet wurde. In diesem Fall wird es korrekt als identifiziert image/bmp. Die neuesten Versionen von FireFox und IE können auch den kaputten Header reparieren.
• Die Barewords BM, I5S2und CSerzeugen einen NOTICEFehler. Um eine Beschädigung des Bildes zu verhindern, muss die Fehlerberichterstattung in php.inieingestellt werden, um dies zu verhindern (z error_reporting = E_ALL & ~E_NOTICE. B. ).
• Keine Ausgabepufferung. Das Bild besteht aus jeweils 3 Bytes, was merklich langsamer ist.
• Der Punkt ( 0, 0 ) wird als unterer linker Punkt und nicht als oberer linker Punkt betrachtet.

PHP-CLI - 83 Bytes

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

Führen Sie das Programm direkt von der Befehlszeile aus und leiten Sie es an eine Datei weiter (z. B. $ php all-colors.php > out.bmp). Es ist kein Content-typeHeader erforderlich. Die resultierende Datei ist identisch mit der 105-Byte-Version und kann in Chrome angezeigt werden.

C mit der GD-Grafikbibliothek (err, ca. 2,5 KB?)

Die Regeln untersagten nicht das Ändern eines vorhandenen Bildes. Ich habe ein Programm erstellt, mit dem alle Pixel eines Bilds durch sequentielle RGB-Werte von #000000bis ersetzt werden. #1fa3ffMit den Ergebnissen bin ich sehr zufrieden. Dies ist das Ergebnis eines Fotos, das Michael Carian auf Flickr gepostet hat ( cc-by-sa 2.0 ):

(Das rohe Ausgabebild ist ziemlich groß (5,6 MB) )

Hier ist eine Nahaufnahme der oberen linken Ecke (vergrößert um 400%):

Die Verarbeitungszeit für ein Bild dieser Größe beträgt ca. 3 Sekunden:

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

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

und ja, alle Pixel haben unterschiedliche Farben:

$ identify -format %k outfile.png
2073600

( identifyist ein ImageMagick-Dienstprogramm; die -format %kOption zählt die Anzahl der eindeutigen Farben in einem Bild.)

Hier ist der Quellcode:

#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

Ein PNG mit voller Auflösung (5,1 MB)

Der Code erstellt eine Sammlung aller Ganzzahlen von 0-1080 * 1920 und sortiert sie dann nach der Gesamthelligkeit. Anschließend wird ein Mandelbrot-Set erstellt und die Positionen werden basierend auf ihrer Escape-Iteration und ihrem Wert sortiert. Dann durchläuft es beide Sätze und ordnet die Farben den kleinsten bis größten Mandelbrot-Werten in der Reihenfolge von dunkel bis hell zu. Schließlich wird ein BMP-Bild mit 32 Bit pro Pixel in den als Befehlszeilenparameter angegebenen Ausgabedateinamen geschrieben.

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

Der Code ist nicht vollständig ausgereift, wird aber nicht zu viel kleiner.

C - 854 Bytes (wenn gedrückt)

Ich hatte ursprünglich etwas mit Cyan, Magenta und Gelb Ecken und sanften Abstufungen von Farben, die sehr schön aussahen, aber es entsprach nicht den Spezifikationen.

Folgendes erfüllt die Spezifikationen: Verwendet die "ersten" 2.073.600 Farben, keine Wiederholungen und Schwarz in der oberen linken Ecke.

Wie es funktioniert, ist irgendwie cool. Es erstellt ein Array mit den Farben und sortiert dann mehrmals vertikal und horizontal nach verschiedenen Kriterien. Das Endergebnis sind angenehme Übergänge zwischen Blau und Grün und zwischen Dunkel und Hell. Die Laufzeit beträgt ca. 1,5 Sekunden. Kompilieren mit: gcc -o many many.c -lmund ausführen mit:./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;
}

Zu Ihrer Information, das war das Originalbild ...

Und für diejenigen, die sich für den Code interessieren, mit dem dieses Bild generiert wurde:

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

Rubin, 109

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

BEARBEITEN: Ich sollte beachten, dass ich dies eingereicht habe, als die Frage noch mit Code-Golf markiert war , bevor sie zu einem Beliebtheitswettbewerb wurde, also habe ich mich für Short Code entschieden. Dies ist nicht sehr einfallsreich, aber ich glaube, dass es eine gültige Vorlage ist.

Die Farbwerte reichen von 00 00 00bis 1f a3 ff, inkrementiert um 1, so dass das Fehlen des redErgebnisses nicht verwunderlich ist.

Für die Kosten für das Hinzufügen von 1 Zeichen zur Quellcodelänge (Ersetzen <<8durch <<11) kann die folgende Ausgabe erfolgen. Dies deckt einen größeren Bereich des Spektrums auf Kosten der blueAuflösung ab. Es wird mit der achtfachen Rate durch den RGB-Raum inkrementiert. Farbwerte reichen von 00 00 00bis fd 1f f8.

Schläger

Ich habe noch nie objektorientiertes Programmieren für Schläger verwendet (Message Passing), daher bin ich mir nicht sicher, ob dies optimal ist, aber es scheint die Aufgabe zu erledigen.

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

Wenn ich die 3 ersten Bits im roten Kanal nicht benutze, erhalte ich alle drei Farben in meinem Ergebnisbild.

Brainfuck

Der Code druckt ein 24-Bit-BMP-Bild für 8-Bit-Zellen-BF-Interpreter an STDOUT aus. Es wird das gleiche Image wie bei der Racket-Version erstellt. Es basiert auf der PNM-Version.

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

Ubuntu wird mit bf8-Bit-Zellen ausgeliefert:

bf img.bf > image.bmp

Alte Version, die gegen das Öffnen in Chrome verstößt. Es erstellt eine PNM-Datei, die mit den meisten Bildbetrachtern kompatibel ist.

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

In der ersten aktualisierten Version waren nicht alle Farben im 24-Bit-Bereich eindeutig:

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

Überprüfung der Regeln:

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

Das erste Pixel ist schwarz:

list[[1, 1]]

{0., 0., 0.}

Alle Farben sind Unikate:

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

Dauert 14,778 Sekunden.

Überprüfung der Regeln:

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

Das erste Pixel ist schwarz:

list[[1, 1]]

{0., 0., 0.}

Alle Farben sind Unikate:

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

Dies ist die Version, die für die Code-Golf-Herausforderung gedacht gewesen wäre. Da der Wert nur von 0 auf 2073599 erhöht wird, enthält er nur eindeutige Farben.

Python - 110

Da mir die obige Version nicht gefallen hat (der Farbraum wird nicht vollständig genutzt), habe ich Folgendes versucht:

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

Eine weitere Erweiterung zu den oben genannten:

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
Dies ist kein Versuch, eine möglichst knappe Lösung zu finden, sondern behält die gesamte Kontrolle, um die gewünschte Anordnung der Farben zu erreichen. Ja, die Farben sind nicht aufeinanderfolgend, aber das macht keinen Spaß.

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 Byte

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

Dies gibt eine 5,61 MB große Datei aus:

Der obige Code ist eine komprimierte Version dieses besser lesbaren Codes. Leerzeichen wurden entfernt, um Bytes zu sparen.

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 zum Bild: http: //µ.pw/k

ImageMagick - Konvertieren Sie 119

Verwenden Sie die convertaus der ImageMagick-Toolbox, um Bilder zu erstellen. Es läuft in 0 Sekunden. Es ist zu 119 Zeichen Golf. Ich überlagere zwei Farbverläufe (Rot-Blau und Schwarz-Weiß), konvertiere sie in HSL und zurück in RGB.

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

Beispiele für die Verlaufsüberlagerung finden Sie in den ImageMagick-Handbuchseiten .

PHP, 507

Sie müssen wahrscheinlich den für PHP zugewiesenen Speicher erhöhen, um ausgeführt werden zu können. Verwendet GD. Es dauert ungefähr 9 Sekunden, um das Bild zu erzeugen.

$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 zum Ausgabebild: http://i.stack.imgur.com/AAKqW.png

Sehen Sie es im Web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Version # 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

Golf gespielt

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

Ergebnis

Erläuterung

Dies ist nicht mein Versuch, die kürzeste, sondern die portabelste Lösung zu finden. Hat nur den Import für BufferedImage verlassen, da die anderen keine Bytes gespeichert haben. Anstatt das Image in ein JPanel zu laden und darauf zu schreiben, habe ich mir die Zeit vom Anfang bis zum Schreiben auf die Festplatte als Dateinamen gespart. Dies führte bei mir zu Dateinamen von ca. 110 ms, während die Zeit vom Anfang bis zum Ende in der Regel ca. 500 ms dauerte. Schließlich sollte es plattformunabhängig sein, da ich es sowohl in Windows als auch in einer Ubuntu-VM getestet habe und es funktionierte (es schreibt die Datei auf Ihren Desktop). Musste die return-Anweisung wegen der Callable-Syntax-Garbage haben. Obwohl ich an der Arbeit arbeite, bezweifle ich, dass ich selbst eine bessere Implementierung finden werde, da ich nicht l und w für meine for-Schleifen verwenden kann. Ich würde sagen, eine halbe Sekunde für Java ist nicht so schlimm.

 (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

Aber ich glaube, es ist immer noch validiert, da es immer noch von Chrome geöffnet werden kann. Es wird nur automatisch in Ihrem Standard-PNG-Viewer geöffnet (Version nicht auf Unix-basierten Computern getestet).

Ich bin mir der möglichen Byte-Speicherungen bewusst, habe sie jedoch hauptsächlich weggelassen, um sich für Boni zu qualifizieren. Auf Wunsch kann ich kürzere, plattformspezifische Beispiele hochladen. Vielen Dank.

Bearbeiten

Unnötig entfernt. Versuchen Sie, den Catch-Block und die falsch formatierte return-Anweisung zu entfernen, um ~ 30 Bytes zu reduzieren.
Entfernt, BufferedImage.TYPE_INT_RGBweil es buchstäblich nur 1 ist.