24

চ্যালেঞ্জ:

এমন একটি প্রোগ্রাম লিখুন যা 1920 পিক্সেল প্রশস্ত 1080 পিক্সেল উচ্চতার কোনও গ্রাফিক ফাইলকে আউটপুট করে। গ্রাফিকের মধ্যে 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 পিক্সেলের আকারের হবে।
রঙগুলি অবশ্যই আরজিবি ফর্ম্যাটে থাকতে হবে।
চিত্রটি আউটপুট করতে একটি লাইব্রেরি ব্যবহার করা ঠিক আছে।
আউটপুট অবশ্যই কোনও গ্রাফিক ফাইলের ফর্ম্যাটে থাকতে হবে যেমন আউটপুট.পিএনজি
পাঠ্য হিসাবে আউটপুট যা বর্ণের মানগুলি গণনা করে না, কোডটি অবশ্যই একটি গ্রাফিক ফাইল আউটপুট দেয়।
আউটপুট চিত্রের ফাইল আকার কোনও বিষয় নয়।
আপনাকে অবশ্যই ক্রোম ওয়েব ব্রাউজারে গ্রাফিক হিসাবে খোলার মাধ্যমে আউটপুটটি দেখতে সক্ষম হতে হবে।

আমি যদি আপনি সত্যিই সংক্ষিপ্ত কোড দিয়ে এটি পরিচালনা করেন তবে মুগ্ধ হব, আপনার প্রোগ্রামটি অনুক্রমিক পিক্সেলগুলিতে চিত্রের মধ্যে overেকে থাকা চিত্রটি নিজের মধ্যে এমবেড করা সময় ব্যয় হওয়া সেকেন্ডেও সময় দেয়, আপনার প্রোগ্রামটি 10 সেকেন্ডের মধ্যে চিত্রটিকে ছাড়িয়ে যায়। আপনার প্রোগ্রামটি যদি 1 সেকেন্ডের মধ্যে চিত্রটিকে আউটপুট করে দেয় তবে আমি সত্যিই মুগ্ধ হব।

popularity-contest graphical-output

— বেন প্যাটন
সূত্র

3

এটি যদি কোড গল্ফ হয় তবে কীভাবে বোনাস ফ্যাক্টর হবে? কোডের জন্য একটি 10-অক্ষরের বোনাস খুব ছোট মনে হয় যা (কার্যকরভাবে) ভবিষ্যতের ভবিষ্যদ্বাণী করে।

— কেন্ডল ফ্রে

1

এখন কোন বোনাস মান আছে! আমাদের কীভাবে এই বোনাস নেওয়ার কথা? তাদের উপেক্ষা?

— কেন্ডল ফ্রে

3

একটি সংক্ষিপ্ত ভাষা চয়ন করুন এবং পিএনজি এপিআই (সমালোচনা!) এবং তারপরে 2,073,600 গণনা করুন। খুব সমালোচিত হওয়ার জন্য দুঃখিত, @ বেনপ্যাটন, তবে আমি পূর্বাভাস দিচ্ছি যে ভাষা এবং এপিআইয়ের পছন্দটি এখানে সবচেয়ে বড় ফ্যাক্টর হবে, চতুর প্রোগ্রামিংয়ের প্রদর্শন নয়। তবে আমি প্রায়শই ভুল এবং এমনকি প্রায়শই চালাক। :-)

— ড্যারেন স্টোন

2

একটি কালো পিক্সেলের জন্য প্রয়োজনীয়তা x==y==0কিছুটা স্বেচ্ছাচারী বলে মনে হচ্ছে। যাইহোক, এটি অস্পষ্ট কারণ এই স্থানাঙ্কগুলি চিত্রের উপরের বাম বা নীচে বাম কোণকে উল্লেখ করতে পারে।

— চটজলদি ossifrage

3

সমস্ত রঙ সহ চিত্রগুলির সদৃশ ; কেবলমাত্র পার্থক্য হ'ল রঙ প্যালেটে সীমাবদ্ধতা কেবল তাদের সকলের চেয়ে ব্লুজ এবং সবুজ , যা সমস্যার ক্ষেত্রে বিশাল পার্থক্য করে না তবে আউটপুটটিকে কম সুন্দর করে তোলে।

