Meydan okuma:

1920 piksel yüksekliğinde ve 1080 piksel yüksekliğinde bir grafik dosyası üreten bir program yazın. Grafikteki 2,073,600 pikselin her biri benzersiz bir renk olmalı ve hiçbir renk değeri tekrarlanmamalıdır. Renkler RGB cinsinden belirtilmeli ve 0,0,0 ile başlamalı ve 255,255,255'e doğru sırayla sayılmalıdır. 1920 x 1080 piksel bir görüntünün yalnızca çok sayıda siyah, mavi ve yeşillik içereceğini göreceksiniz.

Örneğin, (daha küçük bir kesim sürümü). Yükseklik 5 olarak ayarlanmışsa ve genişlik 5 olarak ayarlanmışsa, 25 piksel kare bir grafik çıktısı alınacak ve her piksel benzersiz bir renk olacaktır. RGB renk dizisi şöyle görünür:

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
    )

)

Kurallar:

• Görüntüyü oluşturmak için herhangi bir programlama dili kullanılabilir.

• En çok oy alan cevap, kazanır.

• Renkler sadece bir kez kullanılmalıdır.

• 0,0 konumundaki piksel 0,0,0 renkli ile başlamalıdır.

• Renkler gerçek renk 24 bit aralığında olmalıdır.

• Görüntü 1920 x 1080 piksel boyutunda olmalıdır.

• Renklerin RGB formatında olması gerekir.

• Görüntüyü çıktılamak için bir kütüphane kullanmak tamamdır.

• Çıktı, grafik dosyası biçiminde olmalıdır, örneğin çıktı.

• Renk değerlerini temsil eden metin olarak çıktı sayılmaz, kodun bir grafik dosyası çıkarması gerekir.

• Çıktı resmin dosya boyutu önemli değil.

• Krom web tarayıcısında çıktıyı grafik olarak açarak görüntüleyebilmeniz gerekir.

Bunu gerçekten kısa kodla yapmayı başarırsanız, programınız ayrıca geçen saniye içinde geçen süreyi, görüntünün içine yerleştirilmiş görüntünün sıralı pikseller üzerine bindirilmiş şekilde oluşturması için geçen sürelerde, programınız görüntüyü 10 saniye içinde çıkarır. Programınız görüntüyü 1 saniye içinde çıkarırsa gerçekten etkilendim.

Python - 660+ bayt

Artımlı Sürüm

Tam Boy: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

Bu, Julia Set fraktalını . Her bir renk görüntüye artımlı olarak eklenir, ancak önemli miktarda ön hesaplama vardır.

Parlaklık Sürümü

Tam boy: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

Her bir rengi, indeks yerine parlaklığa göre yineleme seçeneği ekledim. Bu sıfırdan "sayma" olarak nitelendirilmez, ancak bu gevşek bir gereksinim gibi görünmektedir. Bu iki sıranın görüntüdeki tamamen farklı yapıları ortaya çıkarması ilginçtir. Bunu kullanmak için use_luminositybayrağı ayarlayın True.

Kaynak

PIL gerektirir .

Dikkatli olun : bu işlemin gerçekleşmesi birkaç dakika sürer. PyPy'yi Pillow ile kullanmak CPYthon'un PIL ile yaklaşık beşte birini çalıştırır, bu yüzden mümkünse bunu tavsiye ederim.

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

Düzenleme : #000000belirtildiği gibi sol üstte olacak şekilde güncellendi .
Düzenleme : renkleri parlaklıkla yinelemek için bir bayrak eklendi.
Düzenleme : yerel karmaşık hesaplamalara ve biraz daha hızlı olan tam sayı parlaklık ağırlıklarına geçti.

Birincil kriter popülerlik yarışması haline gelmeden önce üzerinde çalıştığım çözümler

PHP - 161 bayt

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

Bu mümkün olan en hızlı çıktı için gidiyor. Hiçbir kütüphane kullanılmaz, sadece önceden hesaplanmış bir başlık ve doğrudan byte çıkışı bulunur. Bilgisayarımda 2 saniyeden daha kısa sürede çalışır. 1'den ziyade 256 artarak , gerçek bir hesaplamaya gerek kalmadan sözde gradyan etkisi yaratır. Tek çöküş budur ( 0, 0 ) siyah olmadığı, ancak sonuç çok daha güzel görünüyor.

ob_start();ve ob_end_flush();kesinlikle gerekli değildir, ancak çıktının tamponlanması, çok daha hızlı çalışmasını sağlar.

Diğer ilginç artışlar:

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

Ve bircok digerleri. Buna rağmen, bir şeye benzeyen desenlerin çoğu, bir tür şeritlere benzemektedir.

PHP - 105 bayt

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

Pervasız ihmal sürümü.

