Wyzwanie:

Napisz program, który wyświetla plik graficzny o szerokości 1920 pikseli i wysokości 1080 pikseli. Każdy z 2 073 600 pikseli w grafice musi mieć unikalny kolor i nie należy powtarzać żadnych wartości kolorów. Kolory powinny być określone w RGB i zaczynają się od 0,0,0 i liczone w górę w kierunku do 255,255,255. Przekonasz się, że obraz w rozdzielczości 1920 x 1080 pikseli będzie zawierał dużo czerni, błękitu i zieleni.

Na przykład (mniejsza wersja). Jeśli wysokość zostanie ustawiona na 5, a szerokość na 5, wydrukowana zostanie grafika o wielkości 25 pikseli i każdy piksel będzie miał unikalny kolor. Tablica kolorów RGB wyglądałaby tak:

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
    )

)

Zasady:

• Do wygenerowania obrazu można użyć dowolnego języka programowania.

• Odpowiedź z największą liczbą głosów pozytywnych wygrywa.

• Kolory można użyć tylko raz.

• Piksel w pozycji 0,0 musi zaczynać się kolorem 0,0,0

• Kolory muszą mieścić się w prawdziwym zakresie 24 bitów.

• Obraz musi mieć rozmiar 1920 x 1080 pikseli.

• Kolory muszą być w formacie RGB.

• Używanie biblioteki do generowania obrazu jest w porządku.

• Dane wyjściowe muszą być w formacie pliku graficznego, np. Output.png

• Wyprowadzany jako tekst reprezentujący wartości kolorów się nie liczy, kod musi generować plik graficzny.

• Rozmiar pliku obrazu wyjściowego nie ma znaczenia.

• Musisz być w stanie wyświetlić wynik, otwierając go jako grafikę w przeglądarce Chrome.

Byłbym pod wrażeniem, jeśli uda ci się to zrobić za pomocą naprawdę krótkiego kodu, twój program wyświetla również czas w upływających sekundach potrzebny do wygenerowania obrazu osadzonego w samym obrazie nałożonym na kolejne piksele, twój program wysyła obraz w ciągu 10 sekund. Byłbym pod wrażeniem, jeśli Twój program wyświetli obraz w ciągu 1 sekundy.

Python - 660+ bajtów

Wersja przyrostowa

Pełny rozmiar: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

To jest obraz oparty na fraktali Julii . Każdy kolor jest dodawany do obrazu przyrostowo, chociaż istnieje znaczna ilość wstępnych obliczeń.

Wersja świetlistości

Pełny rozmiar: http://www.pictureshack.net/images/95389_all_colors4.png (5,24 MB)

Dodałem opcję iteracji każdego koloru według jasności, a nie według indeksu. Nie kwalifikuje się to jako „odliczanie” od zera, ale wydaje się, że jest to luźny wymóg. Interesujące jest to, że te dwa porządki ujawniają zupełnie inne struktury na obrazie. Aby tego użyć, ustaw use_luminosityflagę na True.

Źródło

Wymaga PIL .

Uwaga : wykonanie potrwa kilka minut. Używanie PyPy z Pillow działa w około jednej piątej czasu CPython z PIL, więc polecam, jeśli to możliwe.

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

Edycja : zaktualizowano, tak aby #000000znajdował się w lewym górnym rogu, jak określono.
Edycja : dodano flagę do iteracji kolorów według jasności.
Edycja : przełączono na natywne złożone obliczenia i całkowite wagi jasności, które są nieco szybsze.

Rozwiązania, nad którymi pracowałem, zanim podstawowym kryterium stało się konkurs popularności

PHP - 161 bajtów

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

Daje to najszybszą możliwą wydajność. Żadna biblioteka nie jest używana, tylko wstępnie obliczony nagłówek i bezpośredni bajt. Działa na moim komputerze w czasie krótszym niż 2 sekundy. Zwiększając o 256 zamiast 1 , daje efekt pseudo-gradientu, bez potrzeby wykonywania prawdziwych obliczeń. Jedynym minusem jest to, że ( 0, 0 ) nie jest czarne, ale wynik wygląda o wiele ładniej.

ob_start();i ob_end_flush();nie są absolutnie konieczne, ale buforowanie wyjścia powoduje, że działa on znacznie szybciej.

Inne interesujące przyrosty obejmują:

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

I wiele innych. Chociaż większość wzorów, które wyglądają jak coś, przypomina pewnego rodzaju paski

PHP - 105 bajtów

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

Lekkomyślnie lekceważy wersję.