40

পাইথন - 660+ বাইট

বর্ধিত সংস্করণ

পূর্ণ আকার: http://www.pictureshack.net/images/57626_all_colors.png (4.52MB)

এটি জুলিয়া সেট ফ্র্যাক্টাল ভিত্তিক একটি চিত্র । প্রাক-গণনার প্রচুর পরিমাণে থাকা সত্ত্বেও প্রতিটি রঙ চিত্রের ক্রমবর্ধমানভাবে যুক্ত হয়।

আলোকিত সংস্করণ

পূর্ণ আকার: http://www.pictureshack.net/images/95389_all_colors4.png (5.24MB)

আমি প্রতিটি বর্ণকে আলোকিত করে ইন্ডেক্সের পরিবর্তে পুনরাবৃত্তি করার একটি বিকল্প যুক্ত করেছি। এটি শূন্য থেকে "গণনা" হিসাবে যোগ্যতা অর্জন করে না তবে এটি একটি স্বল্প প্রয়োজন বলে মনে হচ্ছে। এটি আকর্ষণীয় যে এই দুটি ক্রম ইমেজটিতে সম্পূর্ণ আলাদা কাঠামো প্রকাশ করে। এটি ব্যবহার করতে, use_luminosityপতাকাটি এতে সেট করুন True।

সূত্র

পিআইএল প্রয়োজন ।

সতর্কতা অবলম্বন করুন : এটি কার্যকর করতে কয়েক মিনিট সময় নেবে। বালিশ সহ পাইপাই ব্যবহার করা পিআইএল-এর সাথে সিপিথনের সময় প্রায় এক পঞ্চমাংশে চলে, সুতরাং আমি যদি এটি সম্ভব হয় তবে আমি প্রস্তাব দিই।

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উল্লিখিত হিসাবে উপরের বাম দিকে হয়।
সম্পাদনা : আলোকিত করে রঙ পুনরাবৃত্ত করতে একটি পতাকা যুক্ত করেছে।
সম্পাদনা করুন : স্থানীয় জটিল গণনাগুলিতে স্যুইচ করা হয়েছে এবং সামান্য দ্রুত গতি সম্পন্ন লাইটোমোসিটি ওজন।

প্রাথমিক মানদণ্ডটি জনপ্রিয়তা-প্রতিযোগিতায় পরিণত হওয়ার আগে আমি সমাধানগুলিতে কাজ করেছি

পিএইচপি - 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 সেরও কম সময়ে চলে। 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। পিএনজি
557: http://i.stack.imgur.com/eTTWE.png
943: http://i.stack.imgur.com/7rrmR.png
2125: http://i.stack.imgur.com/Ct1kM .png

এবং আরও অনেক কিছু. যদিও, বেশিরভাগ নিদর্শন যা দেখতে কিছুটা ধরণের স্ট্রিপের অনুরূপ

পিএইচপি - 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। ফায়ারফক্স এবং আইই এর সর্বশেষতম সংস্করণগুলিও ভাঙা শিরোনামটি ঠিক করতে সক্ষম।
খালি শব্দগুলি BM, I5S2এবং CSএকটি NOTICEত্রুটি তৈরি করবে । চিত্রের দুর্নীতি রোধ করতে, ত্রুটি প্রতিবেদনকরণ এটির php.ini(যেমন error_reporting = E_ALL & ~E_NOTICE) প্রতিরোধ করার জন্য সেট করা দরকার ।
কোনও আউটপুট বাফারিং নেই। চিত্রটি একবারে 3 বাইট নির্মিত হয়, যা লক্ষণীয়ভাবে ধীর।
বিন্দু ( 0, 0 ) উপরের বামের চেয়ে নীচে বাম হিসাবে বিবেচিত হয়।

পিএইচপি-সিএলআই - 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 কে আরজিবি 0,0,0 হতে বলে।

— ইসজি

@ প্রিয়মো এখন আমার কাছে বেশ ভাল লাগছে।

— ইসজি

1

