Tantangan:

Tulis sebuah program yang menghasilkan file grafik 1920 piksel lebar 1080 tinggi. Setiap 2.073.600 piksel dalam grafik harus berwarna unik dan tidak ada nilai warna yang harus diulang. Warna harus ditentukan dalam RGB dan mulai dari 0,0,0 dan dihitung ke atas secara berurutan menuju 255.255.255. Anda akan menemukan gambar 1920 x 1080 piksel hanya akan mengandung banyak warna hitam, biru dan hijau.

Misalnya, (versi pengurangan yang lebih kecil). Jika tinggi diatur ke 5 dan lebar diatur ke 5 grafik persegi 25 piksel akan menjadi output dan setiap piksel akan menjadi warna yang unik. Array warna RGB akan terlihat seperti ini:

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
    )

)

Aturan:

• Bahasa pemrograman apa pun dapat digunakan untuk menghasilkan gambar.

• Jawaban dengan kemenangan terbanyak menang.

• Warna hanya boleh digunakan satu kali.

• Pixel pada posisi 0,0 harus dimulai dengan warna 0,0,0

• Warna harus berada dalam kisaran warna 24 bit yang sebenarnya.

• Gambar harus berukuran 1920 x 1080 piksel.

• Warna harus dalam format RGB.

• Menggunakan perpustakaan untuk menampilkan gambar tidak masalah.

• Output harus dalam format file grafik misalnya output.png

• Output sebagai teks yang mewakili nilai warna tidak masuk hitungan, kode harus menampilkan file grafik.

• Ukuran file dari gambar output tidak masalah.

• Anda harus dapat melihat output dengan membukanya sebagai grafik di browser web chrome.

Saya akan terkesan jika Anda melakukan ini dengan kode yang benar-benar singkat, program Anda juga mengeluarkan waktu dalam detik yang telah berlalu untuk menghasilkan gambar yang tertanam di dalam gambar itu sendiri yang dilapiskan pada piksel berurutan, program Anda menghasilkan gambar dalam waktu 10 detik. Saya akan sangat terkesan jika program Anda menampilkan gambar dalam 1 detik.

Python - 660+ byte

Versi Tambahan

Ukuran Penuh: http://www.pictureshack.net/images/57626_all_colors.png (4,52MB)

Ini adalah gambar berdasarkan fraktal Julia Set . Setiap warna ditambahkan ke gambar secara bertahap, meskipun ada sejumlah besar pra-perhitungan.

Versi Luminosity

Ukuran penuh: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

Saya telah menambahkan opsi untuk beralih setiap warna dengan luminositas, bukan berdasarkan indeks. Ini tidak memenuhi syarat sebagai "menghitung" dari nol, tetapi ini tampaknya merupakan persyaratan yang lemah. Sangat menarik bahwa dua urutan ini memperlihatkan struktur yang sangat berbeda dalam gambar. Untuk menggunakan ini, atur use_luminositybendera ke True.

Sumber

Membutuhkan PIL .

Diperingatkan : ini akan membutuhkan beberapa menit untuk dieksekusi. Menggunakan PyPy with Pillow berjalan sekitar seperlima waktu CPython dengan PIL, jadi saya akan merekomendasikan itu, jika mungkin.

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

Sunting : diperbarui sehingga #000000ada di kiri atas, seperti yang ditentukan.
Sunting : menambahkan bendera untuk beralih warna dengan luminositas.
Sunting : beralih ke perhitungan kompleks asli, dan bobot luminositas integer, yang sedikit lebih cepat.

Solusi yang saya kerjakan sebelum kriteria utama menjadi kontes popularitas

PHP - 161 byte

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

Ini akan menghasilkan output tercepat. Tidak ada perpustakaan yang digunakan, hanya header yang sudah dihitung sebelumnya, dan keluaran byte langsung. Berjalan kurang dari 2 detik di komputer saya. Dengan menambah dengan 256 daripada 1 , itu menghasilkan efek pseudo-gradient, tanpa perhitungan nyata diperlukan. Satu-satunya kejatuhan adalah bahwa ( 0, 0 ) tidak hitam, tetapi hasilnya terlihat jauh lebih baik.

ob_start();dan ob_end_flush();tidak sepenuhnya diperlukan, tetapi buffering output membuatnya berjalan jauh lebih cepat.

Peningkatan menarik lainnya termasuk:

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

Dan banyak lagi. Meskipun, sebagian besar pola yang terlihat seperti apa pun menyerupai garis-garis

PHP - 105 byte

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

Mengabaikan versi sembrono.