• Kırık bir Content-typebaşlık verildiğinde , Chrome ne gönderildiğini bulmak için elinden geleni yapacaktır. Bu durumda, onu doğru olarak tanımlar.image/bmp . FireFox ve IE'nin en son sürümleri kırılan başlığı da düzeltebilir.
• Korkaklar BM, I5S2ve CSbir NOTICEhata üretecek . Görüntünün bozulmasını önlemek için, bunu önlemek için hata raporlamasının php.iniayarlanması gerekecektir (örn. error_reporting = E_ALL & ~E_NOTICE).
• Tampon çıkışı yok. Görüntü bir seferde 3 bayt, belirgin bir şekilde yavaşlar.
• ( 0, 0 ) noktasının sol üst değil, sol alt olarak kabul edilir.

PHP-CLI - 83 bayt

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

Doğrudan komut satırından çalıştırın ve bir dosyaya (örn. $ php all-colors.php > out.bmp) Aktarın; Content-typebaşlık gerekmez. Sonuçta ortaya çıkan dosya 105 bayt sürümüyle aynıdır ve Chrome'da görüntülenebilir.

GD grafik kitaplığı ile C (err, yaklaşık 2.5 KB?)

Kurallar mevcut bir görüntünün değiştirilmesini yasaklamıyordu. Ben den sıralı RGB değerlerine sahip bir görüntünün tüm pikselleri değiştirmek için bir program yapılmış #000000için #1fa3ffve oldukça sonuçlarla memnun değilim. İşte Michael Carian'ın ( cc-by-sa 2.0 ) Flickr'a gönderdiği bir fotoğraftan ürettiği şey :

(Ham çıktı görüntüsü oldukça büyük (5,6 MB) )

İşte sol üst köşenin yakın bir görüntüsü: (% 400 büyütülmüş):

Bu boyutta bir görüntü için işlem süresi yaklaşık 3 saniyedir:

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

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

ve evet, tüm pikseller farklı renkler:

$ identify -format %k outfile.png
2073600

( identifybir ImageMagick yardımcı programıdır;-format %k seçenek, görüntüdeki benzersiz renklerin sayısını sayar)

İşte kaynak kod:

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

Tam çözünürlüklü bir PNG (5,1 MB)

Kod, 0-1080 * 1920 arasında tüm tam sayıların bir koleksiyonunu oluşturur, ardından bunları genel parlaklığa göre sıralar. Daha sonra bir Mandelbrot seti yaratır ve kaçış yinelemelerine ve değerlerine göre pozisyonları sıralar. Daha sonra her iki sette yürür, karanlıktan aydınlığa doğru sırayla renkleri atayarak en küçükten en büyüğe Mandelbrot değerlerine atar. Son olarak, komut satırı parametresi olarak belirtilen çıktı dosya adına, piksel BMP görüntüsü başına 32 bit yazar.

#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 tam olarak golf oynamadı, ancak çok daha küçük olmayacak.

C - 854 bayt (sıkıldığında)

Aslında camgöbeği, macenta ve sarı köşelerden ve gerçekten güzel görünen pürüzsüz renk tonlarından oluşan bir şeyim vardı, ama özelliklere uymuyordu.

Aşağıdaki özellikler yerine getirmektedir: "ilk" 2.073.600 rengi, tekrarlama yok ve sol üst köşede siyahı kullanır.

Nasıl çalıştığı çok havalı. Renklerle bir dizi oluşturur, ardından birkaç kez dikey ve yatay olarak farklı ölçütlere göre sıralar. Sonuç, mavi ve yeşil ve karanlık ve ışık arasındaki hoş geçişlerdir. Çalıştırması yaklaşık 1,5 saniye sürer. Kullanarak derleyin gcc -o many many.c -lmve kullanarak çalıştırın:./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;
}

Bilginize, bu orijinal resim oldu ...

Ve bu görüntüyü oluşturmak için kullanılan kodla ilgilenenler için:

#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: Soru hala kod-golf olarak etiketlendiğinde , popülerlik yarışması haline gelmeden önce bunu gönderdiğimi not etmeliyim. kısa kod için gideceğimi . Bu çok yaratıcı değil ama geçerli bir başvuru olduğuna inanıyorum.

Renk değerleri arasında değişir 00 00 00kadar 1f a3 ffartış kademelerine, 1eksikliği böylece, redsonuç şaşırtıcı değildir.

Kaynak kod uzunluğuna 1 karakter ekleme maliyeti (yerine <<8ile <<11), aşağıdaki çıktı olabilir. Bu, blueçözünürlük maliyetiyle daha geniş bir spektrum yelpazesini kapsar . RGB uzayda oranın sekiz katını arttırır. Renk değerleri arasında değişir 00 00 00için fd 1f f8.

raket

Daha önce hiç raket nesne yönelimli programlama kullanmamıştım (mesaj geçerken), bu yüzden bunun optimal olduğundan emin değilim, ancak işi halledecek gibi görünüyor.

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

Kırmızı kanaldaki ilk 3 bit kullanılmayacaksa, sonuç resmimin üç rengini alıyorum.

brainfuck

Kod, 8 bit hücre BF yorumlayıcıları için 24 bit BMP görüntüsünü STDOUT'a yazdırır. Raket sürümüyle aynı görüntüyü oluşturur. Pnm versiyonunu temel alır.

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