আমি আলোকিত সংস্করণটি এত পছন্দ করি যে আমি এটি আমার ডেস্কটপ ওয়ালপেপার হিসাবে সেট করেছি :)

— বেন প্যাটন

24

জিডি গ্রাফিক্স গ্রন্থাগার সহ সি (ভুল, প্রায় 2.5 কেবি?)

বিধিগুলি বিদ্যমান চিত্রটি সংশোধন করতে নিষেধ করে না। আমি থেকে অনুক্রমিক আরজিবি মান কোনো চিত্রের পিক্সেল সমস্ত প্রতিস্থাপন জন্য একটি প্রোগ্রাম তৈরি #000000করার জন্য #1fa3ff, এবং আমি বেশ ফলাফল সঙ্গে সন্তুষ্ট নই। মাইকেল ক্যারিয়ান ( সিসি-বাই-সা ২.০ ) দ্বারা ফ্লিকারে পোস্ট করা কোনও ফটো থেকে এটি যা তৈরি করেছে তা এখানে :

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এটি একটি চিত্রম্যাগিক ইউটিলিটি; -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 কিলোবাইট: পি

— Doorknob

16

সি ++, 750 বাইট

ম্যান্ডেলব্রোট সেট একটি সম্পূর্ণ রেজোলিউশন পিএনজি (5.1MB)

কোডটি 0-1080 * 1920 থেকে সমস্ত পূর্ণসংখ্যার একটি সংগ্রহ তৈরি করে, তারপরে সামগ্রিক উজ্জ্বলতার দ্বারা সেগুলি সাজায়। এরপরে এটি একটি ম্যান্ডেলব্রট সেট তৈরি করে এবং তাদের পালানোর পুনরাবৃত্তি এবং মানের ভিত্তিতে অবস্থানগুলি সাজায়। তারপরে এটি উভয় সেটের মধ্যে দিয়ে যায়, ম্যান্ডেলব্রোট মানকে সবচেয়ে ছোট থেকে বৃহত্তর থেকে গা dark় থেকে উজ্জ্বল করে রঙ নির্ধারণ করে। অবশেষে, এটি কমান্ড লাইন প্যারামিটার হিসাবে নির্দিষ্ট আউটপুট ফাইল নামটিতে পিক্সেল বিএমপি চিত্রের জন্য 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;
}

এফওয়াইআই, এটিই আসল চিত্র ছিল ...

ওহ!

এবং কোডটিতে আগ্রহী যারা এই চিত্রটি তৈরি করতে ব্যবহার করেছেন তাদের জন্য:

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

এতে রঙের স্নাতক সত্যই দুর্দান্ত। আমি এই গণনামূলকভাবে উত্পন্ন চিত্রটি থেকে আউটপুটটি দেখতে পাই বেশ নান্দনিকভাবে আনন্দদায়ক। আমি এটি বেশ সহজেই ডেস্কটপ ওয়ালপেপার হিসাবে ব্যবহার করতে পারি। সাবাশ!

— বেন প্যাটন

দেখতে দেখতে দুর্দান্ত, তবে কিছু সমস্যা রয়েছে (১) অ-অনন্য পিক্সেল মান (সহজেই চেক করা হয়েছে: বারবার পুনরাবৃত্তি ./a.out | hexdump | headদেখায় 7d ff de), (২) 000000থ্রু থেকে ক্রমিক আরজিবি মানগুলি 1dffffএবং (3) পিক্সেল (x = 0, y = 0) কালো নয়। (যদিও আমি (3) এর বিন্দুটি নিজের কাছে দেখতে পাচ্ছি না)

— চটজলদি ossifrage

@ স্কোয়ামিশোসিফ্রেজ হ্যাঁ, আমি ভেবেছিলাম যে চশমাগুলি অত্যধিক নিয়ন্ত্রিত ছিল এবং একই সাথে প্রাথমিক প্রতি 8 বিটের বেশি বা 4 প্যানেল প্রতি চ্যানেল ফাইল ফর্ম্যাটগুলির অনুমতি দেয় না, যা আমি যদি প্রাথমিক প্রতি 16 বিট ব্যবহার করি তবে স্বতন্ত্রতার গ্যারান্টি দিতে পারে। যেহেতু এটি একটি জনপ্রিয়তা প্রতিযোগিতা, তাই আমি এটি ছেড়ে দেব, সম্ভবত এটি একটি ভোট বা দু'টি পেয়েছে ...

