Вызов:

Напишите программу, которая выводит графический файл шириной 1920 пикселей и высотой 1080 пикселей. Каждый из 2 073 600 пикселей в графике должен иметь уникальный цвет, и никакие значения цвета не должны повторяться. Цвета должны быть указаны в RGB и начинаться с 0,0,0 и считаться в порядке возрастания до 255,255,255. Вы увидите, что изображение размером 1920 x 1080 пикселей будет содержать только много черного, синего и зеленого.

Например, (уменьшенная урезанная версия). Если высота была установлена ​​на 5, а ширина была установлена ​​на 5, будет выведено квадратное графическое изображение 25 пикселей, и каждый пиксель будет иметь уникальный цвет. Цветовой массив RGB будет выглядеть так:

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
    )

)

Правила:

• Любой язык программирования может быть использован для генерации изображения.

• Ответ с наибольшим количеством голосов выигрывает.

• Цвета должны быть использованы только один раз.

• Пиксель в позиции 0,0 должен начинаться с цвета 0,0,0

• Цвета должны находиться в пределах 24-битного диапазона истинного цвета.

• Размер изображения должен быть 1920 x 1080 пикселей.

• Цвета должны быть в формате RGB.

• Использование библиотеки для вывода изображения в порядке.

• Выходные данные должны быть в формате графического файла, например output.png

• Вывод в виде текста, который представляет значения цвета, не учитывается, код должен выводить графический файл.

• Размер файла выходного изображения не имеет значения.

• Вы должны иметь возможность просмотреть вывод, открыв его в виде графики в веб-браузере Chrome.

Я был бы впечатлен, если вам удастся сделать это с действительно коротким кодом, ваша программа также выводит время в секундах, затраченное на генерацию изображения, встроенного в само изображение, наложенное на последовательные пиксели, ваша программа выводит изображение в течение 10 секунд. Я был бы очень впечатлен, если ваша программа выводит изображение в течение 1 секунды.

Python - 660+ байтов

Инкрементная версия

Полный размер: http://www.pictureshack.net/images/57626_all_colors.png (4,52 МБ)

Это изображение, основанное на фрактале Джулии Сет . Каждый цвет добавляется к изображению постепенно, хотя существует значительный предварительный расчет.

Версия светимости

Полный размер: http://www.pictureshack.net/images/95389_all_colors4.png (5,24 МБ)

Я добавил возможность повторять каждый цвет по яркости, а не по индексу. Это не может считаться «отсчетом» с нуля, но это, похоже, слабое требование. Интересно, что эти два порядка представляют совершенно разные структуры изображения. Чтобы использовать это, установите use_luminosityфлаг в True.

Источник

Требуется ПИЛ .

Имейте в виду : это займет несколько минут. Использование PyPy с Pillow работает примерно на одну пятую времени CPython с PIL, поэтому я бы порекомендовал это, если это возможно.

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

Редактировать : обновлено, чтобы #000000оно находилось в верхнем левом углу, как указано.
Редактировать : добавлен флаг для повторения цветов по яркости.
Изменить : переключен на собственные сложные вычисления и целочисленные значения яркости, которые немного быстрее.

Решения, над которыми я работал до того, как основным критерием стал конкурс на популярность

PHP - 161 байт

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

Это происходит для максимально быстрого вывода. Библиотека не используется, только предварительно вычисленный заголовок и прямой байтовый вывод. Запускается менее чем за 2 секунды на моем компе. Увеличивая значение на 256, а не на 1 , он создает эффект псевдоградиента, не требующий реальных вычислений. Единственным недостатком является то, что ( 0, 0 ) не черный, но результат выглядит намного лучше.

ob_start();и ob_end_flush();не являются строго необходимыми, но буферизация вывода заставляет его работать намного быстрее.

Другие интересные приращения включают в себя:

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

И многие другие. Хотя большинство моделей, которые выглядят как что-либо, напоминают полосы

PHP - 105 байт

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

Безрассудная неуважение к версии.

