Створіть графіку 1920 x 1080 з 2 073 600 унікальних кольорів


24

Виклик:

Напишіть програму, яка видає графічний файл шириною 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 секунди.


3
Якщо це гольф з кодом, як визначається показник бонусів? Бонус на 10 символів здається дуже маленьким для коду, який (ефективно) пророкує майбутнє.
Кендалл Фрей

1
Тепер бонусних значень немає! Як ми повинні приймати ці бонуси? Ігнорувати їх?
Кендалл Фрей

3
Виберіть лаконічну мову та короткий API PNG (критично!), А потім порахуйте 2 073 600. На жаль, настільки критично, @BenPaton, але я прогнозую, що вибір мови та API буде найбільшим фактором тут, а не показ розумного програмування. Але я часто помиляюся і ще рідше розумний. :-)
Даррен Стоун

2
Вимога до чорного пікселя x==y==0здається трохи довільною. У будь-якому випадку, це неоднозначно, оскільки ці координати можуть посилатися на верхній лівий або нижній лівий кут зображення.
пискливе костіння

3
Дублікат зображень з усіма кольорами ; Єдина відмінність полягає в обмеженні кольорової палітри лише блюзом та зеленкою, а не всіма , що не робить великої різниці в проблемі, але робить вихід менш гарним.

Відповіді:


40

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.


Джерело

Потрібен PIL .

Будьте попереджені : на виконання цього піде кілька хвилин. Використання PyPy з подушкою працює приблизно в п’ятій час 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 також здатні виправити зламаний заголовок.
  • У barewords 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.


3
Мені дуже подобається візерунок, дуже потріпаний!
Бен Патон

Мені подобається перше зображення, але воно, схоже, порушує правило, яке вимагає, щоб піксель 0,0 був R,0 0,0,0.
Іссі

@primo Мені добре виглядає.
Іссі

1
Мені так подобається версія світності, що я встановив її як шпалери для робочого столу :)
Бен Патон

24

C з графічною бібліотекою GD (помилка, близько 2,5 КБ?)

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

640x360 піксельних мініатюр результатів тесту

(Вихідне вихідне зображення досить велике (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;
}

Вау, це дивовижно! : D +1 Також 2,463 КБ: P
Дверна ручка

16

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

Код не повністю гольф, але він не буде надто значно меншим.


11

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

FYI, це був оригінальний образ ...

О-о!

А для тих, хто цікавиться кодом, який використовується для створення цього зображення:

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

Градуювання кольору в цьому дійсно приємне. Я вважаю, що вихід із цього обчислюваного зображення, насправді, досить естетично. Я міг би досить легко використовувати це як шпалери для робочого столу. Молодці!
Бен Патон

Виглядає добре, але має деякі проблеми (1) не унікальні значення пікселів (легко перевіряється: ./a.out | hexdump | headпоказує 7d ff deповторення багато разів), (2) не використовує послідовних значень RGB від 000000thru 1dffff, і (3) пікселів при (x = 0, y = 0) - не чорний. (Хоча я і сам не бачу сенсу (3).)
кричуще осифраж

@squeamishossifrage Так, я вважав, що специфікації є занадто обмежуючими, і в той же час не дозволяють формати файлів з більш ніж 8 бітами на первинний або 4 канали на піксель, що, якщо я використовую 16 біт на первинну, гарантувала б унікальність. Оскільки це конкурс на популярність, я залишу його, можливо, він отримає голос або два ...

@squeamishossifrage Це не говорить про те, що вам потрібно перебирати від 0 до x1dffff, лише те, що він починається з чорного кольору і йде вгору до білого, але не як саме.
Сільвестер,

@Sylwester У ньому йдеться про те, що ви повинні рахувати послідовно , а наступне речення говорить, що ви знайдете зображення пікселів 1920 x 1080 пікселів, що містить лише багато чорних, блюзових та зелених . Який біт я неправильно зрозумів? (Крім отримання 0x1dffff неправильно, повинно бути 0x1fa3ff.)
гидливо грифа

8

Рубі, 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: Я мушу зазначити, що я подав це, коли питання все ще було позначене , перш ніж воно стало тому я збирався отримати короткий код. Це не дуже образно, але я вважаю, що це дійсне подання.

Значення кольорів варіюються від 00 00 00до 1f a3 ff, збільшуючись на 1, тому відсутність redрезультату не дивно.

вихід1

Для витрат на додавання 1 символу до довжини вихідного коду (заміни <<8на <<11) можливий наступний вихід. Це охоплює більше діапазону спектру за ціною blueроздільної здатності. Він збільшується через RGB-простір у вісім разів більше швидкості. Значення кольорів варіюються від 00 00 00до fd 1f f8.

введіть тут опис зображення


2
Ваш запис дійсно хороший. Ваше перше зображення виглядає так, як я його очікував. Молодці і спасибі за те, що поїхали Вражений, що ви зробили це так швидко і з таким маленьким кодом.
Бен Патон

7

Ракетка

Ніколи раніше не використовував об'єктно-орієнтоване програмування (передача повідомлень), тому я не впевнений, що це оптимально, але, здається, ця робота виконана.

#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 перших біта в червоному каналі, я отримую всі три кольори у своєму результативному зображенні.

Брейнфук

Код виводить 24-бітове зображення BMP в STDOUT для 8-бітових комірок BF-перекладачів. Це створює те саме зображення, що і версія Racket. Він заснований на версії pnm.

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

Ubuntu поставляється з bfцим має 8 бітових комірок:

bf img.bf > image.bmp

Стара версія, яка порушує можливість відкриття з Chrome. Це робить файл .pnm, сумісний з більшістю переглядачів зображень.

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

6

Оновлена, перша версія не мала всіх кольорів унікальних у 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


Ваше зображення містить лише 394 466 унікальних кольорів. Перетворіть ваші RGB-значення в 8-бітні цілі числа перед вирівнюванням, і ви побачите чому.
пискливе костіння

@squeamishossifrage оновлено.
shrx

6

Пітон - 104

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

Це версія, яка була б для виклику код-гольф. Оскільки воно лише збільшує значення від 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")

ще приємніше


i.show()можна використовувати для відкриття зображення в програмі перегляду за замовчуванням. Існує не сувора вимога, щоб воно було збережено у файл.
прим

добре. Це було, коли це було ще проблемою з кодовим гольфом. але дякую за підказку :)
Дейв Дж.

