Défi:

Écrivez un programme qui produit un fichier graphique de 1920 pixels de large par 1080 pixels de haut. Chacun des 2 073 600 pixels du graphique doit être d'une couleur unique et aucune valeur de couleur ne doit être répétée. Les couleurs doivent être spécifiées en RVB et commencer à 0,0,0 et compter vers le haut en séquence vers 255 255 255. Vous verrez qu'une image de 1920 x 1080 pixels contiendra beaucoup de noirs, bleus et verts uniquement.

Par exemple, (une version réduite plus petite). Si la hauteur était réglée sur 5 et la largeur était réglée sur 5, un graphique carré de 25 pixels serait affiché et chaque pixel serait d'une couleur unique. Le tableau de couleurs RVB ressemblerait à ceci:

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
    )

)

Règles:

• N'importe quel langage de programmation peut être utilisé pour générer l'image.

• La réponse avec le plus de votes positifs l'emporte.

• Les couleurs ne doivent être utilisées qu'une seule fois.

• Le pixel en position 0,0 doit commencer par la couleur 0,0,0

• Les couleurs doivent se situer dans la plage de couleurs réelles 24 bits.

• L'image doit avoir une taille de 1920 x 1080 pixels.

• Les couleurs doivent être au format RVB.

• L'utilisation d'une bibliothèque pour sortir l'image est correcte.

• La sortie doit être au format d'un fichier graphique, par exemple output.png

• La sortie sous forme de texte représentant les valeurs de couleur ne compte pas, le code doit sortir un fichier graphique.

• La taille du fichier de l'image de sortie n'a pas d'importance.

• Vous devez pouvoir afficher la sortie en l'ouvrant sous forme de graphique dans le navigateur Web Chrome.

Je serais impressionné si vous parvenez à le faire avec un code très court, votre programme génère également le temps en secondes écoulées nécessaire pour générer l'image intégrée à l'image elle-même superposée sur les pixels séquentiels, votre programme génère l'image dans les 10 secondes. Je serais vraiment impressionné si votre programme sort l'image en moins d'une seconde.

Python - 660+ octets

Version incrémentale

Taille réelle : http://www.pictureshack.net/images/57626_all_colors.png (4,52 Mo)

Il s'agit d'une image basée sur une fractale Julia Set . Chaque couleur est ajoutée à l'image de manière incrémentielle, bien qu'il y ait une quantité importante de pré-calcul.

Version de luminosité

Taille réelle: http://www.pictureshack.net/images/95389_all_colors4.png (5,24 Mo)

J'ai ajouté une option pour itérer chaque couleur par luminosité, plutôt que par index. Cela ne peut pas être qualifié de "comptage" à partir de zéro, mais cela semble être une exigence laxiste. Il est intéressant de noter que ces deux ordres exposent des structures complètement différentes dans l'image. Pour l'utiliser, définissez le use_luminositydrapeau sur True.

La source

Nécessite PIL .

Soyez averti : cela prendra plusieurs minutes à exécuter. L'utilisation de PyPy avec Pillow s'exécute dans environ un cinquième du temps de CPython avec PIL, donc je recommanderais cela, si possible.

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

Modifier : mis à jour de façon #000000à se trouver en haut à gauche, comme spécifié.
Modifier : ajout d'un drapeau pour itérer les couleurs en fonction de la luminosité.
Modifier : basculé vers des calculs complexes natifs et des poids de luminosité entiers, qui sont légèrement plus rapides.

Solutions sur lesquelles j'ai travaillé avant que le critère principal ne devienne un concours de popularité

PHP - 161 octets

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

Cela va pour la sortie la plus rapide possible. Aucune bibliothèque n'est utilisée, juste un en-tête pré-calculé et une sortie d'octets directe. Fonctionne en moins de 2 secondes sur mon ordinateur. En incrémentant de 256 au lieu de 1 , il produit un effet de pseudo-gradient, sans aucun calcul réel nécessaire. Le seul inconvénient est que ( 0, 0 ) n'est pas noir, mais le résultat semble beaucoup plus agréable.

ob_start();et ob_end_flush();ne sont pas strictement nécessaires, mais la mise en mémoire tampon de la sortie la rend beaucoup plus rapide.

D'autres incréments intéressants incluent:

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

Et plein d'autres. Bien que la plupart des motifs qui ressemblent à quelque chose ressemblent à des rayures

PHP - 105 octets

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

Version de négligence téméraire.

