2,073,600 अद्वितीय रंगों के साथ 1920 x 1080 ग्राफिक उत्पन्न करें

24

चुनौती:

एक प्रोग्राम लिखें जो 1080 पिक्सलों की चौड़ाई वाली एक ग्राफिक फ़ाइल 1920 पिक्सल्स को हाई आउटपुट करता है। ग्राफिक के भीतर 2,073,600 पिक्सेल में से प्रत्येक को एक अद्वितीय रंग होना चाहिए और कोई भी रंग मान दोहराया नहीं जाना चाहिए। आरजीबी में रंगों को निर्दिष्ट किया जाना चाहिए और 0,0,0 पर शुरू करना चाहिए और 255,255,255 के क्रम में ऊपर की ओर गिनना चाहिए। आपको एक 1920 x 1080 पिक्सेल की छवि मिलेगी जिसमें बहुत सारे कालों, ब्लूज़ और ग्रीन्स होंगे।

उदाहरण के लिए, (एक छोटा कट संस्करण)। यदि ऊँचाई 5 पर सेट की जाती है और चौड़ाई 5 से 25 पिक्सेल वर्ग पर सेट की जाती है, तो ग्राफिक आउटपुट होगा और प्रत्येक पिक्सेल एक अनूठा रंग होगा। आरजीबी रंग सरणी इस तरह दिखेगा:

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
    )

)

नियम:

  • किसी भी प्रोग्रामिंग भाषा का उपयोग छवि उत्पन्न करने के लिए किया जा सकता है।

  • सबसे upvotes के साथ जवाब जीतता है।

  • रंगों का उपयोग केवल एक बार किया जाना चाहिए।

  • 0,0 स्थिति में पिक्सेल रंग 0,0,0 के साथ शुरू होना चाहिए

  • रंगों को असली रंग 24 बिट सीमा के भीतर गिरना चाहिए।

  • छवि का आकार 1920 x 1080 पिक्सेल होना चाहिए।

  • रंग आरजीबी प्रारूप में होने चाहिए।

  • छवि को आउटपुट करने के लिए लाइब्रेरी का उपयोग करना ठीक है।

  • आउटपुट एक ग्राफिक फ़ाइल के प्रारूप में होना चाहिए जैसे कि output.png

  • पाठ के रूप में आउटपुट जो रंग मानों का प्रतिनिधित्व नहीं करता है, कोड को एक ग्राफिक फ़ाइल का उत्पादन करना चाहिए।

  • आउटपुट छवि का फ़ाइल आकार मायने नहीं रखता है।

  • क्रोम वेब ब्राउज़र में इसे ग्राफिक के रूप में खोलकर आउटपुट देखने में सक्षम होना चाहिए।

यदि आप वास्तव में छोटे कोड के साथ ऐसा करने के लिए मांग करते हैं, तो मैं प्रभावित होऊंगा, आपका कार्यक्रम भी समय के साथ छवि में उत्पन्न छवि को उत्पन्न करने के लिए लिया गया समय पैदा करता है जो कि अनुक्रमिक पिक्सल पर छवि के भीतर एम्बेडेड है, आपका कार्यक्रम 10 सेकंड के भीतर छवि को आउटपुट करता है। अगर आपका प्रोग्राम 1 सेकंड के भीतर इमेज आउटपुट करता है तो मैं वास्तव में प्रभावित होऊंगा।

