Wygeneruj grafikę 1920 x 1080 z 2 073 600 niepowtarzalnymi kolorami


24

Wyzwanie:

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

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

Array (
[0] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 0
    )

[1] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 1
    )

[2] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 2
    )

[3] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 3
    )

[4] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 4
    )

[5] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 5
    )

[6] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 6
    )

[7] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 7
    )

[8] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 8
    )

[9] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 9
    )

[10] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 10
    )

[11] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 11
    )

[12] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 12
    )

[13] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 13
    )

[14] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 14
    )

[15] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 15
    )

[16] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 16
    )

[17] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 17
    )

[18] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 18
    )

[19] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 19
    )

[20] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 20
    )

[21] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 21
    )

[22] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 22
    )

[23] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 23
    )

[24] => Array
    (
        [0] => 0
        [1] => 0
        [2] => 24
    )

)

Zasady:

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

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

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

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

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

  • Obraz musi mieć rozmiar 1920 x 1080 pikseli.

  • Kolory muszą być w formacie RGB.

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

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

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

  • Rozmiar pliku obrazu wyjściowego nie ma znaczenia.

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

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


3
Jeśli jest to kod golfowy, w jaki sposób uwzględniane są bonusy? Bonus 10 znaków wydaje się bardzo mały dla kodu, który (skutecznie) przewiduje przyszłość.
Kendall Frey

1
Teraz nie ma żadnych wartości bonusowych! Jak mamy wziąć te bonusy? Ignoruj ​​ich?
Kendall Frey

3
Wybierz zwięzły język i zwięzłe API PNG (krytyczne!), A następnie policz do 2,073,600. Przykro mi, że jestem tak krytyczny, @BenPaton, ale przewiduję, że wybór języka i interfejsu API będzie tutaj najważniejszym czynnikiem, a nie przejawem sprytnego programowania. Ale często się mylę, a jeszcze rzadziej sprytny. :-)
Darren Stone

2
Wymóg dotyczący czarnego piksela w x==y==0wydaje się nieco dowolny. W każdym razie jest to niejednoznaczne, ponieważ współrzędne te mogą odnosić się do lewego górnego lub lewego dolnego rogu obrazu.
skrzypliwy ossifrage

3
Duplikat obrazów we wszystkich kolorach ; jedyną różnicą jest ograniczenie w palecie kolorów, aby były to tylko odcienie niebieskiego i zielonego, a nie wszystkie , co nie ma wielkiego znaczenia dla problemu, ale sprawia, że ​​wydruk jest mniej ładny.

Odpowiedzi:


40

Python - 660+ bajtów

Wersja przyrostowa

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

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


Wersja świetlistości

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

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


Źródło

Wymaga PIL .

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

from PIL import Image, ImageDraw

use_luminosity = True

dim = (1920,1080)

img = Image.new('RGB', dim)
draw = ImageDraw.Draw(img)

xstart = -.776707
ystart = -.134663

a = []

xd = 1.6 / 8192 / dim[0]
yd = 0.9 / 8192 / dim[1]

for x in range(dim[0]):
  print x
  for y in range(dim[1]):
    z = d = complex(xstart + x*xd, ystart + y*yd)
    c = 0
    while abs(z) < 2 and c < 5000:
      z = z*z + d
      c += 1
    a += [(c, -abs(z), x, y)]

a = a[1:]
a.sort(reverse = True)

t = [(i>>16, 255&i>>8, 255&i) for i in range(1, dim[0]*dim[1])]
if use_luminosity:
  t.sort(key = lambda c: c[0]*3 + c[1]*10 + c[2], reverse = True)

r = 0
for c,d,x,y in a:
  draw.point((x,y), t[r])
  r += 1

img.show()

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


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

PHP - 161 bajtów

<?header('Content-type: image/bmp');
ob_start();
echo'BM'.pack('I5S2',0,0,26,12,70780800,1,24);
for(;$i=($i-256)%2073601;)echo pack('CS',~$i,~$i>>8);
ob_end_flush();

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

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

Inne interesujące przyrosty obejmują:

17: http://i.stack.imgur.com/ieyyZ.png
103: http://i.stack.imgur.com/WD2wa.png
326: http://i.stack.imgur.com/c4DSF. png
557: http://i.stack.imgur.com/eTTWE.png
943: http://i.stack.imgur.com/7rrmR.png
2125: http://i.stack.imgur.com/Ct1kM .png

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