• Étant donné un en- Content-typetête cassé , Chrome fera de son mieux pour déterminer ce qui a été envoyé. Dans ce cas, il l'identifie correctement comme image/bmp. Les dernières versions de FireFox et IE sont également capables de réparer l'en-tête cassé.
• Les barewords BM, I5S2et CSva générer une NOTICEerreur. Pour éviter la corruption de l'image, un rapport d'erreurs php.inidevra être défini pour éviter cela (par exemple error_reporting = E_ALL & ~E_NOTICE).
• Aucune mise en mémoire tampon de sortie. L'image est construite 3 octets à la fois, ce qui est sensiblement plus lent.
• Le point ( 0, 0 ) est considéré comme étant en bas à gauche plutôt qu'en haut à gauche.

PHP-CLI - 83 octets

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

Exécutez directement à partir de la ligne de commande et dirigez-vous vers un fichier (par exemple $ php all-colors.php > out.bmp), aucun en- Content-typetête n'est nécessaire. Le fichier résultant est identique à la version 105 octets et peut être affiché dans Chrome.

C avec la bibliothèque graphique GD (err, environ 2,5 Ko?)

Les règles n'interdisaient pas de modifier une image existante. J'ai créé un programme pour remplacer tous les pixels d'une image par des valeurs RVB séquentielles de #000000à #1fa3ff, et je suis assez satisfait des résultats. Voici ce qu'il a produit à partir d' une photo publiée sur Flickr par Michael Carian ( cc-by-sa 2.0 ):

(L'image de sortie brute est plutôt grande (5,6 Mo) )

Voici un gros plan du coin supérieur gauche (augmenté de 400%):

Le temps de traitement est d'environ 3 secondes pour une image de cette taille:

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

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

et oui, tous les pixels sont de couleurs différentes:

$ identify -format %k outfile.png
2073600

( identifyest un utilitaire ImageMagick; l' -format %koption compte le nombre de couleurs uniques dans une image)

Voici le code source:

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

Un PNG pleine résolution (5,1 Mo)

Le code crée une collection de tous les entiers de 0 à 1080 * 1920, puis les trie par luminosité globale. Il crée ensuite un ensemble Mandelbrot et trie les positions en fonction de leur itération d'échappement et de leur valeur. Ensuite, il parcourt les deux ensembles, en attribuant des couleurs de sombre à clair aux valeurs de Mandelbrot du plus petit au plus grand. Enfin, il écrit une image BMP 32 bits par pixel dans le nom de fichier de sortie spécifié en tant que paramètre de ligne de commande.

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

Le code n'est pas entièrement joué, mais il ne deviendra pas trop petit.

C - 854 octets (une fois pressé)

À l'origine, j'avais quelque chose avec des coins cyan, magenta et jaune et des dégradés de couleurs lisses qui avaient l'air vraiment bien, mais cela ne correspondait pas aux spécifications.

Ce qui suit remplit les spécifications: utilise les "premières" 2 073 600 couleurs, aucune répétition et le noir dans le coin supérieur gauche.

Comment ça marche est plutôt cool. Il construit un tableau avec les couleurs, puis trie verticalement et horizontalement selon différents critères plusieurs fois. Le résultat final est des transitions agréables entre le bleu et le vert et entre le noir et le clair. L'exécution prend environ 1,5 seconde. Compilez en utilisant: gcc -o many many.c -lmet exécutez en utilisant:./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;
}

Pour info, c'était l'image originale ...

Et pour ceux qui s'intéressent au code utilisé pour générer cette image:

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

Rubis, 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: Je dois noter que j'ai soumis cela lorsque la question était encore taguée code-golf , avant qu'elle ne devienne un concours de popularité, alors j'allais pour le code court. Ce n'est pas très imaginatif, mais je pense que c'est une soumission valable.

Les valeurs de couleur vont de 00 00 00à 1f a3 ff, en augmentant de 1, donc l'absence de redrésultat n'est pas surprenante.

Pour le coût de l'ajout d'un caractère à la longueur du code source (remplacer <<8par <<11), la sortie suivante peut être obtenue. Cela couvre une plus grande plage du spectre au détriment de la bluerésolution. Il incrémente l'espace RVB à huit fois le taux. Les valeurs de couleur vont de 00 00 00à fd 1f f8.

Raquette

Je n'ai jamais utilisé de programmation orientée objet de raquette avant (passage de message), donc je ne suis pas sûr que ce soit optimal, mais cela semble faire le travail.

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

En n'utilisant pas les 3 premiers bits du canal rouge, j'obtiens les trois couleurs dans mon image de résultat.

Brainfuck

Le code imprime une image BMP 24 bits sur STDOUT pour les interprètes BF à cellules 8 bits. Il crée la même image que la version Racket. Il est basé sur la version pnm.

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

Ubuntu est livré avec bfdes cellules 8 bits:

bf img.bf > image.bmp

Ancienne version qui ne peut pas s'ouvrir à partir de Chrome. Il crée un fichier .pnm compatible avec la plupart des visionneuses d'images.

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

Mise à jour, la première version n'avait pas toutes les couleurs uniques dans un espace 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}]]

Vérification des règles:

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

Le premier pixel est noir:

list[[1, 1]]

{0., 0., 0.}

Toutes les couleurs sont uniques:

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

Prend 14,778 secondes.

Vérification des règles:

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

Le premier pixel est noir:

list[[1, 1]]

{0., 0., 0.}

Toutes les couleurs sont uniques:

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

Ceci est la version, qui aurait été pour le défi de code-golf. Comme il augmente simplement la valeur de 0 à 2073599, il ne contient que des couleurs uniques.

Python - 110

Comme je n'ai pas aimé la version ci-dessus (la gamme de couleurs n'est pas entièrement utilisée), j'ai essayé quelque chose comme ceci:

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