popularity-contest  graphical-output 
— बेन पाटन
स्रोत
3
यदि यह कोड गोल्फ है, तो बोनस फैक्टर कैसे होता है? एक 10-वर्ण बोनस कोड के लिए बहुत छोटा लगता है जो भविष्य को प्रभावी ढंग से भविष्यवाणी करता है।
— केंडल फ्रे
1
अब कोई बोनस मान नहीं हैं! हमें उन बोनस को कैसे लेना चाहिए? उन पर ध्यान न दें?
— केंडल फ्रे
3
एक भाषा चुनें और PNG API (क्रिटिकल!) का चयन करें और फिर 2,073,600 तक गिनें। इतना महत्वपूर्ण होने के लिए क्षमा करें, @BenPaton, लेकिन मुझे लगता है कि भाषा की पसंद और एपीआई यहां सबसे बड़ा कारक होगा, न कि चतुर प्रोग्रामिंग का प्रदर्शन। लेकिन मैं अक्सर गलत हूं और बहुत कम बार चालाक हूं। :-)
— डैरेन स्टोन
2
एक काले पिक्सेल के लिए आवश्यकता x==y==0थोड़ी मनमानी लगती है। किसी भी मामले में, यह अस्पष्ट है क्योंकि ये निर्देशांक छवि के ऊपरी बाएँ या निचले बाएँ कोने को संदर्भित कर सकते हैं।
— स्क्विश ओश्रीफ्रेज
3
सभी रंगों के साथ छवियों का डुप्लिकेट ; केवल अंतर केवल सभी के बजाय ब्लूज़ और ग्रीन्स होने के लिए रंग पैलेट में सीमा है , जो समस्या का बहुत बड़ा अंतर नहीं करता है लेकिन आउटपुट को कम सुंदर बनाता है।

जवाबों:

40

पायथन - 660+ बाइट्स

वृद्धिशील संस्करण

पूर्ण आकार: http://www.pictureshack.net/images/57626_all_colors.png (4.52 एमबी)

यह एक जूलिया सेट भग्न पर आधारित छवि है । प्रत्येक रंग को छवि में वृद्धिशील रूप से जोड़ा जाता है, हालांकि इसमें पूर्व-गणना की पर्याप्त मात्रा होती है।

चमकदार संस्करण

पूर्ण आकार: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

मैंने इंडेक्स के बजाय चमकदारता से प्रत्येक रंग को पुनरावृत्त करने के लिए एक विकल्प जोड़ा है। यह शून्य से "काउंटिंग अप" के रूप में योग्य नहीं है, लेकिन यह एक शिथिल आवश्यकता प्रतीत होती है। यह दिलचस्प है कि ये दो आदेश छवि में पूरी तरह से अलग संरचनाओं को उजागर करते हैं। इसका उपयोग करने के लिए, use_luminosityध्वज को सेट करें True।

स्रोत

पीआईएल की आवश्यकता है ।

सावधान रहें : इसे निष्पादित करने में कई मिनट लगेंगे। का उपयोग करते हुए PyPy साथ तकिया के बारे में पांचवां जनहित याचिका के साथ CPython के समय में चलता है, तो मुझे लगता है कि सिफारिश करेंगे, यदि संभव हो तो।

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

यह सबसे तेज़ आउटपुट के लिए संभव है। किसी भी पुस्तकालय का उपयोग नहीं किया जाता है, सिर्फ एक पूर्व-गणना हेडर, और प्रत्यक्ष बाइट आउटपुट। मेरे COMP पर 2s से कम में चलता है। 1 के बजाय 256 से बढ़ाकर , यह एक छद्म-ढाल प्रभाव पैदा करता है, जिसमें वास्तविक गणना की आवश्यकता नहीं होती है। एकमात्र पतन यह है कि ( 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/tt1kM .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हेडर को देखते हुए , क्रोम यह पता लगाने की पूरी कोशिश करेगा कि उसे क्या भेजा गया था। इस मामले में, यह सही रूप में इसकी पहचान करता है image/bmp। फ़ायरफ़ॉक्स और 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 बाइट संस्करण के समान है, और इसे क्रोम में देखा जा सकता है।

— Primo
स्रोत
3
मुझे वास्तव में पैटर्न बहुत पसंद आया है!
— बेन पैटन
मुझे पहली छवि पसंद है, लेकिन यह उस नियम का उल्लंघन करता प्रतीत होता है जो पिक्सेल 0,0 को RGB 0,0,0 कहता है।
— इज़्ज़ी
@primo मुझे अब अच्छा लग रहा है।
— इस्तिज
1
मुझे चमकदार संस्करण बहुत पसंद है मैंने इसे अपने डेस्कटॉप वॉलपेपर के रूप में सेट किया है :)
— बेन पैटन
24

