हैकर लोगो प्रदर्शित करें

Question

आपने "हैकर लोगो" के बारे में सुना होगा, जिसे "हैकर प्रतीक" भी कहा जाता है। यह इस तरह दिख रहा है:

यह एक गणितीय सिमुलेशन से एक पैटर्न है जिसे गेम ऑफ लाइफ कहा जाता है। ग्लाइडर सबसे सरल जीवन पद्धति है जो चलती है, और सभी जीवन प्रतिमानों की सबसे तुरंत पहचानने योग्य है।

चुनौती

चुनौती बहुत आसान है: हैकर लोगो प्रदर्शित करें। इसे इस प्रकार परिभाषित किया गया है:

• एक सीमा के साथ एक 3x3 ग्रिड, एक सफेद पृष्ठभूमि और ग्रे ग्रिडलाइन्स।
• गोएल ग्लाइडर पैटर्न में पांच ब्लैक डॉट्स की व्यवस्था।
• और कुछ नहीं।

नियम

• ब्लैक डॉट्स को उनके व्यक्तिगत ग्रिड-बॉक्स का 40% - 80% भरना चाहिए ।
• आप प्रतीक को चित्रमय आउटपुट के साथ प्रदर्शित करेंगे लेकिन कोई ASCII कला नहीं ।
• आउटपुट कम से कम 30x30 पिक्सेल होना चाहिए ।
• आउटपुट में केवल रंग ग्रे, काला और सफेद होना चाहिए ।
• ग्रिड में प्रत्येक ग्रिड-बॉक्स एक ही आकार का होगा। ग्रिड एक नियमित 3x3 वर्ग होगा ।
• आप लोगो को इंटरनेट या अपने फाइल सिस्टम से नहीं खींच सकते।
• आपका प्रोग्राम खाली स्क्रीन / विंडो पर लोगो प्रदर्शित करेगा। यदि यह समाप्त हो जाता है तो इसे सामान्य रूप से करना चाहिए।
• ध्यान दें कि "डॉट्स" का मतलब "सर्कल" नहीं है। एक "डॉट" एक एकल ज्यामितीय आकार है जो एक सतह के साथ ग्रिड-बॉक्स के बीच में केंद्रित है। उदाहरण के लिए, जबकि एक वृत्त या वर्ग एक डॉट के रूप में अर्हता प्राप्त करेगा, दो त्रिकोण या एक चेकबोर्ड नहीं होगा।

विजेता

जैसा कि यह कोड-गोल्फ है , प्रत्येक भाषा में सबसे कम उत्तर जीतता है!

कृपया अपने उत्तर में अपने कार्यक्रम के आउटपुट का स्क्रीनशॉट शामिल करें।

Comments

मुझे पता नहीं था कि इसे हैकर लोगो कहा जाता है। मैंने इसे कुछ साइटों पर अपने अवतार के रूप में इस्तेमाल किया है, अनुमान है कि मुझे हैकर बनाता है।

— मार्क थॉमस

@MarkThomas कि या एक GoL nerd xD

— स्टीफन

@DavidConrad "स्क्रीन साफ़ करें" का अर्थ है यदि आप एक IDE / इंटरफ़ेस का उपयोग कर रहे हैं जिसमें बिलियन ग्राफिक्स हैं जो आप इसे स्क्रीन पर मौजूदा पाठ के साथ प्रदर्शित नहीं कर सकते हैं। हां, आप इसे एक विंडो में प्रदर्शित कर सकते हैं।

— एमडी XF

एंटी-अलियासिंग के कारण ग्रे (और रंगों से संबंधित) के कई शेड्स की अनुमति है?

— इयान मिलर

क्या हमें आउटपुट प्रदर्शित करना है या क्या हम इसे वापस कर सकते हैं या किसी फ़ाइल को सहेज सकते हैं?

— द लीथलकोडर

Answer 1

गणितज्ञ, 62 बाइट्स

Grid[{{,a=██,},{,,a},{a,a,a}},Frame->All,FrameStyle->Gray]

गणितज्ञ, 71 बाइट्स

Grid[{{,l=Graphics@Disk[],},{,,l},{l,l,l}},Frame->All,FrameStyle->Gray]

Comments

मुझे लगता है कि आप Graphics@Disk[]एक तर्क के रूप में शुद्ध फ़ंक्शन का उपयोग करके बाइट्स बचा सकते हैं ।

— कैलक्यूलेटरफिलीन