PHP - 105 bajtów

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

Lekkomyślnie lekceważy wersję.

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


PHP-CLI - 83 bajty

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

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


3
Bardzo podoba mi się ten wzór, bardzo trippy!
Ben Paton

Uwielbiam pierwszy obraz, ale wydaje się, że narusza zasadę, która wymaga, aby piksel 0,0 był RGB 0,0,0.
Iszi

@primo Wygląda mi teraz dobrze.
Iszi

1
Tak bardzo podoba mi się wersja świetlistości, że ustawiłem ją jako tapetę na pulpicie :)
Ben Paton

24

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

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

Miniatura 640 x 360 pikseli wyników testu

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

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

Powiększony widok lewego górnego rogu

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

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

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

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

$ identify -format %k outfile.png
2073600

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

Oto kod źródłowy:

#include <stdio.h>
#include <stdlib.h>
#include <gd.h>

#define FIRST_PIXEL_MUST_BE_BLACK 1

#define luminance(rgb) (((rgb>>16)&0xff)*77+((rgb>>8)&0xff)*150+(rgb&0xff)*29)

typedef struct { int lum; int rgb; } pal;      /* Colour palette */
typedef struct { int lum; int x; int y; } pix; /* Pixel list */

/* Callback function for qsort */
int pcomp(const void *a, const void *b) {
  return ((pal *)(a))->lum-((pal *)(b))->lum;
}

int main(int argv, char *argc[]) {
  FILE        *infile,*outfile;
  gdImagePtr  img;
  int         img_width;
  int         img_height;
  int         npixels;
  int         x,y,i;
  int         rgb,colour_ref,c;
  pal         *palette;
  pix         *pixels;

  if (argv!=3) return printf("Usage: %s <source> <destination>\n",argc[0]);

  if (!(infile=fopen(argc[1],"r"))) {
    return printf("Can't open source file <%s>\n",argc[1]);
  }
  if (!(img=gdImageCreateFromPng(infile))) {
    return printf("Bad PNG file <%s>\n",argc[1]);
  }
  fclose(infile);

  img_width=img->sx;
  img_height=img->sy;
  npixels = img_width * img_height;
  printf("File accepted; %dx%d pixels\n",img_width,img_height);

  /* Allocate storage for palette and pixel data */
  palette = malloc(npixels * sizeof(pal));
  if (!palette) return printf("Out of memory\n");
  pixels = malloc(npixels * sizeof(pix));
  if (!pixels) return printf("Out of memory\n");

  /* Create palette and sort by luminance */
  for (i=0; i<npixels; i++) {
    palette[i].rgb=i;
    palette[i].lum=luminance(i);
  }
  qsort(palette,npixels,sizeof(pal),pcomp);

  /* Sort image pixels by luminance */
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  colour_ref = gdImageColorAllocate(img,0,0,0);
  gdImageSetPixel(img,0,0,colour_ref);
#endif

  for (x=y=i=0;i<npixels;i++) {
    rgb = gdImageGetTrueColorPixel(img,x,y);
    pixels[i].x=x;
    pixels[i].y=y;
    pixels[i].lum=luminance(rgb);
    if (!(x=++x%img_width)) y++;
  }
#if FIRST_PIXEL_MUST_BE_BLACK == 1
  qsort(pixels+1,npixels-1,sizeof(pix),pcomp);
#else
  qsort(pixels,npixels,sizeof(pix),pcomp);
#endif

  /* Now use the palette to redraw all the pixels */
  for (i=0;i<npixels;i++) {
    c = palette[i].rgb;
    colour_ref = gdImageColorAllocate(img,c>>16,(c>>8)&0xff,c&0xff);
    gdImageSetPixel(img,pixels[i].x,pixels[i].y,colour_ref);
  }

  printf("Saving...\n");
  if (!(outfile=fopen(argc[2],"w"))) {
    return printf("Can't open <%s> for writing\n",argc[2]);
  }
  gdImagePng(img,outfile);
  fclose(outfile);
  gdImageDestroy(img);
  printf("Finished\n");
  return 0;
}

Woah, to niesamowite! : D +1 Również, 2.463 KB: P
Klamka

16

C ++, 750 bajtów

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

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