• Учитывая сломанный Content-typeзаголовок, Chrome постарается выяснить, что именно было отправлено. В этом случае он правильно идентифицирует его как image/bmp. Последние версии Firefox и IE также могут исправить сломанный заголовок.
• Голые слова BM, I5S2и CSсгенерирует NOTICEошибку. Чтобы предотвратить искажение изображения, php.iniнеобходимо установить отчет об ошибках в (например error_reporting = E_ALL & ~E_NOTICE).
• Нет выходной буферизации. Изображение создается по 3 байта за раз, что заметно медленнее.
• Точка ( 0, 0 ) считается левой нижней, а не верхней левой.

PHP-CLI - 83 байта

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

Запускайте прямо из командной строки и передавайте в файл (например $ php all-colors.php > out.bmp), Content-typeзаголовок не требуется. Полученный файл идентичен 105-байтовой версии и может быть просмотрен в Chrome.

C с графической библиотекой GD (ошибается, около 2,5 КБ?)

Правила не запрещают изменять существующее изображение. Я сделал программу для замены всех пикселей изображения последовательными значениями RGB от #000000до #1fa3ff, и я очень доволен результатами. Вот что получено из фотографии, опубликованной на Flickr Майклом Карианом ( cc-by-sa 2.0 ):

(Необработанное выходное изображение довольно большое (5,6 МБ) )

Вот крупный план верхнего левого угла (увеличенный на 400%):

Время обработки составляет около 3 секунд для изображения такого размера:

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

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

и да, все пиксели разных цветов:

$ identify -format %k outfile.png
2073600

( identifyэто утилита ImageMagick; -format %kопция подсчитывает количество уникальных цветов в изображении)

Вот исходный код:

#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 байт

Полное разрешение PNG (5,1 МБ)

Код создает коллекцию всех целых чисел от 0 до 1080 * 1920, а затем сортирует их по общей яркости. Затем он создает набор Мандельброта и сортирует позиции на основе их итерации и значения. Затем он проходит через оба набора, назначая цвета в порядке от темного до светлого значениям Мандельброта от наименьшего к наибольшему. Наконец, он записывает 32-битное изображение BMP в выходное имя файла, указанное в качестве параметра командной строки.

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

Код не полностью соответствует, но он не станет намного меньше.

C - 854 байта (при сжатии)

Первоначально у меня было что-то с голубыми, пурпурными и желтыми углами и плавными градациями цветов, которые выглядели действительно хорошо, но это не соответствовало спецификациям.

Следующее соответствует спецификациям: использует «первые» 2 073 600 цветов, без повторов и черный в верхнем левом углу.

Как это работает, это круто. Он строит массив с цветами, а затем сортирует их по вертикали и горизонтали по разным критериям несколько раз. Конечным результатом являются приятные переходы между синим и зеленым и между темным и светлым. Запуск занимает около 1,5 секунд. Скомпилируйте используя: gcc -o many many.c -lmи запустите используя:./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;
}

К вашему сведению, это было оригинальное изображение ...

И для тех, кто заинтересован в коде, используемом для создания этого изображения:

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

Рубин, 109

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

РЕДАКТИРОВАТЬ: я должен отметить, что я представил это, когда вопрос все еще был помечен code-golf , прежде чем он стал конкурсом популярности, поэтому я собирался для короткого кода. Это не очень изобретательно, но я считаю, что это правильное представление.

Цветовые значения варьируются от 00 00 00до 1f a3 ff, с приращением 1, поэтому отсутствие redрезультата не удивительно.

Что касается стоимости добавления 1 символа к длине исходного кода (заменить <<8на <<11), может быть получен следующий вывод. Это охватывает более широкий спектр спектра за счет blueразрешения. Он увеличивается через пространство RGB в восемь раз быстрее. Цветовые значения варьируются от 00 00 00до fd 1f f8.

рэкет

Раньше никогда не использовал объектно-ориентированное программирование на ракетках (передача сообщений), поэтому я не уверен, что это оптимально, но похоже, что работа выполнена.

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

Не используя 3 первых бита в красном канале, я получаю все три цвета в моем итоговом изображении.

Brainfuck