सी के साथ जीडी ग्राफिक्स लाइब्रेरी (इरेटा, लगभग 2.5 केबी?)

नियमों ने एक मौजूदा छवि को संशोधित करने पर रोक नहीं लगाई। मैं से अनुक्रमिक आरजीबी मूल्यों के साथ एक छवि के पिक्सल के सभी को बदलने के लिए एक कार्यक्रम बनाया #000000करने के लिए #1fa3ff, और मैं काफी परिणामों से प्रसन्न हूँ। माइकल कारियन ( 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;
}
— बग़ल में ossifrage
स्रोत
वाह, यह अद्भुत है! : डी +1 इसके अलावा, 2.463 KB: पी
— दरवाज़े
16

सी ++, 750 बाइट्स

मैंडलब्रॉट सेट पूर्ण संकल्प PNG (5.1MB)

कोड 0-1080 * 1920 से सभी पूर्णांकों का एक संग्रह बनाता है, फिर उन्हें समग्र चमक द्वारा क्रमबद्ध करता है। यह तब एक मेन्डेलब्रोट सेट बनाता है, और उनके भागने के पुनरावृत्ति और मूल्य के आधार पर पदों को सॉर्ट करता है। फिर यह दोनों सेटों के माध्यम से चलता है, मंडेलब्रोट मूल्यों के लिए अंधेरे से उज्ज्वल से लेकर सबसे बड़े तक रंगों को असाइन करता है। अंत में, यह कमांड लाइन पैरामीटर के रूप में निर्दिष्ट आउटपुट फ़ाइलनाम के लिए प्रति पिक्सेल 32 बिट प्रति पिक्सेल बीएमपी छवि लिखता है।

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

कोड पूरी तरह से गोल्फ नहीं है, लेकिन यह बहुत छोटा होने वाला नहीं है।

— Sir_Lagsalot
स्रोत
11

सी - 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) 000000थ्रू से क्रमिक आरजीबी मूल्यों का उपयोग नहीं करता है 1dffff, और (3) पिक्सेल पर (x = 0,) y = 0) काला नहीं है। (हालांकि, मैं (3) खुद की बात नहीं देख सकता।)
— चौदह साल का
@squeamishossifrage हाँ, मैंने सोचा था कि चश्मा अत्यधिक प्रतिबंधात्मक थे और एक ही समय में 8 बिट प्रति प्राइमरी या 4 चैनल प्रति पिक्सेल के साथ फ़ाइल स्वरूपों के लिए अनुमति नहीं दी थी, अगर मैं 16 बिट प्रति प्राइमरी का उपयोग करता था, तो विशिष्टता की गारंटी होगी। चूंकि यह एक लोकप्रियता की प्रतियोगिता है, इसलिए मैं इसे छोड़ दूंगा, हो सकता है कि इसे एक या दो वोट
@squeamishossifrage यह नहीं कहता कि आपको 0 से X1dffff तक पुनरावृत्त करने की आवश्यकता है, केवल यह कि यह काले रंग से शुरू होता है और सफेद की तरफ ऊपर जाता है, लेकिन बिल्कुल नहीं।
— सिल्वेस्टर २५'१४ को ०:१
@ सिलवेस्टर यह कहता है कि आप अनुक्रम में गिनती करने वाले हैं , और अगला वाक्य कहता है कि आपको 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

संपादित करें: मुझे ध्यान देना चाहिए कि मैंने इसे तब जमा किया था जब प्रश्न को अभी भी कोड-गोल्फ टैग किया गया था , इससे पहले कि यह एक लोकप्रियता-प्रतियोगिता बन जाए इसलिए मैं लघु कोड के लिए जा रहा था। यह बहुत कल्पनाशील नहीं है, लेकिन मेरा मानना ​​है कि इसे एक वैध प्रस्तुत करना है।