також .show()не працює для мене. Не знаю чому. : P
Дейв Дж.

5

Обробка, 301
Це не спроба найкращого рішення, але воно підтримує весь контроль для досягнення бажаного розташування кольорів. Так, кольори не є послідовними, але це не весело. uniqe.png

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

Для виклику піксель 0,0повинен бути RGB 0,0,0. Я бачу 31,31,31. Насправді цілий нульовий стовпець видається таким кольором.
Ізі

3

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 Мб:

putput.png

Код, наведений вище, - стислий варіант цього більш читабельного коду. Проміжки було видалено для збереження байтів.

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


2

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

Вихід2

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


1
Приємно, але кольори не унікальні. Спробуйте це: identify -format %k o.png. Я отримав 1762920, а НЕ 2073600
гидливо грифа

thnx. Ще одна точка - зображення не починається з RGB (0,0,0) у верхньому лівому куті. Робота над виправленням ...
CousinCocaine

@squeamishossifrage, дякую за команду Identify. Поправив це зараз.
CousinCocaine

1

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


Чи не підтверджує це вимога 2 073 600 унікальних кольорів, оскільки текст на час створення повністю чорний? Або це не рахується, оскільки технічно це накладка?
Іссі

Так, я думаю, я не думав про це. Коли я вперше задумався про це, я подумав, що було б весело мати шпалери розміру робочого столу з не двома пікселями одного кольору. Потім, коли я почав грати з кодом, який це робив, мене зацікавила швидкість генерування зображення. Я думаю, що дійсно ідеальне рішення також використовуватиме різні кольори пікселів для тексту, але, можливо, простіше сказати, що це не рахується, оскільки я не впевнений, що це буде легко читати.
Бен Патон

Я щойно помітив, що сказав "підтвердити", коли мав на увазі "порушувати". Ну добре. Ти отримав це.
Ізі

1

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.

1
Дякуємо, що подали альтернативне рішення delphi. Чи можете ви завантажувати приклад зображення із результату?
Бен Патон

0

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

кольори


0

Java 411 386 + 24 байти

Гольф

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

Безумовно

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

Результат

102.png

Пояснення

Це не моя спроба найкоротшого рішення, а, скоріше, найбільш портативна. Залишився імпорт лише для BufferedImage, оскільки інші не зберегли байти. Замість того, щоб завантажувати Зображення в JPanel і писати на ньому, я заощадив час, який потрібно від початку до запису на диск як ім'я файлу. Для мене це призвело до назви файлів приблизно ~ 110 мс, тоді як час від початку до кінця зазвичай займав ~ 500 мс. Нарешті, він повинен бути незалежним від платформи, як я тестував і в Windows, і в Ubuntu VM, і він працював (він записує файл на ваш робочий стіл). Повинен був мати висновок повернення через сміття синтаксису Callable. Хоча я працюю над вирішенням проблеми, я сумніваюся, що знайду кращу реалізацію самостійно завдяки економії від використання l і w для моїх циклів. Я б сказав, що півсекунди для 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

Але я вважаю, що вона все ще підтверджена, оскільки її все ще може відкрити хром, вона просто автоматично відкриється для перегляду вашої системи перегляду png за замовчуванням (версія не перевірена на машинах на базі Unix).

Мені відомо, що можливе збереження байтів, але в основному вони опустили їх для отримання бонусів. За запитом я можу завантажувати більш короткі, конкретні приклади платформи. Дякую.

Редагувати

Видалено непотрібне. Спробуйте блокувати Catch і неправильно відформатований оператор повернення, щоб зменшити ~ 30 байт.
Видалено, BufferedImage.TYPE_INT_RGBтому що це буквально лише 1.


Озираючись на це, я не думаю, що мені потрібен блок спробу лову, оскільки основний метод повинен кинути виняток, щоб лямбда, яка
дзвонила,
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.