• Diberikan Content-typetajuk yang rusak , Chrome akan melakukan yang terbaik untuk mengetahui apa yang dikirim. Dalam hal ini, itu benar mengidentifikasi sebagai image/bmp. Versi terbaru FireFox dan IE juga dapat memperbaiki header yang rusak.
• Kata pengantar BM,, I5S2dan CSakan menghasilkan NOTICEkesalahan. Untuk mencegah kerusakan gambar, pelaporan kesalahan dalam php.iniperlu diatur untuk mencegah hal ini (misalnya error_reporting = E_ALL & ~E_NOTICE).
• Tidak ada buffering output. Gambar ini dibangun 3 byte sekaligus, yang terasa lebih lambat.
• Titik ( 0, 0 ) dianggap sebagai kiri bawah, bukan kiri atas.

PHP-CLI - 83 byte

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

Jalankan langsung dari baris perintah dan disalurkan ke file (misalnya $ php all-colors.php > out.bmp), tidak ada Content-typeheader yang diperlukan. File yang dihasilkan identik dengan versi 105 byte, dan dapat dilihat di Chrome.

C dengan perpustakaan grafik GD (err, sekitar 2.5 KB?)

Aturan tidak melarang memodifikasi gambar yang ada. Saya membuat program untuk mengganti semua piksel gambar dengan nilai RGB berurutan dari #000000menjadi#1fa3ff , dan saya cukup senang dengan hasilnya. Inilah yang dihasilkan dari foto yang diposting ke Flickr oleh Michael Carian ( cc-oleh-sa 2.0 ):

(Gambar output mentah agak besar (5,6 MB) )

Berikut ini foto close-up sudut kiri atas (ditingkatkan 400%):

Waktu pemrosesan sekitar 3 detik untuk gambar dengan ukuran ini:

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

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

dan ya, semua pikselnya berwarna berbeda:

$ identify -format %k outfile.png
2073600

(identify adalah utilitas ImageMagick; -format %kopsi menghitung jumlah warna unik dalam suatu gambar)

Berikut kode sumbernya:

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

PNG resolusi penuh (5.1MB)

Kode menciptakan koleksi semua bilangan bulat dari 0-1080 * 1920, lalu mengurutkannya dengan kecerahan keseluruhan. Ini kemudian menciptakan set Mandelbrot, dan mengurutkan posisi berdasarkan iterasi dan nilai melarikan diri mereka. Kemudian ia berjalan melalui kedua set, menugaskan warna dalam urutan dari gelap ke cerah ke nilai Mandelbrot terkecil hingga terbesar. Akhirnya, ia menulis gambar BMP 32 bit per pixel ke nama file output yang ditentukan sebagai parameter baris perintah.

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

Kode tidak sepenuhnya golf, tetapi tidak akan menjadi terlalu kecil.

C - 854 byte (saat diperas)

Saya awalnya memiliki sesuatu dengan cyan, magenta, dan sudut kuning dan gradasi warna yang halus yang terlihat sangat bagus, tetapi tidak memenuhi spesifikasi.

Yang berikut ini memenuhi spesifikasi: menggunakan 2.073.600 warna "pertama", tanpa pengulangan, dan hitam di sudut kiri atas.

Cara kerjanya agak keren. Itu membangun sebuah array dengan warna, kemudian mengurutkan secara vertikal dan horizontal dengan kriteria yang berbeda beberapa kali. Hasil akhirnya adalah transisi yang menyenangkan antara biru & hijau dan antara gelap & terang. Dibutuhkan sekitar 1,5 detik untuk berjalan. Kompilasi menggunakan: gcc -o many many.c -lmdan jalankan menggunakan:./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, ini adalah gambar asli ...

Dan bagi mereka yang tertarik dengan kode yang digunakan untuk menghasilkan gambar ini:

#include <stdio.h>
#include <math.h>

int main(int argc, char **argv)
{
        int x, y;
        int w = (argc > 1)? atoi(argv[1]): 1920;
        int h = (argc > 2)? atoi(argv[2]): 1080;
        double l = hypot(w, h);

        fprintf(stdout, "P6 %d %d 255\n", w, h);

        for (y = 0; y < h; y++)
        {
                for (x = 0; x < w; x++)
                {
                        unsigned char v[3];
                        v[0] = floor(256 * hypot(0 - x, h - y) / l);
                        v[1] = floor(256 * hypot(w - x, h - y) / l);
                        v[2] = floor(256 * hypot(w - x, 0 - y) / l);
                        fwrite(v, sizeof(unsigned char), 3, stdout);
                }
        }

        return 0;
}

Ruby, 109

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

EDIT: Saya harus mencatat bahwa saya mengirimkan ini ketika pertanyaannya masih ditandai kode-golf , sebelum menjadi kontes popularitas jadi saya akan mencari kode pendek. Ini tidak terlalu imajinatif tapi saya percaya itu adalah pengiriman yang valid.

Nilai warna berkisar dari 00 00 00hingga 1f a3 ffmeningkat 1, sehingga kurangnya redhasilnya tidak mengejutkan.

Untuk biaya menambahkan 1 karakter ke panjang kode sumber (ganti <<8dengan <<11), output berikut dapat diperoleh. Ini mencakup lebih banyak spektrum dengan biaya blueresolusi. Ini meningkat melalui ruang RGB pada tingkat delapan kali lipat. Nilai warna berkisar dari 00 00 00hingga fd 1f f8.