• W przypadku zepsutego Content-typenagłówka Chrome dołoży wszelkich starań, aby dowiedzieć się, co zostało wysłane. W takim przypadku poprawnie identyfikuje to jako image/bmp. Najnowsze wersje FireFox i IE są również w stanie naprawić uszkodzony nagłówek.
• Na gołe słowa BM, I5S2i CSwygeneruje NOTICEbłąd. Aby zapobiec uszkodzeniu obrazu, php.ininależy ustawić raportowanie błędów, aby temu zapobiec (np error_reporting = E_ALL & ~E_NOTICE.).
• Brak buforowania wyjściowego. Obraz składa się z 3 bajtów naraz, co jest zauważalnie wolniejsze.
• Punkt ( 0, 0 ) jest uważany za lewy dolny, a nie lewy górny.

PHP-CLI - 83 bajty

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

Uruchom bezpośrednio z wiersza poleceń i potokuj do pliku (np. $ php all-colors.php > out.bmp), Nie Content-typejest wymagany nagłówek. Plik wynikowy jest identyczny z wersją 105-bajtową i można go przeglądać w Chrome.

C z biblioteką graficzną GD (err, około 2,5 KB?)

Reguły nie zabraniały modyfikowania istniejącego obrazu. Zrobiłem program, aby zastąpić wszystkie piksele obrazu sekwencyjnymi wartościami RGB od #000000do #1fa3ffi jestem bardzo zadowolony z wyników. Oto, co wyprodukował ze zdjęcia opublikowanego na Flickr przez Michaela Cariana ( cc-by-sa 2.0 ):

(Surowy obraz wyjściowy jest raczej duży (5,6 MB) )

Oto zbliżenie lewego górnego rogu (powiększone o 400%):

Czas przetwarzania wynosi około 3 sekund dla obrazu o tym rozmiarze:

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

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

i tak, wszystkie piksele mają różne kolory:

$ identify -format %k outfile.png
2073600

( identifyjest narzędziem ImageMagick; -format %kopcja liczy liczbę unikalnych kolorów na obrazie)

Oto kod źródłowy:

#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 bajtów

PNG o pełnej rozdzielczości (5,1 MB)

Kod tworzy zbiór wszystkich liczb całkowitych od 0-1080 * 1920, a następnie sortuje je według ogólnej jasności. Następnie tworzy zestaw Mandelbrota i sortuje pozycje na podstawie iteracji ucieczki i wartości. Następnie przechodzi przez oba zestawy, przypisując kolory w kolejności od ciemnej do jasnej do wartości Mandelbrota od najmniejszej do największej. Na koniec zapisuje obraz BMP o rozdzielczości 32 bitów na piksel do wyjściowej nazwy pliku określonej jako parametr wiersza polecenia.

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

Kod nie jest w pełni golfowy, ale nie będzie zbyt duży.

C - 854 bajtów (po ściśnięciu)

Pierwotnie miałem coś z narożnikami w kolorze cyjan, magenta i żółtym i gładkimi gradacjami kolorów, które wyglądały naprawdę ładnie, ale nie spełniały specyfikacji.

Następujące elementy spełniają specyfikację: używa „pierwszych” 2 073 600 kolorów, bez powtórzeń i czarnego w lewym górnym rogu.

Jak to działa, jest całkiem fajne. Buduje tablicę z kolorami, a następnie kilka razy sortuje w pionie i poziomie według różnych kryteriów. Efektem końcowym są przyjemne przejścia między niebieskim a zielonym oraz między ciemnością a światłem. Uruchomienie zajmuje około 1,5 sekundy. Skompiluj używając: gcc -o many many.c -lmi uruchom używając:./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;
}

Do Twojej wiadomości, to był oryginalny obraz ...

A dla osób zainteresowanych kodem użytym do wygenerowania tego obrazu:

#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

EDYCJA: Powinienem zauważyć, że przesłałem to, kiedy pytanie było jeszcze oznaczone kodem-golfem , zanim stało się konkursem popularności, więc wybrałem krótki kod. Nie jest to zbyt pomysłowe, ale uważam, że jest to prawidłowe zgłoszenie.

Wartości kolorów wahają się od 00 00 00do 1f a3 ff, zwiększając o 1, więc brak redwyniku nie jest zaskakujący.

Na koszt dodanie 1 znak długości kodu źródłowego (wymienić <<8z <<11) następujące wyjście może być miał. Obejmuje to większy zakres widma kosztem bluerozdzielczości. Przyrasta w przestrzeni RGB z ośmiokrotną szybkością. Wartości kolorów wahają się od 00 00 00do fd 1f f8.

Rakieta

Nigdy wcześniej nie stosowałem programowania obiektowego w rakietach (przekazywanie wiadomości), więc nie jestem pewien, czy jest to optymalne, ale wydaje się, że wykonało to zadanie.

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