@ স্কোয়ামিশোসিফ্রেজ এটি বলে না যে আপনাকে 0 থেকে x1dffff পর্যন্ত পুনরাবৃত্তি করতে হবে, কেবল এটি কালো থেকে শুরু হয়ে সাদা দিকে wardsর্ধ্বমুখী হবে তবে ঠিক কী নয়।

— সিলেস্টার

@ সিলওয়েস্টার এটি বলছে যে আপনি ক্রম হিসাবে গণনা করার কথা , এবং পরবর্তী বাক্যটি বলে আপনি একটি 1920 x 1080 পিক্সেল চিত্র পাবেন যাতে কেবল প্রচুর কালো, ব্লুজ এবং সবুজ শাক থাকে । কোন বিট আমি ভুল বুঝেছি? (এছাড়াও 0x1dffff ভুল পাওয়া থেকে; 0x1fa3ff হওয়া উচিত ছিল।)

— খুঁতখুঁতে ossifrage

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

সোর্স কোড দৈর্ঘ্য (প্রতিস্থাপন করতে 1 টি অক্ষর যোগ করার খরচ জন্য <<8সঙ্গে <<11), নিম্নলিখিত বার্তা ছিল করা যেতে পারে। এটি blueরেজোলিউশন ব্যয়ে বর্ণালীটির আরও পরিসীমা জুড়ে । এটি আরজিবি স্পেসের মাধ্যমে আটগুণ হারে বৃদ্ধি পায়। রঙ মানগুলি থেকে শুরু 00 00 00করে fd 1f f8।

এখানে চিত্র বর্ণনা লিখুন

— ড্যারেন স্টোন
সূত্র

2

আপনার প্রবেশ সত্যিই ভাল। আপনার প্রথম চিত্রটি দেখে মনে হচ্ছে ঠিক এটির মতোই। ভাল হয়েছে এবং যেতে চেষ্টা করার জন্য ধন্যবাদ। আপনি এত তাড়াতাড়ি এবং খুব সামান্য কোড দিয়ে মুগ্ধ করেছেন।

— বেন প্যাটন

7

কোলাহল

র‌্যাকেট অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং এর আগে কখনও ব্যবহার করা হয়নি (বার্তা পাঠানো) সুতরাং আমি নিশ্চিত নই যে এটি সর্বোত্তম, তবে মনে হয় এটি কাজটি সেরে গেছে seems

#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 বিট সেল বিএফ অনুবাদকারীদের জন্য 24 বিট বিএমপি চিত্রটি স্টুডউটে প্রিন্ট করে। এটি র‌্যাকেট সংস্করণ হিসাবে একই চিত্র তৈরি করে। এটি পিএনএম সংস্করণ ভিত্তিক।

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

উবুন্টু জাহাজ সাথে bf 8 টি বিট কোষ রয়েছে:

bf img.bf > image.bmp

পুরানো সংস্করণ যা ক্রম থেকে খুলতে সক্ষম হওয়া লঙ্ঘন করে। এটি একটি .pnm ফাইল তৈরি করে যা বেশিরভাগ চিত্র দর্শকের সাথে সামঞ্জস্যপূর্ণ।

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

— Sylwester
সূত্র

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

— shrx
সূত্র

আপনার ছবিটিতে কেবল 394,460 টি অনন্য রঙ রয়েছে। আপনার আরজিবি মানগুলিকে সমতল করার আগে 8-বিট পূর্ণসংখ্যায় রূপান্তর করুন এবং আপনি এটি দেখতে পাবেন।

— স্কিওমিশ ওসিফরেজ

পছন্দ করেছেন

— shrix

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()আমার জন্য কাজ করে না। ডুনো কেন। : পি

— ডেভ জে

5