Raket

Tidak pernah menggunakan pemrograman berorientasi objek raket sebelumnya (message passing) jadi saya tidak yakin ini optimal, tetapi tampaknya menyelesaikan pekerjaan.

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

Dengan tidak menggunakan 3 bit pertama di saluran merah saya mendapatkan ketiga warna di gambar hasil saya.

Brainfuck

Kode mencetak gambar BMP 24bit ke STDOUT untuk penerjemah BF sel 8 bit. Ini menciptakan gambar yang sama dengan versi Racket. Ini didasarkan pada versi pnm.

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

Ubuntu dikirimkan dengan bfyang memiliki sel 8 bit:

bf img.bf > image.bmp

Versi lama yang melanggar bisa dibuka dari Chrome. Itu membuat file .pnm yang kompatibel dengan sebagian besar pemirsa gambar.

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

Diperbarui, versi pertama tidak memiliki semua warna unik dalam ruang 24-bit:

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

Verifikasi aturan:

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

Pixel pertama berwarna hitam:

list[[1, 1]]

{0., 0., 0.}

Semua warna unik:

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

Membutuhkan 14,778 detik.

Verifikasi aturan:

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

Pixel pertama berwarna hitam:

list[[1, 1]]

{0., 0., 0.}

Semua warna unik:

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

Ini adalah versi, yang seharusnya untuk tantangan kode-golf. Karena hanya meningkatkan nilai dari 0 hingga 2073599, itu hanya berisi warna-warna unik.

Python - 110

Karena saya tidak suka versi di atas (colorrange tidak sepenuhnya digunakan), saya mencoba sesuatu seperti berikut:

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

Ekstensi lain ke atas:

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

Memproses, 301
Ini bukan upaya solusi yang paling singkat, tetapi ini mempertahankan semua kontrol untuk mencapai pengaturan warna yang diinginkan. Ya, warnanya tidak berurutan, tapi itu tidak menyenangkan.

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

Ini menghasilkan file 5,61 MB:

Kode di atas adalah versi terkompresi dari kode yang lebih mudah dibaca ini. Spasi telah dihapus untuk menyimpan 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

Tautan ke gambar: http: //µ.pw/k

ImageMagick - Konversi 119

Mari kita gunakan convertdari ImageMagick toolbox untuk membuat gambar. Ini berjalan dalam 0 detik. Ini golf hingga 119 karakter. Saya overlay dua gradien (merah-biru dan hitam-putih) mengubahnya menjadi HSL dan kembali ke RGB.

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

Contoh overlay gradien dapat ditemukan di halaman manual ImageMagick .

PHP, 507

Anda mungkin perlu menambah jumlah memori yang dialokasikan untuk PHP agar dapat dijalankan. Menggunakan GD. Butuh waktu sekitar 9 detik untuk menghasilkan gambar.

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

Tautan ke gambar output: http://i.stack.imgur.com/AAKqW.png

Lihat itu berjalan di web: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Versi # 1), 361 byte

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

Jawa 411 386 + 24 byte

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

Tidak disatukan

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

Hasil

Penjelasan

Ini bukan upaya saya untuk solusi terpendek, melainkan yang paling portabel. Hanya tersisa impor untuk BufferedImage karena yang lain tidak menyimpan byte. Daripada memuat Gambar ke dalam JPanel dan menulis di atasnya, saya menghemat waktu mulai dari awal hingga menulis ke disk sebagai nama file. Bagi saya, ini mengambil menghasilkan nama file sekitar ~ 110 ms, sedangkan waktu dari awal hingga akhir biasanya memakan waktu ~ 500 ms. Terakhir, itu harus platform independen ketika saya diuji di Windows dan Ubuntu VM dan itu berhasil (Ini menulis file ke Desktop Anda). Harus memiliki pernyataan kembali karena sampah sintaks Callable. Meskipun saya sedang mengerjakan pekerjaan di sekitar, saya ragu saya akan menemukan implementasi yang lebih baik pada saya sendiri karena menghemat menggunakan l dan w untuk loop saya. Saya akan mengatakan setengah detik untuk java tidak terlalu buruk.

 (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

Tapi saya percaya itu masih divalidasi karena masih bisa dibuka oleh chrome, itu hanya secara otomatis terbuka ke png viewer default Anda (versi tidak diuji pada mesin berbasis Unix).

Saya menyadari kemungkinan penghematan byte tetapi sebagian besar telah menghilangkannya agar memenuhi syarat untuk bonus. Jika diminta, saya dapat mengunggah lebih pendek, contoh spesifik platform. Terima kasih.

Edit

Dihapus tidak perlu Coba Tangkap blok dan pernyataan kembali diformat buruk untuk mengurangi ~ 30 byte.
Dihapus BufferedImage.TYPE_INT_RGBkarena secara harfiah hanya 1.