#include <windows.h>
#include <vector>
#include <algorithm>
#define X _complex
#define U int
#define S(j,g)std::sort(j.begin(),j.end(),g);
U w=1920,h=1080;
WORD q[27]={'MB',36918,126,0,0,54,0,40,0,w,0,h,0,1,32,0,0,36864,126};
#define V(a,b)((a>>b)&255)
#define L(z)V(z,16)*.3+V(z,8)*.6+V(z,0)*.1
#define F for(c=0;c<w*h;c++)
U C(U a,U b){return L(a)<L(b);}
U M(X a,X b){return a.x<b.x;}
U main(U c,char**v){
std::vector<U>l;
std::vector<X>D;
F l.push_back(c);
U*i=new U[c];
DWORD p;
F{float r=0,i=0,R;p=0;
for(;p<w&&r*r+i*i<4;p++){R=r*r-i*i;i=2*r*i+(c/w-h/2)/400.;r=R+(c%w-w/2)/400.;}
X d={-p-r*r-i*i,c};
D.push_back(d);}
S(l,C)
S(D,M)
F i[(U)D[c].y]=l[c];
void*f=CreateFileA(v[1],4<<28,0,0,2,0,0);
WriteFile(f,q,54,&p,0);
WriteFile(f,i,w*h*4,&p,0);}

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


11

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

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

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

Och!

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

#include <stdlib.h>
#include <stdio.h>

#define W 1920
#define H 1080

typedef struct {unsigned char r, g, b;} RGB;

int S1(const void *a, const void *b)
{
        const RGB *p = a, *q = b;
        int result = 0;

        if (!result)
                result = (p->b + p->g * 6 + p->r * 3) - (q->b + q->g * 6 + q->r * 3);

        return result;
}

int S2(const void *a, const void *b)
{
        const RGB *p = a, *q = b;
        int result = 0;

        if (!result)
                result = p->b - q->b;
        if (!result)
                result = p->g - q->g;
        if (!result)
                result = q->r - p->r;

        return result;
}

int main()
{
        int i, j, n;
        RGB *rgb = malloc(sizeof(RGB) * W * H);
        RGB c[H];

        for (i = 0; i < W * H; i++)
        {
                rgb[i].b = i & 0xff;
                rgb[i].g = (i >> 8) & 0xff;
                rgb[i].r = (i >> 16) & 0xff;
        }

        qsort(rgb, H * W, sizeof(RGB), S1);

        for (n = 0; n < 2; n++)
        {
                for (i = 0; i < W; i++)
                {
                        for (j = 0; j < H; j++)
                                c[j] = rgb[j * W + i];
                        qsort(c, H, sizeof(RGB), S2);
                        for (j = 0; j < H; j++)
                                rgb[j * W + i] = c[j];
                }

                for (i = 0; i < W * H; i += W)
                        qsort(rgb + i, W, sizeof(RGB), S1);
        }

        printf("P6 %d %d 255\n", W, H);
        fwrite(rgb, sizeof(RGB), W * H, stdout);

        free(rgb);

        return 0;
}

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

Och!

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

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

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

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

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

        return 0;
}

Podziałka kolorów w tym jest naprawdę fajna. Uważam, że dane wyjściowe z tego wygenerowanego obliczeniowo obrazu są naprawdę bardzo estetyczne. Mógłbym z łatwością użyć tego jako tapety na pulpit. Dobra robota!
Ben Paton

Wygląda ładnie, ale ma pewne problemy (1) zakaz unikalne wartości pikseli (łatwo sprawdzić: ./a.out | hexdump | headpokazy 7d ff depowtarzane wiele razy), (2) nie używać kolejnych wartości RGB z 000000thru 1dffff, oraz (3) piksel (x = 0, y = 0) nie jest czarne. (Chociaż sam nie widzę sensu (3).)
piskliwy ossifrage

@ squeamishossifrage Tak, myślałem, że specyfikacje były zbyt restrykcyjne, a jednocześnie nie zezwalały na formaty plików z więcej niż 8 bitami na podstawowy lub 4 kanałami na piksel, co, gdybym użył 16 bitów na podstawowy, gwarantowałoby wyjątkowość. Ponieważ jest to konkurs popularności, zostawię to, może dostanie głos lub dwa ...

@ squeamishossifrage Nie mówi, że musisz iterować od 0 do x1dffff, tylko że zaczyna się od czerni i idzie w górę w kierunku bieli, ale nie tak dokładnie.
Sylwester