अगर आप इस ग्रिड [{{, #,}, {, #}, # #, #, #}}, फ्रेम-> सभी, फ्रेम-स्टाइल-> ग्रे] और @ ग्राफिक्स @ डिस्क [] का अर्थ है, तो यह 72 बाइट्स है

— J42161217

इस पर एक 69 बाइट संस्करण Rasterize@Grid[{{,●,},{,,●},{●,●,●}},Frame->All,FrameStyle->Gray]:। ● ● एक दो बाइट यूनिकोड वर्ण है। जैसा कि यह कड़ाई से एक चक्र नहीं है शायद कुछ ASCII चरित्र 40% -80% आवश्यकता को पूरा करने के लिए काम कर सकते हैं।

— इयान मिलर

वास्तव में मैंने इसे सभी आवश्यकताओं को पूरा करते हुए 62 बाइट्स में बनाया

— J42161217

मुझे लगता है कि आपको आवश्यकता Rasterizeया इसी तरह की आवश्यकता को पूरा करने के लिए graphical output but no ASCII artप्रतीक अभी भी ग्रिड में यूनिकोड के पात्रों के रूप में चयन करने योग्य हैं।

— इयान मिलर

Answer 2

CSS + HTML, 56 + 84 = 140 बाइट्स 52 + 84 = 136 बाइट्स

टिप्पणियों से सुझावों को शामिल करके 4 बाइट्स बचाए।

td{border:1px solid#888;line-height:.4;font-size:3em

<table cellspacing=0><tr><td><td>•<td><tr><td><td><td>•<tr><td>•<td>•<td>•

यह UTF-8 वर्ण का उपयोग करता है •जो 2 बाइट लंबा है और HTML सिंटैक्स की शालीनता का लाभ उठाता है।

Comments

बुरा नहीं; का उपयोग कर बहुत चालाक है •!

— एमडी एक्सएफ

बहुत ही शांत। मुझे लगता है कि आप एक बाइट को बचा सकते हैं line-height:.4;, और समापन को छोड़ कर दूसरा}

— ETHproductions

उपयोग नहीं करता है • ASCII कला के रूप में गिना जाता है, जो चुनौती नियमों के खिलाफ है?

— हैनकॉर्डर्स

@ स्टेफेनस वास्तव में निरर्थक भेद की तरह लगता है, साथ ही मुझे ASCII कला पर प्रतिबंध लगाने में भी समझदारी नहीं है लेकिन यूनिकोड कला की अनुमति है। जैसा कि ओपी ने कहा कि यह चतुर था, मेरी टिप्पणी वास्तव में ओपी के लिए निर्देशित थी, मैं @ में डालना भूल गया।

— हैनकॉर्डर्स

एकमात्र कोड गोल्फ उत्तर जिसे मैंने कभी समझा, कम से कम मुझे ऐसा लगता है।

— Uwe Keim

Answer 3

जीएलएसएल (टुकड़ा शैडर), 278 235 256 बाइट्स

precision highp float;void main(){vec2 a=gl_FragCoord.xy/20.-.2;ivec2 b=ivec2(a);a-=vec2(b)+.5;if(b.x>2||b.y>2)discard;gl_FragColor=a.x<-.5||a.y<-.5||a.x>.3||a.y>.3?vec4(.5,.5,.5,1.):length(a+.1)<.4&&(b.x+b.y-3)*b.y==0?vec4(0.,0.,0.,1.):vec4(1.,1.,1.,1.);}

इसे एक्शन में देखें: http://glslsandbox.com/e#40717.2

Comments

हम्म ... क्या सीमा ग्राफिक के चारों ओर जाती है? इसके अलावा, क्या आप सुनिश्चित हैं कि सर्कल केवल 80% ग्रिड-बॉक्स हैं?

— एमडी एक्सएफ

ऐसा घेरा जो इसके चारों ओर से घेरने वाले वर्ग को छूता है, वर्ग का अनुपात 4/4 या लगभग 78.5% भरता है।

— ग्रेग मार्टिन

मैंने आपके कोड का आकार 222 बाइट्स तक घटा दिया:precision highp float;void main(){vec2 a=gl_FragCoord.xy/20.-.2;ivec2 b=ivec2(a);a-=vec2(b)+.5;gl_FragColor=vec4(vec3(a.x<-.5||a.y<-.5||a.x>.3||a.y>.3?.5:length(a+.1)<.4&&(b.x+b.y-3)*b.y==0?.0:1.)*float(b.x<3&&b.y<3),1.);}

— गैबेर फेकेते

Answer 4

पायथन 2 ,  169  140 बाइट्स

from turtle import*
up()
shape("square")
color("gray",[1]*3)
i=9
while i:
 i-=1;goto(20-i/3*20,20-i%3*20);stamp()
 if 302&2**i:dot(15,0,0,0)

वास्तविक आकार, ६१ से ६१, ४०० से ३०० के एक बड़े कैनवास के भीतर प्लॉट किए गए:

पिक्सेल ग्रिड दिखा रहा है:

डॉट्स 40% -80% की सीमा के भीतर 177 पिक्सेल का उपयोग करते हैं, चाहे 19 को 19 सफेद भरण (144.4-288.8) या 21 को 21 द्वारा दोनों सीमाओं (176.4-352.8) सहित।

नोट: कार्यक्रम समाप्त हो गया है और कैनवास विंडो को बंद कर दिया गया है जैसे ही ड्राइंग समाप्त हो गई है, मैनुअल विंडो बंद करने की अनुमति देने के लिएdone() ।

turtleपायथन पैकेज को परिचयात्मक ग्राफिकल प्रोग्रामिंग के लिए विकसित किया गया है। एक पेन x,y=0,0300 से 400 पिक्सेल कैनवस (डिफ़ॉल्ट रूप से) के बीच में शुरू होता है, पेन को upउठाता है, पेन को gotoहिलाता है, पेन shapeके आकार को एक नाम के आकार में सेट करता है ( "square"यह एक डिफ़ॉल्ट आकार है जिसकी डिफ़ॉल्ट पिक्सेल-चौड़ाई 21 है ), colorरंग सेट करता है, जहां दो पैरामीटर स्ट्रोक सेट करते हैं (डिफ़ॉल्ट रूप से 1 की चौड़ाई) और भरें; एक बाइट का उपयोग करके सहेजा जाता है (r,g,b)टपल विकल्प को बदलने के लिए "white"के साथ [1,1,1]सूची गुणन का उपयोग [1]*3। अंत dotमें पिक्सेल और रंग में दी गई चौड़ाई के साथ एक डॉट खींचता है। अर्हता प्राप्त करने के लिए डॉट की डिफ़ॉल्ट चौड़ाई मान बहुत छोटा है, 9इसलिए मैंने इसे एक सौंदर्यवादी और योग्य बनाया है 15। डॉट का रंग हो सकता है"black"लेकिन अनपैक्ड (r,g,b)टपल 0,0,0दो बाइट्स से छोटा होता है।

पेन को अंत में किसी भी डॉट से दूर जाना चाहिए अन्यथा ग्रे / व्हाइट पेन डॉट को छुपाता है।

ग्रिड एक div (का उपयोग करते हुए चल रहा है /) और आधुनिक ( %की) iसे शुरू 8( iकरने के लिए initialised है 9लेकिन की शुरुआत में कम कर रहा है whileपाश) और करने के लिए नीचे काम कर रहे 0, के परिणामों के समायोजन 2,1,0के लिए -1,0,1उपयोग कर रहा (1-...)है और का उपयोग कर ग्रिड आकार अप करने के लिए प्रत्येक स्केलिंग 20 का एक कारक (ध्यान दें कि 20-i/3*20वास्तव में एक बाइट से कम है 20*(1-i/3), उसी के लिए जाता है %)। यह ऑर्डर [बॉटम-लेफ्ट, सेंटर-लेफ्ट, टॉप-लेफ्ट, बॉटम-मिडिल, सेंटर-मिडिल, टॉप-मिडिल, बॉटम-राइट, सेंटर-राइट, टॉप-राइट] को प्रोड्यूस करता है और इसके लिए " hasDot" के मूल्यांकन की आवश्यकता होती है [1,0,0,1,0,1,1,1,0]। जो 302द्विआधारी में है, इसलिए दो घटक की i^वें शक्ति का निरीक्षण करके पहुँचा जा सकता है302एक बिटवाइज़ और, का उपयोग करने के साथ 302&2**i।

Comments

बहुत अच्छा दृष्टिकोण और जितना मैंने सोचा था उससे बहुत कम उपयोग करना संभव होगा turtle।

— मस्त

Answer 5

अप्लेसॉफ्ट बेसिक , 479 476 516 515 483 482 बाइट्स

^{-32 अपठनीय चर नामों का उपयोग करके: P
-1 क्योंकि Apple ने जादुई होने का फैसला किया और मुझे एक अंतर्निहित / गैर-संबंधित GOTO का उपयोग करने दिया}

हलकों का उपयोग नहीं करने वाले आउटपुट के उदाहरण के लिए मेरा अपना (बहुत ही सराहनीय) कार्यक्रम है:

1GR:POKE49234,0:COLOR=15:FORI=0TO39:VLIN0,47ATI:NEXT:COLOR=5:S=21:W=S:H=27:X=INT((40-W)/2):Y=INT((48-H)/2):D=INT(W/3):DX=D:C=Y+H:G=X+W:FORI=0TO3:VLINY,C ATX+I*D:NEXT:D=INT(H/3):FORI=0TO3:HLINX,G ATY+I*D:NEXT:YH=INT(D/2):Z=Y+H-YH:XH=INT(DX/2):COLOR=0:FORI=0TO2:B=Z:A=X+XH+I*DX:GOSUB5:NEXT:B=B-D:GOSUB5:B=B-D:A=A-DX:GOSUB5:K=PEEK(-16384):IFK<128THEN2:K=PEEK(-16368):TEXT:HOME:END 
5VLINB+2,B-3ATA:VLINB+2,B-3ATA-1:VLINB+2,B-3ATA+1:VLINB+2,B-3ATA+2:VLINB,B-1ATA-1:VLINB,B-1ATA+2:RETURN

आउटपुट:

Comments

मुझे यकीन नहीं है कि यह मान्य है, क्योंकि पंक्ति 1, 239 वर्णों से अधिक लंबी है, सामान्य तरीकों से प्रवेश करना असंभव है, कम से कम // ई पर।

— आवेषण_नाम_जहाँ

@insert_name_here आपको इसे डिस्क पर फ़ाइल में सहेजना होगा।

— एमडी एक्सएफ

Answer 6

IA-32 मशीन कोड, 81 80 बाइट्स

Hexdump:

60 8b f9 b8 50 35 20 20 ab b8 32 35 36 20 ab ab
ab fe 4f fe 33 c9 66 49 51 8a c1 d4 55 50 8a c5
d4 55 5b b2 80 84 c0 74 1f 84 db 74 1b b2 ff 2c
10 3c 35 77 13 93 2c 10 3c 35 77 0c 8d 0c 58 8a
cd b0 e4 d2 e0 79 01 42 92 aa 59 e2 cb aa 61 c3

यह एक ऐसा fastcallफ़ंक्शन doitहै जो आपूर्ति किए गए बफर में पीजीएम प्रारूप में छवि को वापस करता है। उपयोग:

char buf[256 * 256 + 256];
doit(buf);

FILE* f = fopen("k.pgm", "wb");
fwrite(buf, 1, sizeof buf, f);
fclose(f);

आउटपुट:

मैंने 256x256 रिज़ॉल्यूशन का उपयोग किया, क्योंकि यह शांत है यह मुझे पिक्सेल के सूचकांक को ecxस्वचालित रूप से निर्देशांक yमें chऔर xअंदर में विभाजित करने देता है cl। इसके अलावा, PGM फाइल फॉर्मेट में इमेज हेडर में नंबर 255 की आवश्यकता होती है।

आंतरिक वर्ग 54x54 (क्षेत्रफल के आधार पर सेल का 41%) हैं।

स्रोत कोड (विजुअल स्टूडियो द्वारा संकलित किया जा सकता है):

    pushad;                 // save all registers
    mov edi, ecx;           // edi is now the pointer to output
    mov eax, '  5P';        // PGM file header
    stosd;                  // store it
    mov eax, ' 652';        // the number 256 and a space
    stosd;                  // store the width
    stosd;                  // store the height
    stosd;                  // store maximum brightness
    dec byte ptr [edi-2];   // fix maximum brightness to 255

    xor ecx, ecx;           // initialize the counter of pixels
    dec cx;                 // to 65535
myloop:
    push ecx;

    mov al, cl;             // al = cl = x coordinate in the image
    _emit 0xd4;             // divide by 85
    _emit 85;               // ah = x cell number, al = x coordinate in cell
    push eax;
    mov al, ch;             // al = ch = y coordinate in the image
    _emit 0xd4;             // divide by 85
    _emit 85;               // ah = y cell number, al = y coordinate in cell
    pop ebx;                // bh = x cell number, bl = x coordinate in cell

    mov dl, 0x80;           // gray pixel value
    test al, al             // is cell boundary (y)?
    je output1;
    test bl, bl;            // is cell boundary (x)?
    je output1;

    mov dl, 255;            // white pixel value
    sub al, 16;
    cmp al, 53;
    ja output1;             // if outside the inner square, output white
    xchg eax, ebx;          // exchange the registers to shorten following code
    sub al, 16;
    cmp al, 53;
    ja output1;             // if outside the inner square, output white

    lea ecx, [ebx * 2 + eax]; // cell index = y * 2 + x
    mov cl, ch;
    mov al, 0xe4;           // load the bitmap for the glider pattern
    shl al, cl;             // shift the needed but into SF
    jns output1;            // the bit was 0? - output white
    inc edx;                // the bit was 1? - change to black

output1:
    xchg eax, edx;
    stosb;                  // output the byte

    pop ecx;
    loop myloop;
    stosb;                  // output an additional gray pixel
    popad;
    ret;

सेल पैटर्न

0 1 0
0 0 1
1 1 1

7 बिट्स के "अनुकूलित" बिटमैप द्वारा प्रतिनिधित्व किया जा सकता है।

बिट्स को अभिव्यक्ति द्वारा अनुक्रमित किया जाता है y * 2 + x, जहां (x,y)सेल का स्थान है। यह अभिव्यक्ति 2 जोड़े कोशिकाओं को एक ही सूचकांक देती है। यह एक भाग्यशाली संयोग है कि वहां के मूल्य समान हैं।

Comments

यह शांत है, लेकिन मैं 42*42/85/85केवल 24.4% बनाता हूं ।

— जोनाथन एलन

@JonathanAllan: सेल के सफेद भाग केवल 84x84 हैं, लेकिन हाँ, एक 42x42 बॉक्स केवल 84x84 बॉक्स का एक चौथाई है।

— निक मैट्टो

मैंने स्पष्टीकरण के लिए कहा है (यदि यह क्षेत्र में जाता है तो मुझे आशा है कि इसे अपडेट करना बहुत मुश्किल नहीं है)।

— जोनाथन एलन

सत्तारूढ़ है - यह क्षेत्र है ...

— जोनाथन एलन

मैंने 42 से 54 तक काले डॉट्स को बड़ा किया। यह न्यूनतम है, जिससे उन्हें क्षेत्र का 40% बना दिया गया है, और वे पहले से ही बदसूरत होने लगे हैं ...

— अनातोलीग

Answer 7

HTML और CSS, 155 बाइट्स

HTML बाहर हो जाता है वास्तव में वाक्यविन्यास त्रुटियों के बारे में क्षमा करना।

_{@Octopus लिए 1 बाइट बचाया धन्यवाद · @Downgoat लिए 1 बाइट बचाया धन्यवाद · 2 बाइट्स बचाया @StephenS करने के लिए धन्यवाद}

_{2 बाइट्स बचाया धन्यवाद @Ryan लिए · 3 बाइट्स बचाया धन्यवाद @styfle को · 4 बाइट @Ferrybig को बचाया धन्यवाद}

_{13 बाइट्स ने @SteveBennett को धन्यवाद दिया}

p{height:33px;width:33px;border-radius:50%;background:#000;margin:0

<table cellspacing=0 border=1><td><td><p><td><tr><td><td><td><p><tr><td><p><td><p><td><p

Comments

कृपया यह बताएं कि कौन सा ब्राउज़र (और कौन सा संस्करण) काम करता है - यह ओपेरा 45 में काम नहीं करता है।

— पाओलो एबरमैन

Windows पर Chrome 58.0.3029.110 (64-बिट) का उपयोग करके स्निपेट मेरे लिए काम नहीं करता है। Chrome संस्करण किस में काम करता है?

— जोनाथन एलन

यह macOS Sierra (10.12.4) पर सफारी 10.1 के साथ सर्कल को प्रदर्शित नहीं करता है।

— आर। काप

डॉट्स क्रोमियम 55.0.2883.87 (64-बिट) के साथ प्रदर्शित नहीं होते हैं।

— डायलन मीस

एंड्रॉइड के लिए क्रोम पर डॉट्स नहीं देख सकते हैं (58.0.3029.83)

— Spikatrix

Answer 8

आर ( 130 119 113 बाइट्स)

plot(c(2,4,6,4,6),c(2,2,2,6,4),an=F,ax=F,xli=(l=c(1,7)),yli=l,xaxs="i",yaxs="i",pch=16,cex=19);grid(3,lt=1);box()

Comments

आप axes=Fप्रतिस्थापित करने के लिए उपयोग कर सकते हैं xaxt="n",yaxt="n"। यदि आप सभी समन्वय मूल्यों को दोगुना करते हैं, तो आप 4 शुद्ध बाइट्स बचाते हैं (लेकिन 1:3,2:3चाल का उपयोग नहीं कर सकते हैं )।

— user2390246

@ user2390246: सुझावों के लिए thx। मैं इसे बाहर गोल्फ के लिए ज्यादा समय नहीं मिला। मुझे यकीन है कि और भी संभावित सुधार हो सकते हैं। मुझे जोड़ने ;box()के लिए axes=Fभी फ्रेम को हटा दिया गया था। इसके अलावा, जैसा axesकि एक plotपैरामीटर है और / के parमाध्यम से पारित नहीं किया ...जाता है , इसे पूरी तरह से वर्तनी की आवश्यकता भी नहीं है। xaxtyaxt

— 15

आप c(1,7)एक चर के साथ (1) की जगह 7 बाइट्स से दाढ़ी बना सकते हैं l=c(1,7); (2) के annसाथ की जगह an; (3) के [xy]liसाथ की जगह [xy]li; और (4) के बाद दूसरे स्थान, अनावश्यक तर्क को हटाने grid: grid(3,lt=1)। वास्तव में, मैंने इसे (समीक्षा के तहत) संपादित करने की स्वतंत्रता ले ली है।

— कोनराड रुडोल्फ

@KonradRudolph प्रासंगिक लगता है: codegolf.meta.stackexchange.com/questions/1615/…

— मैट

@ ममत हं। लगता है कि यह समझ में आता है अगर यह सीधे-सीधे सुधारों को लागू करने के बजाय मौलिक रूप से अलग-अलग अनुकूलन करता है। काफी उचित।

— कोनराड रुडोल्फ

Answer 9

पायथन 2.7, 214 311 309 बाइट्स

from matplotlib.pyplot import*
f,x=subplots()
j=(0,0),(1,0),(2,0),(1,2),(2,1)
for i in j:x.add_artist(Circle((i),.4,color='k'))     
x.tick_params(labelbottom='off',labelleft='off')
for o in x.spines.values():o.set_edgecolor('gray')
for s in 'xy':exec"x.set_"+s+"ticks((.5,1.5,2.5));"+s+"lim(-.5,2.5);"
grid()

कोड गोल्फ में यह मेरा पहला प्रयास है, इसलिए मुझे यकीन है कि इसमें सुधार किया जा सकता है। मैं सीमाओं को स्थापित नहीं करना पसंद करूंगा, लेकिन ऐसा प्रतीत होता है कि मैटलपोटलिब यह पता नहीं लगा सकता है कि मैंने उन हलकों को प्लॉट किया है जहां मैंने किया था। Xlim () और ylim () को सेट किए बिना यह केवल नीचे के दो सर्कल दिखाता है।

आउटपुट:

संपादित करें: सीमाओं का रंग तय किया और टिक संख्या को हटा दिया। मुझे कहना चाहिए कि matplotlib बहुत घनी शब्द है, और बदलते रंग के साथ बहुत अनुकूल नहीं है।

@DJMcMayhem की बदौलत 3 बाइट शेव की गईं

संपादित करें: मेरे टिक्स को सेट_टिक्स फ़ंक्शंस के अंदर एक टपल के रूप में सेट करके दो बाइट्स ले लिया।

Comments

क्षमा करें, ग्राफ़ पर संख्याओं की अनुमति नहीं है। इसके अलावा, सीमा ग्रे है?

— एमडी एक्सएफ

साइट पर आपका स्वागत है! यह एक अच्छा पहला उत्तर है। :)

— DJMcMayhem

कुछ छोटे गोल्फ मैं देख रहा हूं: 1) आप एक जगह और एक नई लाइन (-2 बाइट्स 2) को हटाने के लिए 5 और 6 की लाइनों में शामिल हो सकते हैं यदि सेट xy_ticks और xy_lim का क्रम मायने नहीं रखता है, तो आप कुछ ऐसा कर सकते हैं for s in'xy':exec"x.set_"+s+"ticks(a);"+s+"lim(-.5,2.5);"। (मैंने ऐसा परीक्षण नहीं किया है, इसलिए मैं सकारात्मक नहीं हूं)

— डीजेमेकमेम

Answer 10

बैश + इमेजमैजिक, 233 226 अक्षर

convert xc: +antialias -resize 31 -draw "stroke gray fill none ${r=rectangle} 0,0 10,30$r 20,0 30,30$r 0,0 30,10$r 0,20 30,30stroke #000 fill #000 ${c=circle} 15,5 15,8$c 25,15 25,18$c 5,25 5,28$c 15,25 15,28$c 25,25 25,28" x:

नमूना उत्पादन:

बैश + इमेजमैजिक, 215 अक्षर

convert xc: -resize 31 -draw "stroke gray fill none ${r=rectangle} 0,0 10,30$r 20,0 30,30$r 0,0 30,10$r 0,20 30,30stroke #000 fill #000 ${c=circle} 15,5 15,8$c 25,15 25,18$c 5,25 5,28$c 15,25 15,28$c 25,25 25,28" x:

प्रश्न के मालिक ने अभी तक उत्तर नहीं दिया है कि एंटी-अलियासिंग प्रश्न और कुछ अन्य समाधानों में भी एंटी-अलियासिंग द्वारा अतिरिक्त ग्रे शेड जोड़े गए हैं, इसलिए अब यह छोटा भी स्वीकार्य लगता है।

नमूना उत्पादन:

Answer 11

रूबी, 144 166 164 148 144 बाइट्स

require'ruby2d'
set background:'grey'
c=482;g=2,13,24;d=0
g.map{|y|g.map{|x|Square.new(x,y,9);Square.new(x+2,y+2,5,"black")if c[d]>0;d+=1}}
show

आउटपुट:

संपादित करें: अब ग्रे ग्रिडलाइन्स हैं।

Comments

मैं यहाँ कुछ गोल्फ के अवसर देख सकता हूँ। शुरुआत के लिए, d=d+1एक छोटा रूप है ( d+=1) और ==1यहाँ के बराबर है >0। यह भी विचार करें कि जब आप सरणी के बजाय एक

— फ़िक्नम में

@RJHunter मुझे कुछ कम लटके फल याद आ गए! और मुझे लगता है कि सी के साथ एक बिटफील्ड बनाने जैसे सामान के बारे में सोचा था, लेकिन इस तरह से नहीं आ सकता था जो वास्तव में कार्यान्वयन में कम हो।

— मार्क थॉमस

शायद आश्चर्य की बात है, रूबी वास्तव में कुछ बिटफील्ड समर्थन में निर्मित है! आप एक पूर्णांक तक पहुंच सकते हैं []जैसे कि यह बिट्स की एक सरणी थी (केवल पढ़ने के लिए, लेकिन यह यहां ठीक है)।

— आरजेहंटर

@RJHunter धन्यवाद! मुझे सिर्फ इतना करना था कि सी को उचित संख्या में बदल दिया जाए। इसे काफी कम कर दिया।

— मार्क थॉमस

आप बदल सकते हैं g=[2,13,24]करने के लिएg=2,13,24 और की जगह eachके साथ map।

— जॉर्डन

Answer 12

पीएनजी, 105 100 बाइट्स

   (अर्थात यह छवि फ़ाइल)

यह देखते हुए कि HTML और अन्य गैर-प्रोग्रामिंग भाषाओं की अनुमति है , मैं यह देखने के लिए उत्सुक था कि मैं एक आधारभूत तुलना के रूप में सेवा करने के लिए एक सादे ब्राउज़र-डिस्प्ले करने योग्य छवि को कितना गोल कर सकता हूं। परिणाम ओपन-सोर्स टूल ऑप्टिपंग के साथ संपीड़ित होता है ( -o7 -zm1-9 -strip all) और pngwolf । मैंने zopflipng के साथ भी प्रयोग किया , लेकिन परिणाम बड़े थे। अन्य बंद-स्रोत संपीड़न उपकरण कुछ और बाइट्स को दाढ़ी बनाने में सक्षम हो सकते हैं।

बेस 64 में छवि डेटा:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTgAAAABJRU5ErkJggg==

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
    fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
    4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTgAAAABJRU5ErkJggg==">

संपादित करें मैंने बनाया डॉट्स सेल को ऊपर और नीचे स्पर्श करते हैं, जिससे पिक्सेल पैटर्न में अधिक पुनरावृत्ति होती है और इस प्रकार संपीड़न अनुपात में सुधार होता है। लेकिन चिंता मत करो, एक बिंदु अभी भी केवल (7 * 9) / (9 * 9)। 78% इसकी सेल भरता है।

गैर-मानक पीएनजी, 88 बाइट्स

जैसा कि @anatolyg ने बताया , IEND chunk (12 बाइट्स) को हटाकर कुछ गोल्फिंग क्षमता है। तकनीकी रूप से, IEND मानक द्वारा आवश्यक है । हालांकि, प्रत्येक पीएनजी चंक में अपना स्वयं का आकार और चेकसम जानकारी शामिल है। इसलिए एंड-मार्कर होना बिल्कुल आवश्यक नहीं है। और वास्तव में, मैंने जिन सभी ब्राउज़रों का परीक्षण किया है वे बिना किसी समस्या के छवि प्रदर्शित कर सकते हैं।

दुर्भाग्य से (या सौभाग्य से), यह गैर-मानक छवि imgur द्वारा अस्वीकार कर दी गई है, इसलिए मैं वास्तव में इसे अपलोड नहीं कर सकता। यह बेस 64 एनकोडिंग है:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTg==

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTg==">

Comments

मुझे यकीन नहीं है कि यह मान्य है। PNGकोई प्रोग्रामिंग भाषा नहीं है।

— DJMcMayhem

शुक्रिया एमडी एक्सएफ। @DJMcMayhem न तो HTML है। लेकिन छवि के छोटे आकार को देखते हुए, मैंने इसे एक दिलचस्प बाहरी बॉक्स प्रविष्टि के रूप में प्रस्तुत किया।

— मेयर

गैर-प्रोग्रामिंग-भाषाओं में @DJMcMayhem उत्तर तकनीकी रूप से सर्वसम्मति से अनुमति है। खासकर, फिक्स्ड-आउटपुट चुनौतियों के लिए।

— मार्टिन एंडर

इसके अलावा, PPCG, @ मेयर में आपका स्वागत है! :)

— मार्टिन एंडर

आप फ़ाइल के अंत में कुछ बाइट्स निकाल सकते हैं और अभी भी छवि है। हालांकि एक दर्शक पर निर्भर हो सकता है; मैं कल्पना करता हूं कि अधिकांश दर्शकों को उदाहरण के लिए अंत-चंक की आवश्यकता नहीं है।

— अनातोली

Answer 13

सप्टक , 127 124 बाइट्स

लुइस के लिए 3 बाइट्स को हटा दिया गया। gridपर्याप्त है (के बजायgrid on ) है।

spy([0,1,0;0,0,1;1,1,1],'.k',300),set(gca,'XTick',.5:4,'XTickLabel','','YTick',.5:4,'YTickLabel',''),axis(.5+[0,3,0,3]),grid

आउटपुट (बचत के बाद):

ध्यान दें कि आउटपुट प्लॉट विंडो में ग्रे ग्रिड लाइनें दिखाता है। इसे बचाने के लिए वे काले हो जाते हैं (किसी कारण से)।

खैर, यह लंबा और गड़बड़ था! ऐनक का पालन करने के लिए बहुत सारे संशोधनों से गुजरना पड़ा ।

स्पष्टीकरण और उम्मीद है कि कुछ गोल्फ आ रहा है ...

Comments

यह बहुत डरावना नहीं दिखता है, लेकिन जब से ओपी ने एक समान आउटपुट के साथ एक उत्तर दिया, मुझे लगता है कि यह ठीक है ..

— L3viathan

मुझे लगता है कि ऊंचाई / चौड़ाई का अनुपात प्लेटफॉर्म पर निर्भर है। 'square'इसे सभी प्लेटफार्मों पर चौकोर बनाने के लिए जोड़ें । spy([0,1,0;0,0,1;1,1,1],'.k',80),set(gca,'XTick',.5:4,'XTickLabel','','YTick',.5:4,'YTickLabel',''),axis(.5+[0,3,0,3],'square'),grid on।

— स्टिव ग्रिफिन

Answer 14

प्रसंस्करण, 212 198 बाइट्स

background(-1);noFill();stroke(99);rect(0,0,99,99);rect(0,33,99,33);rect(33,0,33,99);fill(0);int f=25;ellipse(15,83,f,f);ellipse(50,83,f,f);ellipse(83,83,f,f);ellipse(83,50,f,f);ellipse(50,15,f,f);

मूल रूप से, हम एक सफेद पृष्ठभूमि को आकर्षित करने के लिए सरल प्रसंस्करण का उपयोग कर रहे हैं, फिर ग्रिड के लिए उपयोग किए जाने वाले आयतों की पारदर्शिता स्थापित करने और उनके स्ट्रोक ग्रे में खींचने के लिए। हम आयत को परिभाषित करते हुए, हलकों को फिर से भरने के लिए फिर से फिल वैल्यू सेट करते हैं और फाइव सर्कल को परिभाषित करते हैं।

देखा!

आप जोड़ सकते हैं

strokeWidth(2); 

या अधिक स्ट्रोक के रंग को बेहतर देखने के लिए।

(यह मेरा पहला कोड-गोल्फ है, मुझे आशा है कि मैंने सब कुछ ठीक किया है।)

संपादित करें: कृतिका लिथोस के लिए धन्यवाद! निकाले गए नए कथानक, int f = 25 में बदल गए और पृष्ठभूमि में -1 का उपयोग किया गया (फ्लोट)

Comments

महान पहला गोल्फ, और PPCG में आपका स्वागत है!

— एमडी एक्सएफ

तुम्हें पता है, नई-पंक्तियों को हटाने बदलकर कुछ बाइट्स बचा सकते हैं float f=25;करने के लिए int f=25;और का उपयोग करके background(-1)बजायbackground(255);

— Kritixi lithos

Answer 15

टिक्ज़, 193 175 170 बाइट्स

\documentclass[tikz]{standalone}\begin{document}\tikz{\def\a{)rectangle(}\def~{)circle(1)(}\draw(4,6\a2,0)(0,\a6,6)(0,2\a6,4);\fill(1,1~3,1~5,1~5,3~3,5~,)}\end{document}

यहाँ उत्पादन है:

Comments

@MDXF यह करीब से कट जाता है, लेकिन चूंकि ये सही सर्कल और वर्ग हैं, इसलिए वे वर्ग का F / 4 बनाते हैं जो वर्ग का लगभग 79% है।

— गेहूं जादूगर

लानत है, चुनौती को देखा और ठीक उसी तरह का विचार था;)