Ubuntu bf8 bit hücreli olarak geliyor:

bf img.bf > image.bmp

Chrome'dan açılmayı ihlal eden eski sürüm. Çoğu resim görüntüleyiciyle uyumlu bir .pnm dosyası oluşturur.

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

Güncelleme yapıldıktan sonra ilk sürüm 24-bitlik alanda benzersiz olan tüm renklere sahip değildi:

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

Kural doğrulama:

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

İlk piksel siyah:

list[[1, 1]]

{0., 0., 0.}

Tüm renkler eşsiz:

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

14.778 saniye sürer.

Kural doğrulama:

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

İlk piksel siyah:

list[[1, 1]]

{0., 0., 0.}

Tüm renkler eşsiz:

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

Bu, kod golf mücadelesi için olan sürüm. Değeri 0'dan 2073599'a çıkardığı için, yalnızca benzersiz renkler içerir.

Python - 110

Yukarıdaki sürümü beğenmedim (colorrange tamamen kullanılmadı), aşağıdaki gibi bir şey denedim:

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

Yukarıdakilere başka bir uzantı:

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

İşleme, 301
Bu, en özlü çözüm için bir girişim değildir, ancak istenen renk düzenlemesini elde etmek için tüm kontrolü elinde tutar. Evet, renkler ardışık değil, ama eğlenceli değil.

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 bayt

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

Bu 5.61 MB'lık bir dosya çıkarır:

Yukarıdaki kod, bu daha okunabilir kodun sıkıştırılmış bir sürümüdür. Baytları kurtarmak için boşluklar kaldırıldı.

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

Resme bağlantı: http: //µ.pw/k

ImageMagick - Dönüştür 119

convertGörüntüler oluşturmak için ImageMagick araç kutusundan kullanalım . 0 saniye içinde çalışır. 119 karakter golf oynuyor. İki degradeyi (kırmızı-mavi ve siyah-beyaz) kapladım, onları HSL'ye ve RGB'ye geri döndüm.

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

Degrade bindirme örnekleri ImageMagick kılavuz sayfalarında bulunabilir .

PHP, 507

Muhtemelen çalışması için PHP'ye ayrılan hafıza miktarını arttırmanız gerekecektir. GD kullanır. Görüntüyü oluşturmak yaklaşık 9 saniye sürer.

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

Çıktı resmine bağlantı: http://i.stack.imgur.com/AAKqW.png

Web'de çalıştığını görün: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080

DELPHI / PASCAL (Sürüm # 1), 361 bayt

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 bayt

golfed

import java.awt.image.*;()->new BufferedImage(1920,1080,1){{long t=System.currentTimeMillis();int q=-1;for(int i=0;i<getWidth();i++)for(int j=0;j<getHeight();j++)setRGB(i,j,q++);java.io.File f=new java.io.File(System.getProperty("user.home"),"Desktop"+System.getProperty("file.separator")+(System.currentTimeMillis()-t)+".png");javax.imageio.ImageIO.write(this,"png",f);java.awt.Desktop.getDesktop().open(f);}}

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

Sonuç

açıklama

Bu benim en kısa çözüm yolundaki girişimim değil, en taşınabilir çözüm. Diğerleri bayt kaydetmediğinden, yalnızca BufferedImage için içe aktarma yaptı. Görüntüyü bir JPanel'e yüklemek ve üzerine yazmak yerine, dosya adı olarak diske yazmaya kadar geçen zamandan itibaren zaman kazandım. Benim için bu, yaklaşık ~ 110 ms dosya isimleriyle sonuçlandı, oysa baştan sona kadar olan zaman genellikle ~ 500 ms sürdü. Son olarak, hem Windows'ta hem de Ubuntu VM'de test ettiğimden ve platform çalıştığından platform bağımsız olmalı (Dosyayı Masaüstünüze yazar). Callable sözdizimi çöplüğü nedeniyle return ifadesine sahip olmak zorunda kaldım. Etrafında çalışmama rağmen, döngüler için l ve w kullanmamın sağladığı tasarruflar nedeniyle kendi başıma daha iyi bir uygulama bulacağımdan şüpheliyim. Java için yarım saniyenin fena olmadığını söyleyebilirim.

 (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

Ancak hala krom tarafından açılabildiğinden hala doğrulanmış olduğuna inanıyorum, yalnızca otomatik olarak varsayılan png görüntüleyicinize açılır (sürüm Unix tabanlı makinelerde test edilmemiştir).

Bayt tasarruflarının mümkün olduğunu biliyorum ama çoğunlukla ikramiye almaya hak kazanmadık. İstenirse daha kısa, platforma özel örnekler yükleyebilirim. Teşekkür ederim.

Düzenle

Kaldırıldı Gereksiz ~ 30 bayt azaltmak için Catch bloğunu ve kötü biçimlendirilmiş return deyimini deneyin.
Kaldırıldı BufferedImage.TYPE_INT_RGBçünkü kelimenin tam anlamıyla sadece 1.