প্রসেসিং, 301
এটি সর্বাধিক সংশ্লেষজনক সমাধানের চেষ্টা নয়, তবে এটি রঙের কাঙ্ক্ষিত বিন্যাসটি অর্জনের জন্য সমস্ত নিয়ন্ত্রণ নিয়ন্ত্রণ করে। হ্যাঁ, রঙগুলি একটানা নয়, তবে এটি কোনও মজাদার নয়।

int w = 1920;
int h = 1080;
void setup(){
  size(w, h);
  int x = 0; int y = 0;
  for(int i=0; i<w*h; i++){
    stroke(
      (i >> 0) & 0xFF,
      (i >> 6) & 0xFF,  
      (i >> 3) & 0xFF
    );
    if (y % h == 0){
      y = 0;
      x++;
    }
    point(x, y);
    y++;
  }
  save("unique.png");
}

— দান্তে
সূত্র

চ্যালেঞ্জটির 0,0আরজিবি হওয়ার জন্য পিক্সেল প্রয়োজন 0,0,0। আমি দেখছি 31,31,31। আসলে, পুরো কলামটি শূন্যটি সেই রঙ হিসাবে উপস্থিত হবে।

— ইসজি

3

ভিজ্যুয়াল বেসিক। নেট, 273 বাইট

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

এটি একটি 5.61 এমবি ফাইল আউটপুট করে:

উপরের কোডটি আরও বেশি পঠনযোগ্য কোডের সংকোচিত সংস্করণ। বাইটগুলি সংরক্ষণ করার জন্য স্পেসগুলি সরানো হয়েছে।

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

চিত্রটির লিঙ্ক: http: //µ.pw/k

— bilde2910
সূত্র

2

চিত্রম্যাগিক - 119 রূপান্তর করুন

convertচিত্র তৈরি করতে ইমেজম্যাগিক টুলবক্স থেকে ব্যবহার করতে দেয় । এটি 0 সেকেন্ডে চলে। এটি 119 টি অক্ষরে গল্ফ করা হয়েছে। আমি দুটি গ্রেডিয়েন্ট (লাল-নীল এবং কালো-সাদা) ওভারলে এগুলি এইচএসএল এবং আরজিবিতে ফিরে রূপান্তর করি।

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

Output2

গ্রেডিয়েন্ট ওভারলে এর উদাহরণগুলি চিত্রম্যাগিক ম্যানুয়াল পৃষ্ঠাগুলিতে পাওয়া যাবে ।

— CousinCocaine
সূত্র

1

এটি দুর্দান্ত, তবে রঙগুলি অনন্য নয়। এই চেষ্টা করুন: identify -format %k o.png। আমি 1762920 পেয়েছি, না 2073600

— খুঁতখুঁতে ossifrage

thnx। আর একটি বিষয় হ'ল চিত্রটি আরজিবি (0,0,0) দিয়ে উপরের বামে শুরু হয় না। একটি স্থির উপর কাজ করা ...

— কাজিনকোচেন

@ স্কোয়ামিশোসিফ্রেজ, শনাক্তকরণ আদেশটির জন্য ধন্যবাদ। ঠিক আছে এখন।

— মামাতো ভাই কোকেইন

1

পিএইচপি, 507

আউটপুট চিত্র

চালানোর জন্য আপনার সম্ভবত পিএইচপি বরাদ্দ মেমরির পরিমাণ বাড়ানো দরকার। জিডি ব্যবহার করে। চিত্রটি তৈরি করতে প্রায় 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/portLive/pixel.php?w=1920&h=1080

— বেন প্যাটন
সূত্র

প্রজন্মের সময়কালের জন্য পাঠ্য সমস্ত কালো থাকায় এটি কি 2,073,600 টি অনন্য রঙের প্রয়োজনীয়তা যাচাই করে না? বা এটি প্রযুক্তিগতভাবে কোনও ওভারলে থেকে গণনা করা হয় না?

— ইসজি