Une autre extension de ce qui précède:

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
Ce n'est pas une tentative de la solution la plus laconique, mais elle conserve tout le contrôle pour obtenir l'arrangement de couleurs souhaité. Oui, les couleurs ne sont pas consécutives, mais ce n'est pas amusant.

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 octets

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

Cela génère un fichier de 5,61 Mo:

Le code ci-dessus est une version compressée de ce code plus lisible. Les espaces ont été supprimés pour enregistrer les octets.

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

Lien vers l'image: http: //µ.pw/k

ImageMagick - Convertir 119

Permet d'utiliser le convertdepuis la boîte à outils ImageMagick pour créer des images. Il s'exécute en 0 secondes. Il est joué à 119 personnages. Je superpose deux dégradés (rouge-bleu et noir-blanc) pour les convertir en HSL et revenir en RVB.

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

Des exemples de superposition de dégradé peuvent être trouvés dans les pages de manuel ImageMagick .

PHP, 507

Vous devrez probablement augmenter la quantité de mémoire allouée à PHP pour fonctionner. Utilise GD. Prend environ 9 secondes pour générer l'image.

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

Lien vers l'image de sortie: http://i.stack.imgur.com/AAKqW.png

Voyez-le en cours d'exécution sur le Web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Version # 1), 361 octets

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 octets

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

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

Résultat

Explication

Ce n'est pas ma tentative de la solution la plus courte, mais plutôt la plus portable. L'importation de BufferedImage est restée uniquement car les autres n'ont pas enregistré d'octets. Plutôt que de charger l'image dans un JPanel et d'écrire dessus, j'ai économisé le temps qu'il faut du début jusqu'à l'écriture sur le disque comme nom de fichier. Pour moi, cela prenait des noms de fichiers d'environ ~ 110 ms, alors que le temps du début à la fin prenait généralement ~ 500 ms. Enfin, il devrait être indépendant de la plate-forme comme je l'ai testé à la fois sur Windows et sur une machine virtuelle Ubuntu et cela a fonctionné (il écrit le fichier sur votre bureau). Doit avoir l'instruction return en raison de la syntaxe Callable. Bien que je travaille sur le travail, je doute que je trouve une meilleure implémentation par moi-même en raison des sauvegardes de l'utilisation de l et w pour mes boucles for. Je dirais qu'une demi-seconde pour Java n'est pas trop mal.

 (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

Mais je crois qu'il est toujours validé car il peut toujours être ouvert par Chrome, il s'ouvre automatiquement sur votre visionneuse png par défaut (version non testée sur les machines basées sur Unix).

Je suis conscient des sauvegardes d'octets possibles, mais je les ai principalement omises pour pouvoir prétendre à des bonus. Si demandé, je peux télécharger des exemples plus courts et spécifiques à la plate-forme. Merci.

modifier

Suppression du bloc Try Catch inutile et instruction de retour mal formatée pour réduire ~ 30 octets.
Supprimé BufferedImage.TYPE_INT_RGBcar il s'agit littéralement de 1.