@Sylwester Mówi, że powinieneś liczyć w sekwencji , a następne zdanie mówi, że znajdziesz obraz o rozdzielczości 1920 x 1080 pikseli, który będzie zawierał tylko dużo czerni, błękitów i zieleni . Którego fragmentu źle zrozumiałem? (Poza błędem 0x1dffff; powinno być 0x1fa3ff.)
ossifrage

8

Ruby, 109

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

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

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

wyjście 1

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

wprowadź opis zdjęcia tutaj


2
Twój wpis jest naprawdę dobry. Twoje pierwsze zdjęcie wygląda dokładnie tak, jak się spodziewałem. Dobra robota i dzięki za próbę. Pod wrażeniem, że zrobiłeś to tak szybko i przy tak małym kodzie.
Ben Paton

7

Rakieta

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

#lang racket
(require racket/draw)
(let* ((x 1920) (y 1080) (b 256) (bb (* b b)) (pic (make-object bitmap% x y)))
  (let loop ((c 0) (v 0))
    (when (> (* x y) c)
      (send pic set-argb-pixels (modulo c x)   ; x
                                (quotient c x) ; y
                                1              ; width
                                1              ; height
                                (list->bytes 
                                 (list 0                            ; alpha
                                       (modulo v b)                 ; red
                                       (quotient v bb)              ; green 
                                       (modulo (quotient v b) b)))) ; blue
      (loop (+ c 1) (+ v 8))))
  (send pic save-file "image.png" 'png))

Obraz w wielu kolorach

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

Brainfuck

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

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

Ubuntu bfzawiera 8-bitowe komórki:

bf img.bf > image.bmp

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

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

6

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

Mathematica: 110

x = 1920; y = 1080; Image[
 ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]]

unikalne kolory

Weryfikacja zasad:

list = ParallelTable[
  List @@ ColorConvert[Hue[h, 1, (b + h)/2], "RGB"], {h, 0, 1 - 1/y, 
   1/y}, {b, 0, 1 - 1/x, 1/x}]

Pierwszy piksel jest czarny:

list[[1, 1]]
{0., 0., 0.}

Wszystkie kolory są unikalne:

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

Mathematica: 146

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

zabarwienie

Trwa 14,778 sekund.

Weryfikacja zasad:

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

Pierwszy piksel jest czarny:

list[[1, 1]]
{0., 0., 0.}

Wszystkie kolory są unikalne:

Length[DeleteDuplicates[Flatten[list, 1]]] == 1920*1080
True


Twój obraz ma tylko 394,460 unikalnych kolorów. Przed spłaszczeniem przekonwertuj wartości RGB na 8-bitowe liczby całkowite, a zobaczysz dlaczego.
piskliwy kostnica

Zaktualizowano @squeamishossifrage.
shrx

6

Python - 104

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

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

krótka wersja

Python - 110

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

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

wersja rozszerzona, ale lepiej wyglądająca

Python - 122

Kolejne rozszerzenie powyższego:

from PIL import Image
a=[(i<<3,i)[i%2]for i in range(2073600)]
i=Image.new("RGB",(1920,1080))
i.putdata(a)
i.save("o.png")

jeszcze ładniej


i.show()można użyć do otwarcia obrazu w domyślnej przeglądarce. Nie ma ścisłego wymogu zapisania go w pliku.
primo

dobrze. było, kiedy było to jeszcze wyzwanie w golfa. ale dzięki za podpowiedź :)
Dave J

też .show()nie działa dla mnie. Nie wiem dlaczego. : P
Dave J

5

Przetwarzanie, 301
Nie jest to próba najbardziej zwięzłego rozwiązania, ale zachowuje on pełną kontrolę, aby osiągnąć pożądany układ kolorów. Tak, kolory nie są następujące po sobie, ale to nie jest zabawne. 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");
}

Wyzwanie wymaga, 0,0aby piksel był RGB 0,0,0. Widzę 31,31,31. W rzeczywistości cała kolumna zero wydaje się mieć ten kolor.
Iszi

3

Visual Basic .NET, 273 bajty

Imports System.Drawing : Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080) : For i As Integer = 0 To 2073599 : Dim x = 0 : b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000)) : Next : b.Save("output.png")
    End Sub
End Module

To daje plik 5,61 MB:

putput.png

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