Код распечатывает 24-битное изображение BMP в STDOUT для 8-битных интерпретаторов BF с ячейками. Создает то же изображение, что и версия Racket. Он основан на версии PNM.

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

Ubuntu поставляется с bf8-битными ячейками:

bf img.bf > image.bmp

Старая версия, которая нарушает возможность открытия из Chrome. Он создает файл .pnm, совместимый с большинством средств просмотра изображений.

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

Обновленная первая версия не имеет всех цветов, уникальных в 24-битном пространстве:

Математика: 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}]]

Правила проверки:

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

Первый пиксель черный:

list[[1, 1]]

{0., 0., 0.}

Все цвета уникальны:

id = ImageData[Image[list], "Bit16"]]
Length[DeleteDuplicates[Flatten[id, 1]]] == 1920*1080

True

Математика: 146

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

Занимает 14,778 секунд.

Правила проверки:

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

Первый пиксель черный:

list[[1, 1]]

{0., 0., 0.}

Все цвета уникальны:

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

Это версия, которая была бы для соревнования Code-Golf. Так как он просто увеличивает значение с 0 до 2073599, он содержит только уникальные цвета.

Питон - 110

Поскольку мне не понравилась вышеуказанная версия (цветовой диапазон не используется полностью), я попробовал что-то вроде следующего:

from PIL import Image
a=list(range(0,2073600*8,8))
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

Питон - 122

Еще одно дополнение к вышесказанному:

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

Обработка, 301
Это не попытка наиболее краткого решения, но она сохраняет весь контроль для достижения желаемого расположения цветов. Да, цвета не последовательные, но это не весело.

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 байта

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

Это выводит файл 5,61 МБ:

Код выше является сжатой версией этого более читаемого кода. Пробелы были удалены, чтобы сохранить байты.

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

Ссылка на изображение: http: //µ.pw/k

ImageMagick - конвертировать 119

Давайте использовать convertиз панели инструментов ImageMagick для создания изображений. Работает за 0 секунд. Гольф до 119 символов. Я накладываю два градиента (красно-синий и черно-белый), преобразую их в HSL и обратно в RGB.

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

Примеры наложения градиента можно найти на страницах справки ImageMagick .

PHP, 507

Вам, вероятно, потребуется увеличить объем памяти, выделенной для PHP, для запуска. Использует GD. Занимает около 9 секунд, чтобы сгенерировать изображение.

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

Ссылка на выходное изображение: http://i.stack.imgur.com/AAKqW.png

Посмотрите, как он работает в Интернете: http://ben-paton.co.uk/portfolio/pixel.php?w=1920&h=1080.

DELPHI / PASCAL (Версия # 1), 361 байт

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 байта

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

Результат

объяснение

Это не моя попытка найти самое короткое решение, а скорее самое портативное. Импортируется только для BufferedImage, потому что другие не сохраняют байты. Вместо того, чтобы загружать изображение в JPanel и писать на нем, я сохранил время, от начала до записи на диск, в качестве имени файла. Для меня это потребовало, это привело к именам файлов около ~ 110 мс, тогда как время от начала до конца обычно занимало ~ 500 мс. Наконец, он должен быть независимым от платформы, как я тестировал как в Windows, так и на виртуальной машине Ubuntu, и он работал (он записывает файл на рабочий стол). Должен был быть оператор return из-за мусора синтаксиса Callable. Хотя я работаю над обходом, я сомневаюсь, что найду лучшую реализацию самостоятельно из-за экономии от использования l и w для цикла for. Я бы сказал, что полсекунды для Java не так уж и плохи.

 (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

Но я верю, что он все еще проверен, так как его все еще можно открыть с помощью chrome, он просто автоматически открывается в вашей программе просмотра png по умолчанию (версия не тестировалась на машинах на основе Unix).

Я знаю о возможном сохранении байтов, но в основном опускал их, чтобы претендовать на бонусы. По запросу я могу загрузить более короткие примеры для конкретной платформы. Спасибо.

редактировать

Удален ненужный блок Try Catch и неправильно отформатированный оператор return для уменьшения ~ 30 байт.
Удалено, BufferedImage.TYPE_INT_RGBпотому что буквально 1.