रंग मूल्यों से 00 00 00लेकर 1f a3 ff, वृद्धिशीलता तक है 1, इसलिए redपरिणाम की कमी आश्चर्यजनक नहीं है।

output1

स्रोत कोड की लंबाई (बदलें ) के <<8साथ 1 वर्ण जोड़ने की लागत के लिए <<11, निम्न आउटपुट हो सकता है। यह blueसंकल्प की लागत पर स्पेक्ट्रम की अधिक रेंज को कवर करता है । यह आरजीबी अंतरिक्ष के माध्यम से आठ गुना की दर से वृद्धि करता है। रंग मान से 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 पहले बिट्स का उपयोग नहीं करने से मुझे अपनी परिणाम छवि में सभी तीन रंग मिलते हैं।

Brainfuck

कोड 8 बिट सेल BF दुभाषियों के लिए STDOUT में एक 24 बिट बीएमपी छवि प्रिंट करता है। यह रैकेट संस्करण के समान छवि बनाता है। यह pnm संस्करण पर आधारित है।

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

साथ उबंटू जहाजों bfकि 8 बिट कोशिकाएं होती हैं:

bf img.bf > image.bmp

पुराना संस्करण जो उल्लंघन करता है वह क्रोम से खुलने में सक्षम है। यह एक .pnm फ़ाइल बनाता है जो अधिकांश छवि दर्शकों के साथ संगत होती है।

>------>+++++>+++++>++>------>>-------->>+>------>>++>------->+>--
---->++++++>>>++++[-<++++>]<[-<+++++<+++<+<+++<++++<+++<+++<+<+++<
+++<++++<+++<+<+++<+++<+++<+>>>>>>>>>>>>>>>>>]<[.[-]<]+[>>>>+<.<<.
>.>++++++++[>-]>[<<+[>>-]>>[<<<+[>>>-]>>>[<<<<->>>>>>>]<]<]<<<<<]
— Sylwester
स्रोत
6

अपडेट किया गया, पहले संस्करण में 24-बिट स्पेस में सभी रंग अद्वितीय नहीं थे:

गणित: ११०

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

गणित: १४६

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

— shrx
स्रोत
आपकी छवि में केवल 394,460 अद्वितीय रंग हैं। समतल करने से पहले अपने RGB मानों को 8-बिट पूर्णांक में बदलें और आप देखेंगे कि क्यों।
— स्क्विश ossifrage
@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()डिफ़ॉल्ट दर्शक में छवि को खोलने के लिए इस्तेमाल किया जा सकता है। कोई सख्त आवश्यकता नहीं है कि इसे किसी फ़ाइल में सहेजा जाए।
— Primo
कुंआ। यह तब था, जब यह अभी भी एक कोड-गोल्फ चुनौती थी। लेकिन संकेत के लिए धन्यवाद :)
— डेव जे
.show()मेरे लिए भी काम नहीं करता है। पता नहीं क्यों। : पी
— डेव जे
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

— bilde2910
स्रोत
2

ImageMagick - 119 कन्वर्ट

convertछवियाँ बनाने के लिए ImageMagick टूलबॉक्स से उपयोग करें । यह 0 सेकंड में चलता है। यह 119 वर्णों का है। मैं दो ग्रेडिएंट्स (लाल-नीले और काले-सफेद) को ओवरले करता हूं और उन्हें एचएसएल और आरजीबी में वापस कन्वर्ट करता हूं।

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

Output2

ग्रेडिएंट ओवरले के उदाहरण ImageMagick मैनुअल पेजों में मिल सकते हैं ।