Nie używając 3 pierwszych bitów w kanale czerwonym, uzyskuję wszystkie trzy kolory na obrazie wynikowym.

Brainfuck

Kod drukuje 24-bitowy obraz BMP do STDOUT dla 8-bitowych interpreterów BF. Tworzy ten sam obraz, co wersja rakiety. Opiera się na wersji PNM.

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

Ubuntu bfzawiera 8-bitowe komórki:

bf img.bf > image.bmp

Stara wersja, która narusza możliwość otwierania z Chrome. To sprawia, że ​​plik .pnm jest kompatybilny z większością przeglądarek obrazów.

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

Zaktualizowana, pierwsza wersja nie miała wszystkich kolorów unikalnych w przestrzeni 24-bitowej:

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

Weryfikacja zasad:

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

Pierwszy piksel jest czarny:

list[[1, 1]]

{0., 0., 0.}

Wszystkie kolory są unikalne:

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

Trwa 14,778 sekund.

Weryfikacja zasad:

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

Pierwszy piksel jest czarny:

list[[1, 1]]

{0., 0., 0.}

Wszystkie kolory są unikalne:

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

To jest wersja, która byłaby przeznaczona do wyzwania golfowego. Ponieważ tylko zwiększa wartość od 0 do 2073599, zawiera tylko unikalne kolory.

Python - 110

Ponieważ nie podobała mi się powyższa wersja (zakres kolorów nie jest w pełni wykorzystywany), wypróbowałem coś takiego:

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

Kolejne rozszerzenie powyższego:

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

Przetwarzanie, 301
Nie jest to próba najbardziej zwięzłego rozwiązania, ale zachowuje on pełną kontrolę, aby osiągnąć pożądany układ kolorów. Tak, kolory nie są następujące po sobie, ale to nie jest zabawne.

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 bajty

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

To daje plik 5,61 MB:

Powyższy kod jest skompresowaną wersją tego bardziej czytelnego kodu. Spacje zostały usunięte, aby zapisać bajty.

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 do obrazu: http: //µ.pw/k

ImageMagick - Konwertuj 119

Pozwala używać convertz przybornika ImageMagick do tworzenia obrazów. Działa za 0 sekund. Gra w golfa do 119 znaków. Nakładam dwa gradienty (czerwono-niebieski i czarno-biały) przekonwertować je na HSL i ponownie na RGB.

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

Przykłady nakładek gradientowych można znaleźć na stronach podręcznika ImageMagick .

PHP, 507

Aby uruchomić, prawdopodobnie będziesz musiał zwiększyć ilość pamięci przydzielonej PHP. Używa GD. Wygenerowanie obrazu zajmuje około 9 sekund.

$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 do obrazu wyjściowego: http://i.stack.imgur.com/AAKqW.png

Zobacz, jak działa w Internecie: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (wersja nr 1), 361 bajtów

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 bajty

Grał w golfa

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

Bez golfa

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

Wynik

Wyjaśnienie

To nie jest moja próba najkrótszego rozwiązania, ale najbardziej przenośna. Zostawił import tylko dla BufferedImage, ponieważ inne nie zapisały bajtów. Zamiast ładować obraz do pliku JPanel i pisać na nim, zaoszczędziłem czas, który upływa od początku do zapisu na dysku jako nazwa pliku. Dla mnie zajęło to w rezultacie nazwy plików około ~ 110 ms, podczas gdy czas od początku do końca zwykle zajmował ~ 500ms. Wreszcie powinien być niezależny od platformy, ponieważ testowałem zarówno w systemie Windows, jak i na maszynie Wirtualnej Ubuntu i działał (zapisuje plik na pulpicie). Musiał mieć instrukcję return z powodu śmieci składni na żądanie. Chociaż pracuję nad obejściem, wątpię, czy znajdę lepszą implementację samodzielnie ze względu na oszczędności wynikające z używania l i w dla moich pętli for. Powiedziałbym, że pół sekundy dla Javy nie jest takie złe.

 (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

Ale wierzę, że wciąż jest zatwierdzony, ponieważ można go nadal otwierać za pomocą chrome, po prostu automatycznie otwiera się do domyślnej przeglądarki png (wersja nie testowana na komputerach z systemem Unix).

Jestem świadomy możliwych zapisów bajtów, ale głównie pominąłem je, aby zakwalifikować się do bonusów. Na życzenie mogę przesłać krótsze, specyficzne dla platformy przykłady. Dziękuję Ci.

Edytować

Usunięto niepotrzebne. Spróbuj Złap blok i źle sformatowaną instrukcję return, aby zmniejszyć ~ 30 bajtów.
Usunięto, BufferedImage.TYPE_INT_RGBponieważ to dosłownie tylko 1.