হ্যাঁ আমি মনে করি আমি সে সম্পর্কে ভেবে দেখিনি। যখন আমি প্রথম এটি করার কথা ভেবেছিলাম তখন ভেবেছিলাম যে কোনও ডিক্সপ্লেস একই রঙের নয় এমন একটি ডেস্কটপ আকারের ওয়ালপেপারটি মজাদার হবে। তারপরে আমি যখন কোড দিয়ে খেলতে শুরু করলাম তখন এই চিত্রটির উত্পন্ন গতির প্রতি আমি আগ্রহী হয়ে উঠি। আমি মনে করি যে একটি সত্যই নিখুঁত সমাধান পাঠ্যের জন্যও বিভিন্ন রঙের পিক্সেল ব্যবহার করবে তবে সম্ভবত এটি বলা সহজ যে এটি পড়তে সহজ হবে না বলে আমি নিশ্চিত নই।

— বেন প্যাটন

আমি এখনই লক্ষ্য করেছি আমি যখন "লঙ্ঘন" বলতে চাইছিলাম তখন "বৈধতা দিন" বলেছিলাম। আচ্ছা ভালো. তুমি বুঝতে পেরেছ.

— ইসজি

1

দিল্লি / পাসল (সংস্করণ # 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

টিসিএল / টাকা, 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);
        }
    }

ফল

ব্যাখ্যা

সংক্ষিপ্ত সমাধানে এটি আমার প্রচেষ্টা নয়, বরং সবচেয়ে বহনযোগ্য। কেবল বাফারডিমেজের জন্য বাম আমদানি কারণ অন্যটি বাইট সংরক্ষণ করে না। ছবিটি কোনও JPanel এ লোড করা এবং এতে লেখার পরিবর্তে, ফাইলের নাম হিসাবে ডিস্কে লেখা না হওয়া পর্যন্ত শুরু থেকে যে সময় লাগে তা আমি সংরক্ষণ করেছি। আমার জন্য, এটি প্রায় 110 ডলার এমএসের ফাইলনামগুলির ফলস্বরূপ নিয়েছে, যদিও শুরু থেকে শেষ অবধি সাধারণত ~ 500ms লেগে যায়। শেষ পর্যন্ত, এটি প্ল্যাটফর্মটি স্বতন্ত্র হওয়া উচিত কারণ আমি উইন্ডোজ এবং উবুন্টু ভিএম উভয় ক্ষেত্রেই পরীক্ষা করেছিলাম এবং এটি কাজ করে (এটি আপনার ডেস্কটপে ফাইলটি লিখে)। কলযোগ্য সিনট্যাক্স আবর্জনার কারণে ফেরতের বিবৃতি থাকতে হয়েছিল। যদিও আমি আশেপাশে কাজ করছি, আমার সন্দেহ হয় আমি আমার এবং লুপের জন্য ডাব্লু ডাব্লু ব্যবহার করা থেকে সংরক্ষণের কারণে আমার নিজের থেকে আরও ভাল বাস্তবায়ন খুঁজে পেতে পারি। আমি বলব জাভাটির জন্য আধ সেকেন্ড খুব খারাপ নয় isn't

 (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
সূত্র

এটিকে পিছনে ফিরে দেখলে আমি মনে করি না যে চেষ্টা করার মতো ল্যাম্বডা কাজ করার জন্য মূল পদ্ধতিটির জন্য একটি ব্যতিক্রম

— ছোঁড়াতে হবে

2,073,600 অনন্য রঙ সহ একটি 1920 x 1080 গ্রাফিক উত্পন্ন করুন

পাইথন - 660+ বাইট

বর্ধিত সংস্করণ

আলোকিত সংস্করণ

সূত্র

পিএইচপি - 161 বাইট

পিএইচপি - 105 বাইট

পিএইচপি-সিএলআই - 83 বাইট

জিডি গ্রাফিক্স গ্রন্থাগার সহ সি (ভুল, প্রায় 2.5 কেবি?)

সি ++, 750 বাইট

সি - 854 বাইট (যখন সঙ্কুচিত)

রুবি, 109

কোলাহল

Brainfuck

পাইথন - 104

পাইথন - 110

পাইথন - 122

ভিজ্যুয়াল বেসিক। নেট, 273 বাইট

দিল্লি / পাসল (সংস্করণ # 1), 361 বাইট

টিসিএল / টাকা, 149

150

জাভা 411 386 + 24 বাইট

Golfed

Ungolfed

ফল

ব্যাখ্যা

সম্পাদন করা