— CousinCocaine
स्रोत
1
यह अच्छा है, लेकिन रंग अद्वितीय नहीं हैं। इस प्रयास करें: identify -format %k o.png। मुझे 1762920 मिला, 2073600 नहीं
— स्क्वीश ओस्फीराज
thnx। एक अन्य बिंदु यह है कि छवि आरजीबी (0,0,0) से शुरू नहीं होती है। एक फिक्स पर काम कर रहे हैं ...
— 21
@squeamishossifrage, पहचान आदेश के लिए धन्यवाद। अब तय हो गया।
— कज़िनकोकेन
1

PHP, 507

आउटपुट की छवि

आपको संभवतः चलाने के लिए PHP में आवंटित मेमोरी की मात्रा को बढ़ाने की आवश्यकता होगी। जीडी का उपयोग करता है। छवि बनाने के लिए लगभग 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&&=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
वैकल्पिक डेल्फी समाधान प्रस्तुत करने के लिए धन्यवाद। क्या आप आउटपुट के रूप में एक उदाहरण छवि अपलोड कर सकते हैं?
— बेन पैटन
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

रंग की

— sergiol
स्रोत
0

जावा 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);
        }
    }

परिणाम

102.png

व्याख्या

यह कम से कम समाधान पर मेरा प्रयास नहीं है, बल्कि सबसे पोर्टेबल है। केवल बफ़रेडइमेज के लिए आयात छोड़ दिया क्योंकि दूसरे ने बाइट्स को नहीं बचाया। छवि को JPanel में लोड करने और उस पर लिखने के बजाय, मैंने उस समय को सहेजने से बचाया जब तक कि वह फ़ाइल नाम के रूप में डिस्क पर लिखना शुरू न कर दे। मेरे लिए, इसमें लगभग ~ 110 मि। के फ़ाइल नाम थे, जबकि शुरुआत से लेकर अंत तक का समय आमतौर पर ~ 500ms होता था। अंत में, यह प्लेटफ़ॉर्म स्वतंत्र होना चाहिए क्योंकि मैंने विंडोज और एक उबंटू वीएम दोनों में परीक्षण किया था और यह काम किया (यह आपके डेस्कटॉप पर फ़ाइल लिखता है)। कॉल करने योग्य वाक्यविन्यास कचरे के कारण रिटर्न स्टेटमेंट देना पड़ता था। यद्यपि मैं चारों ओर काम कर रहा हूं, मुझे संदेह है कि मैं अपने उपयोग के लिए एल और डब्ल्यू के लिए लूप से बचाने के कारण अपने आप ही बेहतर कार्यान्वयन पाऊंगा। मैं कहूँगा कि जावा के लिए आधा सेकंड भी बुरा नहीं है।

 (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

लेकिन मेरा मानना ​​है कि यह अभी भी मान्य है क्योंकि यह अभी भी क्रोम द्वारा खोला जा सकता है, यह बस आपके डिफ़ॉल्ट पीएनजी दर्शक (यूनिक्स आधारित मशीनों पर परीक्षण नहीं किया गया संस्करण) के लिए खुलता है।

मुझे पता है कि बाइट संभव है, लेकिन मुख्य रूप से बोनस के लिए अर्हता प्राप्त करने के लिए उन्हें छोड़ दिया गया है। यदि अनुरोध किया जाए तो मैं छोटे, प्लेटफ़ॉर्म विशिष्ट उदाहरण अपलोड कर सकता हूं। धन्यवाद।

संपादित करें

हटाए गए अनावश्यक प्रयास करें ~ 30 बाइट्स को कम करने के लिए ब्लॉक और बीमार स्वरूपित रिटर्न स्टेटमेंट को पकड़ो।
हटा दिया BufferedImage.TYPE_INT_RGBक्योंकि यह शाब्दिक रूप से सिर्फ 1 है।

— jfh
स्रोत
इस पर पीछे देखते हुए मुझे नहीं लगता कि मुझे कोशिश करने वाले ब्लॉक को पकड़ने की जरूरत है क्योंकि मुख्य विधि में काम करने के लिए एक योग्य लैम्ब्डा के लिए एक अपवाद फेंकना है ...
— jfh
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.