Imports System.Drawing
Module Module1
    Sub Main()
        Dim b As New Bitmap(1920, 1080)
        For i As Integer = 0 To 2073599
            Dim x = 0
            b.SetPixel(Math.DivRem(i, 1080, x), x, Color.FromArgb(i + &HFF000000))
        Next
        b.Save("output.png")
    End Sub
End Module

Link do obrazu: http: //µ.pw/k


2

ImageMagick - Konwertuj 119

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

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

Wyjście 2

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


1
To miłe, ale kolory nie są wyjątkowe. Spróbuj tego: identify -format %k o.png. Mam 1762920, a nie 2073600
ossifrage

dzięki. innym punktem jest to, że obraz nie zaczyna się od RGB (0,0,0) w lewym górnym rogu. Praca nad poprawką ...
CousinCocaine

@ squeamishossifrage, dzięki za komendę identyfikacji. Naprawiłem to teraz.
CousinCocaine

1

PHP, 507

Obraz wyniku

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

$a=microtime(true);$c=1920;$d=1080;$e=$c*$d;$f=@imagecreatetruecolor($c,$d);$h=255;$j=2200000;$k=array();$l=1;for($m=0;$m<=$h;$m++){for($n=0;$n<=$h;$n++){for($o=0;$o<=$h;$o++){if($l<=$j){$k[]=array($m,$n,$o);$l++;}else{break;}}}}while($p<=$e){for($q=0;$q<=$c;$q++){for($s=0;$s<=$d;$s++){$t=imagecolorallocate($f,$k[$p][0],$k[$p][1],$k[$p][2]);imagesetpixel($f,$q,$s,$t);$p++;}}}$u=number_format((microtime(true)-$a),4).' seconds';imagestring($f,6,10,10,$u,$v);header('Content-Type: image/png');imagepng($f);

Link do obrazu wyjściowego: http://i.stack.imgur.com/AAKqW.png

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


Czy to nie potwierdza wymogu 2 073 600 niepowtarzalnych kolorów, ponieważ tekst na czas generowania jest cały czarny? Czy to się nie liczy, ponieważ technicznie jest to nakładka?
Iszi

Tak, chyba nie myślałem o tym. Kiedy po raz pierwszy pomyślałem o tym, pomyślałem, że fajnie byłoby mieć tapetę w rozmiarze pulpitu bez dwóch pikseli tego samego koloru. Potem, kiedy zacząłem bawić się kodem, który to zrobił, zainteresowałem się prędkością generowanego obrazu. Podejrzewam, że naprawdę idealne rozwiązanie wykorzystałoby również różne kolorowe piksele dla tekstu, ale może łatwiej powiedzieć, że się nie liczy, ponieważ nie jestem pewien, czy byłby łatwy do odczytania.
Ben Paton

Właśnie zauważyłem, że powiedziałem „zatwierdź”, kiedy miałem na myśli „naruszać”. No cóż. Masz to.
Iszi

1

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

program P;
{$APPTYPE CONSOLE}
uses
  System.SysUtils, Vcl.Imaging.pngimage,System.UITypes;
var a : TPNGObject; h,w: Integer; c : TColor;
begin
   a :=TPNGObject.CreateBlank(COLOR_RGB, 16, 1920, 1080);
   for h := 0 to 1020 do
     for w := 0 to 1920 do
         begin
         a.Pixels[h,w]:= c ;
         inc(c);
         end;
   a.SaveToFile('e:\t.png');
end.

1
Dziękujemy za przesłanie alternatywnego rozwiązania delphi. Czy możesz załadować przykładowy obraz z wyjścia?
Ben Paton

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

zabarwienie


0

Java 411 386 + 24 bajty

Grał w golfa

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

Bez golfa

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

Wynik

102.png

Wyjaśnienie

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

 (System.getProperty("os.name").toLowerCase().contains("win")) { try { Process
 * p = Runtime.getRuntime() .exec(new String[] { "cmd", "/c", "start chrome " +
 * f }); p.waitFor(); } catch (Exception e) { } } else if
 * (System.getProperty("os.name").toLowerCase().contains("ix")) { try { Process
 * p = Runtime.getRuntime().exec(new String[] { "google-chrome" + f }); } catch

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

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

Edytować

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


Patrząc wstecz na to, nie sądzę, że potrzebuję blokowania
próbnego,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.