— रेसर २

Answer 16

MATL , 74 69 68 64 62 बाइट्स

4:6B&f,.5+w]'k.'5Y08W5$XG7lZG1$3ZG1tZG4:"@th1Kh'k'3$XG1Mbw3$XG

MATL ऑनलाइन पर यह कोशिश करो ! (इसमें कुछ सेकंड लगते हैं।)

ऑनलाइन दुभाषिया से आउटपुट:

Answer 17

प्रसंस्करण, 134 बाइट्स

@Zep से प्रेरित होकर, यहां मेरा प्रोसेसिंग वन-लाइनर (और मेरा पहला कोड गोल्फ भी है):

stroke(127);for(int i=0;i<9;i++){int x=i%3*30;int y=i/3*30;fill(255);rect(x+5,y+5,30,30);if(i==1||i>4){fill(0);ellipse(x+20,y+20,23,23);}};

कुछ बाइट्स शेविंग पर अपने शानदार सुझावों के लिए @Kritii लिथोस के लिए धन्यवाद!

Comments

कृपया एक भाषा और स्कोर लाइन शामिल करें ।

— थरोट

PPCG में आपका स्वागत है और पहला उत्तर अच्छा है! जैसा कि थेरॉट ने कहा, सभी सबमिशन के लिए एक हेडर होना आवश्यक है जिसमें भाषा और बायटेकाउंट शामिल हो। इसके अलावा, आप फॉर-लूप के सभी वेरिएबल्स को घोषित करके कुछ बाइट्स को गोल्फ कर सकते हैं, जैसे for(int i=0,x,y;...कि आप intलूप के शरीर में छोड़ सकते हैं । इसके अतिरिक्त, fill(255);बस बन सकता हैfill(-1);

— Kritii Lithos

मैं इस परीक्षण नहीं किया है, लेकिन मैं आप ड्रॉप कर सकते हैं लगता है +20, जबकि के मूल्यों की स्थापना xऔर y, ताकि आप बदल सकते हैं rectकरने के लिए rect(x+5,y+5,30,30);और ellipseकरने के लिए ellipse(x+20,y+20,23,23);और दो बाइट्स सहेजें।

— क्रिति लिथोस

Answer 18

लाटेक्स + टिक्ज़, 155 बाइट्स

\documentclass[tikz]{standalone}\begin{document}\tikz{\draw(0,0)grid(3,3);\foreach\x/\y in{0/0,1/0,2/0,2/1,1/2}\fill(\x+.5,\y+.5)circle(.5);}\end{document}

Comments

क्या वह 1/0विभाजन कर रहा है?

— wizzwizz4

क्षमा करें, लेकिन नहीं, यह एक साधारण विभाजक है जिसमें जोड़े xऔर yनिर्देशांक हैं।

— टोनियोइलग्रिंगो

आपको हर चीज को 2 से बढ़ाकर कुछ बाइट्स को बचाने में सक्षम होना चाहिए, ताकि आपका .5बस बन जाए 1।

— क्रिस

@ क्रिस ग्रिड ग्रिड बिल्ड डिफ़ॉल्ट रूप से यूनिट-लंबाई की कोशिकाओं का उत्पादन करता है, और [step=2]एक बड़ा ग्रिड का उत्पादन करने के लिए लगभग 8 बाइट्स (अधिक ) जोड़ता है । हलकों के ड्राइंग के लिए निर्देशांक को सरल बनाने से पर्याप्त बाइट्स नहीं बचेंगे। (यदि आप ऐसा करते हैं तो आपको 157 बाइट्स

— मिलते हैं

@TonioElGringo आह, सच। मुझे यह परीक्षण किए बिना टिप्पणी करने के लिए सिखाता है;)

— क्रिस

Answer 19

स्माइलबासिक, 125 बाइट्स

GCLS-1GCOLOR #GRAY
GBOX.,8,30,38GBOX 10,8,20,38GBOX.,18,30,28G.,1G 1,2G-1,3G.,3G 1,3DEF G X,Y
GPUTCHR X*10+12,Y*10,58081,.END

58081 (U + E2E1, जो "निजी उपयोग क्षेत्र" ब्लॉक में है) एक सर्कल प्रतीक के लिए वर्ण कोड है। इसे एक स्ट्रिंग में रखना भी बहुत काम करेगा, लेकिन चूंकि यह UTF-8 में 3 बाइट्स के रूप में एनकोडेड है, इसलिए यह समान लंबाई होगी (और यहां सही तरीके से नहीं दिखाई जाएगी)।

Comments

यह हमेशा बुनियादी जवाब देखने के लिए ताज़ा है!

— टेलर स्कॉट

Answer 20

सी #, 333 बाइट्स

using System.Drawing;_=>{var b=new Bitmap(31,31);var g=Graphics.FromImage(b);g.FillRectangle(Brushes.White,0,0,31,31);for(int x=0,y;x<3;++x)for(y=0;y<3;++y){g.DrawRectangle(Pens.Gray,x*10,y*10,10,10);if(x==1&y<1|x>1&y==1|y>1)g.FillEllipse(Brushes.Black,x*10+1,y*10+1,8,8);}b.Save("t.png");System.Diagnostics.Process.Start("t.png");};

पूर्ण / प्रारूपित संस्करण:

using System.Drawing;
Action<int> a = _ =>
{
    var b = new Bitmap(31, 31);
    var g = Graphics.FromImage(b);

    g.FillRectangle(Brushes.White, 0, 0, 31, 31);

    for (int x = 0, y; x < 3; ++x)
        for (y = 0; y < 3; ++y)
        {
            g.DrawRectangle(Pens.Gray, x * 10, y * 10, 10, 10);
            if (x == 1 & y < 1 | x > 1 & y == 1 | y > 1)
                g.FillEllipse(Brushes.Black, x * 10 + 1, y * 10 + 1, 8, 8);
        }

    b.Save("t.png");
    System.Diagnostics.Process.Start("t.png");
};

विचार सरल है हम छवि से एक ग्राफिक्स ऑब्जेक्ट बनाते हैं और इसका उपयोग करते हैं ताकि छवि सभी सफेद हो। फिर बाउंडिंग आयत को चित्रित करने वाले छवि के प्रत्येक वर्ग पर लूप करें। यदि यह डॉट के लिए स्थानों में से एक है, तो हम इसे भी आकर्षित करते हैं। अंत में हम इमेज को फाइल करने के लिए सेव करते हैं और विंडो को यह तय करने का तरीका बताते हैं कि, मेरे मामले में यह विंडोज फोटो व्यूअर के साथ खुलता है।

इसका उपयोग करना Processछवि को दिखाने के लिए और फ़ाइल को सहेजने के लिए विंडोज फॉर्म या WPF ऐप बनाने की तुलना में बहुत कम है क्योंकि सभी अलग-अलग वर्गों और उन्हें बनाने के लिए आवश्यक अतिरिक्त फुलाना है।

आउटपुट:

Comments

मुझे नहीं लगता कि आपको Process.Start का उपयोग करना है, उदाहरण के लिए टाइटस का जवाब सिर्फ आउटपुट छवि है, इसे नहीं खोलता है

— जेरेमी थॉम्पसन

@JeremyThompson नियम बताता है कि आपको छवि प्रदर्शित करनी होगी

— TheLethalCoder

Answer 21

PHP, 221 + 2 बाइट्स

<?imagefill($i=imagecreatetruecolor(31,31),0,0,~0);function q($i,$x,$y,$f){imagerectangle($i,$x*=10,$y*=10,$x+10,$y+10,5e6);$f?:imagefilledellipse($i,$x+5,$y+5,8,8,0);}for($p=16;$p--;)q($i,$p&3,$p>>2,53>>$p&1);imagepng($i);

फाइल में बचाएं; ब्राउज़र में कॉल करें। आपके ब्राउज़र को जिबरिश प्रदर्शित करनी चाहिए, पहले
डालें ।header("Content-Type:image-png");imagepng($i);

डॉट्स बहुत गोल नहीं हैं; छोटे अनुपात के कारण।

टूट - फूट

function q($i,$x,$y,$f){        # function to draw quadrant:
    imagerectangle($i,$x*=10,$y*=10,$x+10,$y+10,5e6);   # draw lines in 0x4c4b40
    $f?:imagefilledellipse($i,$x+5,$y+5,8,8,0);         # if bit not set, draw dot
}

imagefill($i=
    imagecreatetruecolor(31,31) # create image
    ,0,0,~0);                   # fill with 0xffffff (white)
for($p=16;$p--;)q($i,           # loop through positions, call function
    $p&3,                           # $x=lower two bits
    $p>>2,                          # $y=upper two bits
    53>>$p&1                        # $f=one bit from %0000 0000 0011 0101
);                                      # (reversed inverted bit mask for dots)
imagepng($i);                   # output image

मुझे लगता है कि 0x4c4b40अनुमानित ग्रे के रूप में योग्य है। यदि नहीं, तो चार बाइट्स जोड़ें।

Answer 22

आर 313 236 बाइट्स

l=c(1,7)
bmp('r',400,400)
plot(x=c(4,6,2,4,6),c(6,4,2,2,2),cex=14,pch=19,xlim=l,ylim=l,xlab='',ylab='',xaxs='i',yaxs='i',axes=F)
a=function(s,...){axis(s,labels=F,tck=1, col="gray",lwd=9,...)}
a(1,xaxp=c(l,3))
a(2,yaxp=c(l,3))
dev.off()

संशोधित कोड, @ user2390246 से टिप्पणियों के आधार पर 77 बाइट्स बचाए। बहुत मदद की सराहना करते हैं।

इसके अलावा, @mschilli द्वारा छोटे आर समाधान में कॉल-आउट जोड़ना चाहते हैं। यह आर चित्रमय चूक की समस्या को संबोधित करने का एक सुंदर तरीका दिखाता है।

उत्पादन

एक फ़ाइल नाम "r" पर जाता है। ओमिटिंग और एक्सटेंशन ने मुझे चार बाइट बचाए। लेकिन फिर मुझे फ़ाइल एक्सटेंशन को वापस "bmp" में संपादित करना था ताकि इसे अपलोड किया जा सके। तो शायद मुझे उन चार बाइट्स के लिए क्रेडिट नहीं मिलना चाहिए।

टीका

मैंने खुद से सोचा, "उस ग्राफिक के कुछ नहीं, लेकिन पांच बिंदुओं के साथ एक सरल ग्राफ। मजबूत डेटा ग्राफिक्स क्षमताओं वाली भाषा में लागू करने के लिए एक साधारण मामला होना चाहिए। आइए इसे आर में आज़माएं।" लेकिन तब मुझे 80% बाइट्स के ऑर्डर पर R के ग्राफिक डिफॉल्ट के आसपास काम करना पड़ा।

काम के लिए गलत साधन Kinda ...।

मैं bmp कंस्ट्रक्टर और फिर dev.off () कहकर ग्राफिक के आकार और पहलू अनुपात की गारंटी देने का एक कम क्रिया तरीका नहीं खोज सका। संयोजन 25 बाइट्स के लिए खाता है। यदि आपका R सत्र सही सेट अप है, तो आपको उन बाइट्स को खर्च किए बिना अधिक या कम सही दिखने वाला ग्राफ़िक मिल सकता है, लेकिन यह विश्वसनीय या सुसंगत नहीं है।

Comments

कुछ सुझाव: अपने डेटा फ़्रेम को बिल्कुल भी परिभाषित न करें b, बस दो वैक्टर को सीधे plotफ़ंक्शन में अनामित करें । के c(l,3)लिए xaxpऔर का उपयोग करें yaxp। आप सिर्फ Fझूठ के लिए उपयोग कर सकते हैं , इसे परिभाषित करने की कोई आवश्यकता नहीं है। और एक नए फ़ंक्शन को परिभाषित करता है a(x,...)जो axis(x)लेबल, tck, आदि के लिए डिफ़ॉल्ट मान है, ताकि आपको उन सभी को दो बार निर्दिष्ट करने की आवश्यकता न हो।

— user2390246

आप axes=Fइसके बजाय उपयोग कर सकते हैं xaxt='n',yaxt='n'। और आप .5परिभाषित करते समय उपयोग करना भूल गए lहालांकि आपने बाद में उस चाल का उपयोग किया था।

— user2390246

वास्तव में, क्या होगा अगर आपने उन pesky से .5पूरी तरह से छुटकारा पाने के लिए सभी समन्वय मूल्यों को दोगुना कर दिया?

— user2390246

यदि आप पहले से ही .bmpफ़ाइल एक्सटेंशन को बंद करने जा रहे हैं , तो आप फ़ाइल को केवल नाम दे सकते हैं r।

— एमडी एक्सएफ

@ user2390246 - सुझाव के लिए बहुत धन्यवाद। संचयी रूप से 70 बाइट्स के आदेश पर बचाया गया। आर में गोल्फिंग में यह मेरा पहला प्रयास था, और आपने टायरों की बहुत सारी त्रुटियां देखीं, जो शायद मुझे देखनी चाहिए थीं। अगली बार मैं बेहतर जानता हूँ।

— CCB60

Answer 23

TI-BASIC, 218 140 137 बाइट्स

नोट: यह बाइट काउंट थोड़ा फुलाया हुआ है। कार्यक्रम केवल 85 टोकन का उपयोग करता है, लेकिन यह 137 बाइट्स में सहेजा गया है। इसके अलावा, यदि आप एक गैर-रंग कैलकुलेटर का उपयोग कर रहे हैं, तो आप एक और 4 टोकन बचा सकते हैं क्योंकि आपको रंग निर्दिष्ट नहीं करना है (जो डिफ़ॉल्ट रूप से नीला है), लेकिन मुझे नहीं पता कि उनकी स्क्रीन काफी बड़ी है यह चुनौती है क्योंकि मेरे पास कोई नहीं है।

प्राग्मैकर (138 बाइट्स, 86 टोकन):

{0,1,2,1,2}→L1
{0,0,0,2,1}→L2
.3→R
For(I,0,5
L₁(I)+.5→A
L₂(I)+.5→B
For(N,0,R,dX
√(R²-N²
Line(A+N,B-Ans,A+N,B+Ans,BLACK
Line(A-N,B-Ans,A-N,B+Ans,BLACK
End
End

उचित प्रदर्शन के लिए, इस प्रोग्राम के लिए आवश्यक है कि Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX को भी ठीक से सेट किया जाना चाहिए, लेकिन कैलकुलेटर आपके लिए ऐसा करता है जब आप कोई अन्य कंप्यूटर चर सेट करते हैं। मैं यह नहीं देख सका कि रैम में इस्तेमाल होने वाले ये वैरिएबल कितने स्पेस में हैं।

इसके अलावा, प्रारूप सेटिंग्स {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF} होनी चाहिए, लेकिन ये टॉगल किए गए मान हैं और सेटिंग के आधार पर किसी अतिरिक्त स्थान का उपभोग नहीं करते हैं।

Comments

सूची को नीचे लाने के लिए, आप इन्हें व्यक्त कर सकते हैं {0,1,2,1,2}और {0,0,0,2,1}फिर 0.5प्रत्येक आइटम में जोड़ सकते हैं ।

— wizzwizz4

कोशिश की, लेकिन यह सूचियों द्वारा उपयोग की जाने वाली रैम की मात्रा को नहीं बदले। हालाँकि, आपने मुझे रैम में सूचियों से छुटकारा पाने और उन्हें परिभाषित करने का विचार दिया, जब प्रोग्राम चलता है, तो रैम में 78 बाइट्स की बचत होती है।

— latias1290

गोल्फ लोगों में आदेश! बदलें L1और L2करने के लिए L₁और L₂, जब से तुम उन्हें पहले से ही इस्तेमाल करते हैं। मुझे लगता है कि आप हटा सकते हैं }, और L₁(I)+.5→A=> .5+L₁(Iऔर L₂(I)+.5→B=> .5+L₂(I→B।

— ज़ाचारि

Answer 24

आर, 119 114 111 बाइट्स

( मुझे 3 बाइट बचाने के लिए @JayCe की तुलना में )

अन्य R समाधान से कम नहीं है , लेकिन एक पूरी तरह से अलग दृष्टिकोण:

layout(matrix(c(1,9,2:8),3,,T))
par(mar=0*1:4)
for(i in 1:9){frame();if(i>4)points(.5,.5,,19,cex=29);box(fg=8)}

एक लेआउट का उपयोग करता है जिसमें 4 पहले प्लॉट खाली सेल होते हैं, और 5 अन्य उन में डॉट्स वाले होते हैं।

Comments

क्या मैं

— स्थैतिक

@JayCe वास्तव में, धन्यवाद!

— प्लेनैपस

Answer 25

एक्सेल VBA, 180 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन जो डिफ़ॉल्ट इनपुट वर्कशीट ऑब्जेक्ट ( Sheet1) के लिए कोई इनपुट और आउटपुट नहीं लेता है ।

Cells.RowHeight=48:Cells.Interior.Color=-1:[B2:D4].Borders.Color=7434613:For Each s In[{21,32,13,23,33}]:Sheet1.Shapes.AddShape(9,48*(s\10)+4,Mid(s,2)*48+4,40,40).ShapeStyle=8:Next

टिप्पणी संस्करण

Cells.RowHeight=48                      ''  Make the Cells square
Cells.Interior.Color=-1                 ''  Remove the default grid
[B2:D4].Borders.Color=7434613           ''  Create the 3x3 gray grid at range `B2:D4`
For Each s In [{21,32,13,23,33}]        ''  Assign and iterate over a list of where
                                        ''  to place the dots; This list is a range that 
                                        ''  is coerced into a numeric array

    Sheet1.Shapes.AddShape(         _   ''  Add a shape to the Sheet1 object
                9,                  _   ''  An Oval (msoShapeOval)
                48*(s\10)+4,        _   ''  At the calculated value from the left
                Mid(s,2)*48+4,      _   ''  At the calculated value from the top
                40,                 _   ''  that is 40 units wide
                40                  _   ''  and is 40 units tall
                ).ShapeStyle=8          ''  and is black filled with a black outline

Next                                    ''  repeat to end of list

उत्पादन

[{21,32,13,23,33}]ओवर का उपयोग करने के लिए -6 बाइट्सSplit("21 32 13 23 33")

-2 बाइट्स का उपयोग करने के लिए Mid(s,2)ओवर करने केRight(s,1)

(s\10)ओवर का उपयोग करने के लिए -3 बाइट्सLeft(s,1)

Answer 26

ऑक्टेव 107 94 103 बाइट्स

scatter([1:3,3,2],[1,1,1:3],1e5,zeros(5,3),'.');axis off;a=[1,7]/2;for i=.5:3.5;line(a,i);line(i,a);end

या

plot([1:3,3,2],[1,1,1:3],'k.','markersize',250);axis off;a=[1,7]/2;for i=.5:3.5;line(a,i);line(i,a);end

दोनों समाधान 103 बाइट्स हैं।

Comments

मेरा मानना ​​है कि डॉट्स का काला होना

— जरूरी है

आह, दिलचस्प, मटलब एक स्केलर को एक बिंदु के रूप में व्याख्या करता है, जैसा कि इसे प्रसारित करने के विपरीत है। तो इसके बजाय line([x1,x2],y)आपको करना होगाline([x1,x2],[y,y])

— टासोस पापस्टीलियनौ

Answer 27

ऐप्पल स्विफ्ट (आईओएस - कोरग्राफिक्स / क्वार्ट्ज़कोर) - 832 बाइट्स

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

UIGraphicsBeginImageContext(CGSize(width:60,height:60));let c=UIGraphicsGetCurrentContext()!;UIColor.lightGray.setStroke();c.addRect(CGRect(x:0,y:0,width:60,height:60));c.move(to: CGPoint(x:20,y:0));c.addLine(to: CGPoint(x:20,y:60));c.move(to: CGPoint(x:40,y:0));c.addLine(to: CGPoint(x:40,y:60));c.move(to: CGPoint(x:0,y:20));c.addLine(to: CGPoint(x:60,y:20));c.move(to: CGPoint(x:0,y:40));c.addLine(to: CGPoint(x:60, y:40));c.strokePath();UIColor.black.setFill();c.addEllipse(in:CGRect(x:22,y:2,width:16,height:16));c.addEllipse(in:CGRect(x:42,y:22,width:16,height:16));c.addEllipse(in:CGRect(x:2,y:42,width:16,height:16));c.addEllipse(in:CGRect(x:22,y:42,width:16,height:16));c.addEllipse(in:CGRect(x:42,y:42,width:16,height:16));c.fillPath();let i=UIGraphicsGetImageFromCurrentImageContext();sub.addSubview(UIImageView(image:i))

रुचि रखने वाले किसी भी व्यक्ति के लिए अधिक पठनीय संस्करण:

    UIGraphicsBeginImageContext(CGSize(width: 60, height: 60))
    let c = UIGraphicsGetCurrentContext()!

    UIColor.lightGray.setStroke()
    c.addRect(CGRect(x: 0, y: 0, width: 60, height: 60))
    c.move(to: CGPoint(x: 20, y: 0))
    c.addLine(to: CGPoint(x: 20, y: 60))
    c.move(to: CGPoint(x: 40, y: 0))
    c.addLine(to: CGPoint(x: 40, y: 60))
    c.move(to: CGPoint(x: 0, y: 20))
    c.addLine(to: CGPoint(x: 60, y: 20))
    c.move(to: CGPoint(x: 0, y: 40))
    c.addLine(to: CGPoint(x: 60, y: 40))
    c.strokePath()

    UIColor.black.setFill()
    c.addEllipse(in: CGRect(x: 22, y: 2, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 42, y: 22, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 2, y: 42, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 22, y: 42, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 42, y: 42, width: 16, height: 16))
    c.fillPath()

    let i = UIGraphicsGetImageFromCurrentImageContext()
    sub.addSubview(UIImageView(image: i))

यहाँ आईओएस सिम्युलेटर में उत्पादित आउटपुट है:

Answer 28

जूते के साथ रूबी, 118 अक्षर

Shoes.app{9.times{|i|
stroke gray
fill white
rect x=i%3*w=10,y=i/3*w,w,w
stroke fill black
oval x+2,y+2,7if 482[i]>0}}

मार्क थॉमस के रूबी समाधान पर RJHunter की टिप्पणी से उधार ली गई बिट चेकिंग ।

नमूना उत्पादन:

Answer 29

एसवीजी + एचटीएमएल, 146 138 135 133 बाइट्स

<svg>
<path fill=none stroke=#ccc d=m.5.5h30v30h-30zh10v30h10v-30zv10h30v10h-30 />
<path d=m11,1h9v9m1,1h9v9m-29,1h9v9m1-9h9v9m1-9h9v9>

उदार HTML पार्सर के लिए धन्यवाद, xmlns="http://www.w3.org/2000/svg"घोषणा को छोड़ दिया जा सकता है, साथ ही विशेषता उद्धरण और समापन टैग भी। यह संस्करण अन्य HTML समाधानों के कुछ मुद्दों को संबोधित करता है:

• एक "डॉट" को इसकी सेल का कम से कम 40% भरने की गारंटी है ()1)
• यह बाहरी ग्राफिक्स का उपयोग नहीं करता है, उदाहरण के लिए फ़ॉन्ट ग्लिफ़ (§2, graphics6)
• ग्रिड पूरी तरह से चौकोर है ((5)

8 बाइट्स को इस तथ्य का फायदा उठाकर शेव करें कि भरे जाने के लिए सबपैथ को बंद करने की आवश्यकता नहीं है ।

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

कोडगॉल्फ पर एक और उत्तर से सीखना संपादित करें , मैंने अंतिम के 9 />साथ बदल दिया है 9>। यह सभी परीक्षण किए गए ब्राउज़रों में ठीक काम करता है।

Answer 30

पायथन 3 + पायगेम, 238 बाइट्स

from pygame import*
d=display
s=d.set_mode([55]*2)
s.fill([255]*3)
f=lambda*a:draw.line(s,[128]*3,*a)
for x in[0,18,36,54]:
 f((x,0),(x,55));f((0,x),(55,x))
for x,y in zip([3,5,1,3,5],[1,3,5,5,5]):draw.circle(s,[0]*3,(x*9,y*9),7)
d.flip()

प्रतीत होता है कि मनमाना स्थिरांक मेरी ओर से हैं जो बाइट का त्याग किए बिना छवि को यथासंभव बड़ा बनाने की कोशिश कर रहे हैं।

गैर-मुद्रण वर्णों के साथ, 229 बाइट्स

from pygame import*
d=display
s=d.set_mode([55]*2)
s.fill([255]*3)
f=lambda*a:draw.line(s,[128]*3,*a)
for x in b'\0␒$6':
 f((x,0),(x,55));f((0,x),(55,x))
for x,y in zip(b'␃␅␁␃␅',b'␁␃␅␅␅'):draw.circle(s,[0]*3,(x*9,y*9),7)
d.flip()

मैंने सूचियों को बाइट शाब्दिकों से बदल दिया, जो वर्णों के एक समूह को बचाता है, लेकिन गैर-मुद्रण वर्णों को यहां ठीक से प्रदर्शित नहीं किया जा सकता है। मैंने गैर-मुद्रण वर्णों को प्रदर्शन उद्देश्यों के लिए उनके चित्रमय समकक्षों U + 2400-U + 2421 के साथ प्रतिस्थापित किया।