दक्षिण कोरियाई झंडा खींचें

58

जब मैं इस सवाल पर अड़ गया तो मुझे याद आया कि मैंने एक बार दक्षिण कोरियाई ध्वज के निर्माण के लिए सटीक नियम भी देखे थे। और यह काफी अलग निर्माण है।

यहाँ छवि विवरण दर्ज करें

स्रोत: विकिपीडिया

तो आप अब इस का एक सटीक निर्माण करना चाहते हैं!

विशिष्टता

आप वेक्टर या रेखापुंज ग्राफिक्स का उपयोग करके ध्वज को फ़ाइल या स्क्रीन पर प्रस्तुत कर सकते हैं। यदि आपका आउटपुट rasterised है, तो आपकी छवि में 450x300 पिक्सेल या उससे अधिक के आयाम होने चाहिए।

सभी लंबाई अनुपात और पदों को निम्न चित्र में दिखाए गए अनुसार होना चाहिए:

यहाँ छवि विवरण दर्ज करें

स्रोत: विकिपीडिया

ध्यान दें कि दो छोटे वृत्त के केंद्र विकर्ण के साथ संरेखित होते हैं।

रंगों के लिए, आपको निम्नलिखित पैलेट का उपयोग करना चाहिए:

  • सफ़ेद: # फाफ
  • काला: # 000000
  • लाल: # C60C30
  • नीला: # 003478

काली सीमा को तब तक नहीं खींचना चाहिए जब तक कि आपका ड्राइंग सिस्टम आपको तकनीकी कारणों से 3: 2 कैनवास निर्दिष्ट करने की अनुमति न दे (अन्यथा, आपको 3: 2 कैनवास का उपयोग करना चाहिए और ध्वज को सभी को भरना चाहिए)। यदि आपको सीमा को जोड़ने की आवश्यकता है, तो यह मनमाने ढंग से मोटा हो सकता है - ध्वज को काली सीमा के अंदर सख्ती से माना जाना चाहिए । किसी भी अन्य मदद लाइनों या लंबाई संकेतक नहीं खींचा जाना चाहिए। यानी, पहली छवि में झंडा बिल्कुल दिखाई देना चाहिए।

स्कोरिंग

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

चेतावनी के एक शब्द के रूप में, मौजूदा संपीड़न (जैसे एक संपीड़ित जीआईएफ को एम्बेड करना) का उपयोग करना कई मानक खामियों में पड़ता है ।

code-golf  graphical-output  kolmogorov-complexity  geometry 
— मार्टिन एंडर
स्रोत
2
दिलचस्प बात यह है कि कोरियाई ध्वज में बाइनरी नंबर सिस्टम ( britton.disted.camosun.bc.ca/jbbinflag.htm ) का प्रारंभिक रूप होता है
— ब्रिटिश
क्या हमें उस समय सीमा खींचनी होगी जब हम ध्वज से बड़ा HTML पृष्ठ का उपयोग कर रहे हों, श्वेत होने के कारण कैनवास / तत्व का आकार ध्वज के समान होने पर भी कोई अलगाव दिखाई नहीं देता
— ऑप्टिमाइज़र
@ ओप्टिमाइज़र, नहीं, यदि कैनवास इस तरह से बंधा हुआ है, जिसे किसी तरह से दृश्यमान बनाया जा सकता है (जैसे आपके ब्राउज़र के "निरीक्षण तत्व" के हाइलाइटिंग से), तो आपको सीमा की आवश्यकता नहीं है। काली सीमा केवल उस दुर्लभ मामले में खींची जानी चाहिए जहां कैनवास की सीमा को तकनीकी रूप से परिभाषित नहीं किया जा सकता है।
— मार्टिन एंडर
3
मुझे लगता है कि CountryData["ROK","Flag"]गिनती नहीं है?
— वचर्जिन
— सर्गियोल

जवाबों:

13

PHP / HTML / SVG, 324

(लेगबिलिटी के लिए लाइन ब्रेक जोड़ा गया)

<?=gzinflate(base64_decode('tVHBioMwFPyVwF5WSOzLi/tswQjdu9cevIk1KqtriaFd9utrgpSWFva0PPImMwzDkGTz
uWXnvrl8Tj8aOPAUebLNs5Y5W33PZrKjtpOrXPOuVEy7KMiD54mKMY3yrO5tPTTMaonM9MOg32qCWgHb5Nmpch076kIih/2y
PC4jRRCIU6BhbkwGV7lmAagk3d5nCfwQdKByVBwOFLagQu6exZLNzk5fjU+B9S4u/dF1Gh/apRw6Cb83uzHm0S69/cWbSIkx
YfSf5QT6dkk5UoACIeAfXTftepb/za8='));

संपीड़ित डेटा उसी एसवीजी डेटा के रूप में फैलता है, जैसा कि नीचे दिखाए गए मेरे पहले के उत्तर में था, लेकिन संपीड़न में सहायता के लिए दो बदलावों के साथ:

  1. दो <use>खंड खंड की मूल सामग्री तक विस्तारित हैं <defs>। यह स्रोत पाठ को लंबा बनाता है, लेकिन एन्ट्रापी को कम करता है इसलिए यह बेहतर तरीके से संपीड़ित करता है।

  2. पहले <g>तत्व में, मैं बदल transform=translate(36,24)rotate(33.69)गया transform=rotate(33.69)translate(43.27)। यह ज्यामितीय रूप से एक ही प्रभाव है, लेकिन बेहतर संपीड़ित करता है क्योंकि अनुक्रम ><g transform=rotate(अब दो बार दिखाई देता है।

डिफ़ॉल्ट रूप से, PHP इस के रूप में काम करेगी Content-Type: text/html, इसलिए अमान्य XML सिंटैक्स समस्या नहीं होनी चाहिए।

एसवीजी / एचटीएमएल, 463

एचटीएमएल पार्सर सही सिंटैक्स के बारे में बहुत अधिक नहीं है, इसलिए हम मापदंडों में उद्धरण चिह्नों के साथ दूर कर सकते हैं जब तक कि उनके पास कोई स्थान न हो। इसे थोड़ा और जावास्क्रिप्ट के साथ नीचे निचोड़ना संभव होना चाहिए।

<svg viewBox=0,0,72,48><defs><path d=M-25-6V6Zm3,0V6m3,0V-6M19-6V6Zm3,0V6m3,0V-6Z stroke=#000
stroke-width=2 id=p /></defs><g transform=translate(36,24)rotate(33.69)><circle r=12 fill=#c60c30
/><path d=M12,0A12,12,0,0,1-12,0A6,6,0,0,0,0,0A6,6,0,0,1,12,0Z fill=#003478 /><use xlink:href=#p
/><path d=M17,0h10z stroke=#fff stroke-width=1 /><g transform=rotate(112.62)><use xlink:href=#p
/><path d=M-27,0h4Zm6,0h4ZM20,0h4Z stroke=#fff stroke-width=1 /></g></g></svg>
स्निपेट का विस्तार करें

— बग़ल में ossifrage
स्रोत
44

पायथन + पाइकैरो, 371 370 है 366 बाइट्स

झंडा

from cairo import*
p=3.141593
c=Context(SVGSurface("F",12,8))
C=c.set_source_rgb;R=c.rectangle;T=c.rotate;F=c.fill
C(1,1,1);R(0,0,12,8);F()
c.translate(6,4);T(.588);b=3188
for o in[(0,.2,.47),(.77,.05,.19)]*2:C(*o);i=b/2%2;b+=1;c.arc(i,0,2-i,0,p+i*p);F();T(p)
C(0,0,0)
for x in(p,1.966)*2:
 for y in.5,0,1:
    for z in-1,1:R(3+y,-z,1./3,z*(2.75+b%2)/3);F()
    b/=2
 T(x)

नाम के एक छोटे SVG फ़ाइल को आउटपुट करता है F।

— पक्ष
स्रोत
C(*[.77,0,.05,.2,.19,.47][i::2])से कम हैC(*[(.77,.05,.19),(0,.2,.47)][i%2])
— isaacg
s=SVGSurface("F",12,8);c=Context(s)सिर्फ लिखने के बजाय क्यों लिखते हैं c=Context(SVGSurface("F",12,8))?
— लिली चुंग
@IstvanChung अच्छी बात है।
— एल
32

HTML + CSS, 966 906 843 792 762 बाइट्स

कभी भी विजेता नहीं, लेकिन CSS में बहुत सारी मजेदार ड्राइंग। यह हालांकि बहुत गोल्फ हो सकता है।

CSS, HTML :

*{position:fixed}a{background:linear-gradient(0deg,#003478 50%,#C60C30 50%);width:2in;height:2in;transform:rotate(.6rad);top:1in;left:2in}d,e{width:50%;height:50%;background:#C60C30;left:0;top:25%}a,d,e{border-radius:50%}d{background:#003478;left:50%}b,i{width:1in;height:26em;top:-1em;left:15em;transform:rotate(.98rad)}g,f,k,j{width:1in;height:17%;background:repeating-linear-gradient(0deg,#000,#000 1em,#fff 1em,#fff 1.5em);bottom:0;left:0}g,j,p{top:-.5em}b{transform:rotate(-.98rad)}c,p,v,x{height:2em;width:.5em;background:#fff;transform:rotate(.98rad)}p{top:2.8in;left:28em;transform:rotate(-.98rad) scale(1,4)}x{top:3.9em;left:28.4em}c,v{top:23.8em;transform:none}c{top:3.5em}body{height:4in;width:6in;border:1px solid
<a><d><e></a><b><f><g></b><i><j><k></i><p></p><x><v><c
स्निपेट का विस्तार करें

;border:1px solidशो के लिए ही है क्योंकि <body>टैग में स्पष्ट सीमाएं हैं जो ओपी द्वारा बताए गए इंस्पेक्टर या इसी तरह के औजारों द्वारा देखी जा सकती हैं

नोट केवल गैर-विशिष्ट विशिष्ट परिवर्तन और ग्रेडिएंट के उपयोग के कारण फ़ायरफ़ॉक्स (या क्रोम कैनरी / देव) में काम करता है।

इसे एक्शन में देखें

— अनुकूलक
स्रोत
मुझे लगता है कि आपको अपने कैरेक्टर काउंट में <लिंक> या <स्टाइल> टैग शामिल करने चाहिए। आप कुछ वर्ण बचा सकते हैं: सीएसएस में 0deg-> 0(दो बार) और हटाने left:0से a:before। HTML में आप उपयोग कर सकते हैं <p><ul></ul>। ( <p>पहले स्पष्ट रूप से बंद हो जाएगा <ul>)
— ग्रोनोस्तज
1
फ़ायरफ़ॉक्स 32 में काम करता है। सफारी 7.1 में शानदार ढंग से विफल रहता है।
— 200_सफल
1
CSS के लिए LESS या SASS का उपयोग करें जो आपको इसे थोड़ा छोटा करने के लिए काफी विकल्प देना चाहिए। इसके अतिरिक्त :before{content:''}और :after{content:''}केवल एक और तत्व जोड़ने से अधिक है (इसके बावजूद यह वास्तव में बेहतर दिख रहा है)।
— डेविड मुल्डर
@DavidMulder मैं छोटे कोड के बजाय इसमें मजेदार कारक चाहता था। लोग शुद्ध CSS से अधिक आसानी से LESS या SASS से संबंधित हो सकते हैं :)
— अनुकूलक
नवीनतम क्रोम में भी काम करता है। @ 200_success आपको इसे सफ़र में काम करने में सक्षम होना चाहिए , -webkit-सभी को जोड़ने से पहले transform:, लेकिन यह कहने की ज़रूरत नहीं है कि यह काफी लंबा हो जाएगा!
— दरवाज़े
20

बीबीसी बेसिक, 349 343 ASCII वर्ण, टोकन फ़ाइल आकार 330

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर एमुलेटर डाउनलोड करें

  p=1049q=25r=100VDU4118;275;-1,49,3076;19,7,-1;-1;531;255;7693;q;40;0;q,97,1200;800;29,640;400;
  FORa=38TO56STEP0.01x=r*COS(a)y=r*SIN(a)b=a*7DIV44/2IFb=3.5z=y<0ELSEz=x>0
  VDU18;1,p;-x;-y;q,153,r;0;18;2,p;x;y;q,153,r;0;18;0
  IFABS(y)DIV1=56VDUp;x*b+y;y*b-x;q;x/3;y/3;q,113,-2*y;2*x;18;7:b-=0.1VDUp;x*b+y/12;y*b-x/12;q;x/2;y/2;q,112-z,-y/6;x/6;
  NEXT

सही रंगों का उपयोग करने से बहुत कुछ जोड़ा गया, लेकिन सभी ग्राफिक्स को कच्चे वीडीयू कोड के लिए कमांड करने से मूल अक्षर की तुलना में कुल 6 वर्णों की बचत होती है। बीबीसी माइक्रो पर सभी ग्राफिक्स मशीन-विशिष्ट ASCII नियंत्रण कोड के माध्यम से किया जाता है, इसलिए उच्च-स्तरीय ग्राफिक्स आदेशों का उपयोग करने के बजाय आप वीडीयू नियंत्रक को सीधे बाइट्स फ़ीड कर सकते हैं (आमतौर पर कम लेकिन पठनीयता के लिए महान व्यय पर)। अल्पविराम के बजाय अर्धविराम में समाप्त होने वाला मान 2 बाइट्स का 16-बिट थोड़ा-एंडियन प्रतिनिधित्व है।

अनप्लग्ड संस्करण

  MODE16
  VDU19,1,-1,49,4,12                :REM adjust shade of red 
  VDU19,7,-1,-1,-1,-1               :REM adjust shade of white to full brightness (63 is 2's complement representation of -1
  VDU19,4,-1,0,13,30                :REM adjust shade of blue
  RECTANGLEFILL40,0,1200,800        :REM plot background rectangle
  ORIGIN640,400
  FORa=38TO56STEP0.01
    x=COS(a)*100
    y=SIN(a)*100
    GCOL1:CIRCLEFILL-x,-y,100       :REM red
    GCOL4:CIRCLEFILLx,y,100         :REM blue
    GCOL0                           :REM black
    b=a*7DIV44/2                    :REM divide a by 2*(22/7) to get integer representation, then divide by 2 again.
    IFb=3.5THENz=y<0ELSEz=x>0       :REM decide whether to cut bar
    REM If the angle is correct (100*sin(a) = 56) draw bar. If required, cut out the middle of the bar.
    IFABS(INT(y))=56 MOVEx*b+y,y*b-x:MOVEBY x/3,y/3:PLOT113,-2*y,2*x:GCOL7:b-=0.1:MOVEx*b+y/12,y*b-x/12:MOVEBY x/2,y/2:IFz PLOT113,-y/6,x/6
  NEXT

कार्यक्रम की शुरुआत में मैं मूल को स्क्रीन के केंद्र में ले जाता हूं।

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

जब कोण सही होता है, तो मैं एक बार खींचता हूं। वेक्टर x, y वर्तमान छोटे नीले वृत्त को खींचने के लिए यह बताने का कार्य करता है कि बार किस दिशा में होना चाहिए। 3 क्रांतियों में से प्रत्येक के लिए, पूर्णांक के एक अलग मूल्य की a*7DIV44गणना की जाती है, जो बताता है कि क्या पहली, दूसरी या तीसरी पट्टी खींची जानी चाहिए, इसके आंतरिक किनारे 6 / 8,7 / 8 या 8/8 इकाइयों से केंद्र ( प्रश्न युक्ति में प्रयुक्त इकाइयों के अनुसार।) क्योंकि कार्यक्रम इकाइयाँ कल्पना में उन लोगों में से 1/4 हैं, यह अभी भी एक अर्ध-इकाई है, इसलिए हम बार-बार होने से बचने के लिए चर ´b´ में बचत करने से पहले 2 से फिर से विभाजित करते हैं। बाद में।

सलाखों को ठोस खींचा जाता है, फिर यदि आवश्यक हो, तो बीच को हटा दिया जाता है। यह किंक को आधा-छड़ में शामिल होने से रोकता है। चर z इंगित करता है कि क्या एक बार काट दिया जाना चाहिए। अर्थात्, जब y मध्य सलाखों के लिए नकारात्मक है और जब x अन्य सलाखों के लिए सकारात्मक है।

MOVEएक निरपेक्ष चाल है। MOVEBYएक सापेक्ष चाल है। PLOT133पिछले दो ग्राफिक्स कर्सर पदों पर विचार करता है, साथ ही नया एक निर्दिष्ट (सापेक्ष निर्देशांक में) एक समांतर चतुर्भुज के तीन कोनों के रूप में, और उस समांतर चतुर्भुज को प्लॉट करता है।

आउटपुट (और भाषा सीमाओं की चर्चा)

मैंने 1280x800 तार्किक पिक्सेल = 640x400 भौतिक पिक्सेल की एक स्क्रीन मोड का चयन किया, जिसकी डिफ़ॉल्ट रूप से एक काली पृष्ठभूमि है। इस पर मैं एक सफेद आयत -600 से खींचता हूं, -400 से 600,400 तक मेरे "कैनवास" के रूप में कार्य करता है।

बीबीसी बेसिक एक रिप्रोग्रामेबल पैलेट से एक बार में 16 रंगों को संभाल सकता है। लेकिन यह केवल 18-बिट रंग का समर्थन करता है, जबकि प्रश्न रंगों को 24-बिट के रूप में निर्दिष्ट करता है। जितना संभव हो उतना रंग।

यहाँ छवि विवरण दर्ज करें

— स्तर नदी सेंट
स्रोत
2
मैंने सीमा के संबंध में युक्ति को थोड़ा सा हटा दिया है। जिस तरह से आपने इसे संभाला है वह बहुत ज्यादा है जैसा कि मैंने इरादा किया है।
— मार्टिन एंडर
16

अजगर 3 कछुआ ( 552 549 बाइट्स)

झंडा

( पूर्ण आकार की छवि )

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

(इसके अलावा, मुझे लग रहा है कि यह वास्तव में कुछ ब्राउज़रों पर काम नहीं कर सकता है ...)

function out(a){var b=document.getElementById("output");b.innerHTML+=a}function builtinRead(a){if(void 0===Sk.builtinFiles||void 0===Sk.builtinFiles.files[a])throw"File not found: '"+a+"'";return Sk.builtinFiles.files[a]}
$(document).ready(function run(){Sk.canvas="canvas";Sk.configure({output:out,read:builtinRead});try{Sk.importMainWithBody("<stdin>",!1,'import turtle\nimport math\nt=turtle.Turtle()\nt.speed(9)\nR="#c60c30"\nr=56.3\nk=0.6\ns=60*k\noffsetx,offsety=-215,-145\nt.up()\nt.goto(offsetx,offsety)\nt.down()\ndef q():t.rt(90)\ndef Q():t.lt(90)\ndef K():t.color("black");t.begin_fill();q()\ndef A(g,G):t.fd(g);Q();t.fd(G);Q();t.fd(g);Q();t.fd(G);Q()\ndef E():t.up();t.fd(s);t.down();Q();t.end_fill();t.up();t.fd(30*k);t.down();\ndef i():K();t.up();t.bk(s);t.down();A(120*k,20*k);E()\ndef I():K();t.up();t.fd(5*k);t.down();A(55*k,20*k);t.up();t.bk(65*k);t.down();A(55*k,20*k);E()\ndef C():t.circle(120*k,180)\nA(720*k,480*k)\nt.seth(r)\nt.up()\nt.goto(459.8*k+offsetx,173.4*k+offsety)\nt.down()\nt.color(R)\nt.begin_fill()\nC()\nt.end_fill()\nt.begin_fill()\nt.color("#003478")\nC()\nt.circle(s)\nt.end_fill()\nt.color(R)\nC()\nt.begin_fill()\nt.circle(s)\nt.end_fill()\nq()\nt.up()\nt.fd(s)\nt.down()\ni()\ni()\ni()\nt.up()\nt.bk(530*k)\nt.down()\nI()\nI()\nI()\nt.up()\nt.fd(170*k)\nt.rt(2*r)\nt.fd(180*k)\nt.down()\nI()\ni()\nI()\nt.up()\nt.bk(530*k)\nt.down()\ni()\nI()\ni()\n')}catch(a){throw Error(a.toString());}})
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script><script src="http://www.skulpt.org/static/skulpt.min.js" type="text/javascript"></script><script src="http://www.skulpt.org/static/skulpt-stdlib.js" type="text/javascript"></script>
<canvas height="320" width="480" id="canvas" style="border:1px solid gray">Your browser does not support HTML5 Canvas!</canvas>
स्निपेट का विस्तार करें

वास्तविक कोड:

import turtle as t
b=t.begin_fill
c=t.circle
e=t.end_fill
f=t.fillcolor
R="#c60c30"
r=56.3
F=t.fd
B=t.bk
s=60
def q():t.rt(90)
def Q():t.lt(90)
def K():f(0,0,0);b();q()
def A(g,G):exec("F(g);Q();F(G);Q();"*2)
def E():F(s);Q();e();F(30)
def i():K();B(s);A(120,20);E()
def I():K();F(5);A(55,20);B(65);A(55,20);E()
def C():c(120,180)
A(720,480)
t.seth(r)
t.up()
t.goto(459.8,173.4)
f(R)
b()
C()
e()
b()
f("#003478")
C()
c(s)
e()
C()
f(R)
b()
c(s)
e()
q()
F(s)
i()
i()
i()
B(530)
I()
I()
I()
F(170)
t.rt(2*r)
F(180)
I()
i()
I()
B(530)
i()
I()
i()
t.ht()

कछुए के ऐसे धीमे होने के बाद से, यदि आप तुरंत परिणाम चाहते हैं तो आप t.tracer(0)स्क्रिप्ट चलाने से पहले पहली पंक्ति के बाद जोड़ सकते हैं ।

नोट: किसी कारण से कछुआ ड्राइंग करता है जो अतिरिक्त ब्लैक पिक्सल्स की तरह दिखता है भले ही मैंने पहले ही फोन किया हो up(), और मुझे पता नहीं क्यों ...

— Sp3000
स्रोत
मेरा मानना ​​है कि किसी ने स्टैक स्निपेट्स पोस्ट पर पायथन (कछुए के साथ) को लागू किया; यदि आप यह जानना चाहते हैं कि आप इस नई सुविधा का उपयोग करने वाले पहले व्यक्ति कैसे हो सकते हैं! ;)
— दरवाज़े
@Doorknob मुझे अपने आधे कोड को नष्ट करने के लिए नष्ट करना पड़ा, जैसा कि मैं चाहता था कि वह भी कर सकता है, लेकिन कम से कम यह नेत्रहीन अब पायथन की तरह ही करता है। (लेकिन यह किसी कारण से मेरे क्रोम पर काम नहीं करता है ...)
— Sp3000
2
Chrome iOS पर ठीक काम करना खुशी है कि किसी को मेरी परियोजना के लिए उपयोग मिला है, हालांकि :)
— ArtOfCode
14

HTML + ES6, 388

<canvas id=D width=576 height=384><script>c=D.getContext('2d')
T=x=>c.translate(x*72,x*48)
R=(x,y)=>T(4)+c.rotate(x*.59)+T(-4)+eval('for(i=j=0;i*j<6;i+=(j^=1))c.fillRect(72+24*i+(i>2)*288,144+j*52,16,44+52*(y>>i&1-j))')
A=(w,x,y,z)=>(c.fillStyle=c.fill()+c.beginPath()||w)*c.arc(x*4,192-y,48*y,0,3.1,z)||A
R(-1,21)
R(2,7)
A(r='#C60C30',72,2,1)('#003478',72,2)(0,84,1,1)(r,60,1)()</script>
स्निपेट का विस्तार करें

यदि आपका ब्राउज़र ES6 का समर्थन करता है, तो आप इसे JSFiddle पर देख सकते हैं या स्निपेट चला सकते हैं ।

यह कुछ मूल आकृतियों से ध्वज का निर्माण करता है, कोणों को ध्यान में रखते हुए पहले कैनवास को घुमाता है।

— gRC
स्रोत
बस एक नोट यह क्रोम 39 में काम नहीं करता है, एफएफ> 29 में ठीक काम करता है।
— जेबीसीपी
<canvas width=576 height=384 id=D><script>c=D.getContext('2d')9 बाइट्स कम है। इसके अलावा, चूंकि पूरा पृष्ठ सफेद है, मुझे लगता है कि आपको सीमा खींचने की आवश्यकता है।
— ऑप्टिमाइज़र
@ ऑप्टिमाइज़र थैंक्स। जैसा कि मैं इसे समझता हूं, सीमा की आवश्यकता तभी होती है जब आपके पास एक अनंत कैनवास हो।
— grc
5
आप स्टैक स्निपेट्स के साथ यह कोशिश कर सकते हैं!
— बीटा डेके
@ BetaDecay ने वास्तव में काम किया: o
— grc
6

गणितज्ञ 404 450

b=1&~Array~13;a=ReplacePart[b,7-> 0];d=Disk;r=RGBColor;
z@{q_,p_,s_}:=ArrayPlot[{q,q,{},p,p,{},s,s},Frame-> False,ImageSize-> 155];
m=r@@{0,.2,.5};
o=r@@{.8,0,.2};
t=-19.1;u=-12.75;v=-5;q=-3.33;
Graphics[{Line[{{-36,-24},{36,-24},{36,24},{-36,24},{-36,-24}}],
Inset[Rotate[z@#,#2 125 Degree],#3]&@@@{{{b,a,b},1,{t,u}},{{a,b,a},1,{-t,-u}},
{{a,a,a},-1,{-t,u}},{{b,b,b},-1,{t,-u}}},
{o,d[{0,0},12,{-.2 Pi,.8Pi}],m, d[{0,0},12,{.8Pi,1.8Pi}],o,d[{v,-q},6],m,d[{-v,q},6]}}]

झंडा

— DavidC
स्रोत
3

C ++ TOO LARGE

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

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

Ungolfed मुख्य कोड (बाकी लाइब्रेरी बहुत बड़ी है, इस पर गोल्फ करना मायने नहीं रखता है)

#include "PPMDraw.h"
#include <iostream>

int main(){
    std::cout << "Drawing Korean Flag" << std::endl;

    int scale = 150;
    int width = 3 * scale;
    int height = 2 * scale;

    int xc = width/2;
    int yc = height/2;

    // coords for the bar corners
    float nwax = -0.773; float nway = -0.813;
    float nwbx = -0.707; float nwby = -0.773;
    float nwcx = -1.000; float nwcy = -0.360;
    float nwdx = -1.050; float nwdy = -0.400;
    float nwex = -0.667; float nwey = -0.747;
    float nwfx = -0.613; float nwfy = -0.693;
    float nwgx = -0.880; float nwgy = -0.293;
    float nwhx = -0.947; float nwhy = -0.333;
    float nwix = -0.560; float nwiy = -0.667;
    float nwjx = -0.507; float nwjy = -0.627;
    float nwkx = -0.773; float nwky = -0.227;
    float nwlx = -0.840; float nwly = -0.267;

    float neax = 0.747; float neay = -0.813;
    float nebx = 0.867; float neby = -0.627;
    float necx = 0.813; float necy = -0.587;
    float nedx = 0.680; float nedy = -0.773;
    float neex = 0.893; float neey = -0.587;
    float nefx = 1.030; float nefy = -0.400;
    float negx = 0.960; float negy = -0.360;
    float nehx = 0.840; float nehy = -0.547;
    float neix = 0.640; float neiy = -0.747;
    float nejx = 0.920; float nejy = -0.333;
    float nekx = 0.853; float neky = -0.293;
    float nelx = 0.587; float nely = -0.693;
    float nemx = 0.533; float nemy = -0.667;
    float nenx = 0.667; float neny = -0.493;
    float neox = 0.600; float neoy = -0.440;
    float nepx = 0.480; float nepy = -0.627;
    float neqx = 0.693; float neqy = -0.440;
    float nerx = 0.813; float nery = -0.267;
    float nesx = 0.747; float nesy = -0.227;
    float netx = 0.627; float nety = -0.400;

    float swax = -0.773; float sway = 0.200;
    float swbx = -0.507; float swby = 0.613;
    float swcx = -0.560; float swcy = 0.653;
    float swdx = -0.840; float swdy = 0.253;
    float swex = -0.880; float swey = 0.280;
    float swfx = -0.760; float swfy = 0.453;
    float swgx = -0.813; float swgy = 0.493;
    float swhx = -0.947; float swhy = 0.320;
    float swix = -0.733; float swiy = 0.507;
    float swjx = -0.613; float swjy = 0.680;
    float swkx = -0.667; float swky = 0.720;
    float swlx = -0.787; float swly = 0.547;
    float swmx = -0.987; float swmy = 0.347;
    float swnx = -0.707; float swny = 0.760;
    float swox = -0.773; float swoy = 0.800;
    float swpx = -1.053; float swpy = 0.387;

    float seax = 0.747; float seay = 0.200;
    float sebx = 0.813; float seby = 0.253;
    float secx = 0.693; float secy = 0.427;
    float sedx = 0.627; float sedy = 0.387;
    float seex = 0.853; float seey = 0.280;
    float sefx = 0.920; float sefy = 0.320;
    float segx = 0.800; float segy = 0.507;
    float sehx = 0.733; float sehy = 0.453;
    float seix = 0.960; float seiy = 0.347;
    float sejx = 1.036; float sejy = 0.387;
    float sekx = 0.893; float seky = 0.573;
    float selx = 0.840; float sely = 0.520;
    float semx = 0.600; float semy = 0.427;
    float senx = 0.667; float seny = 0.467;
    float seox = 0.547; float seoy = 0.653;
    float sepx = 0.480; float sepy = 0.613;
    float seqx = 0.707; float seqy = 0.493;
    float serx = 0.773; float sery = 0.547;
    float sesx = 0.640; float sesy = 0.733;
    float setx = 0.547; float sety = 0.680;
    float seux = 0.813; float seuy = 0.573;
    float sevx = 0.880; float sevy = 0.613;
    float sewx = 0.747; float sewy = 0.800;
    float sexx = 0.693; float sexy = 0.747;

    PPMDraw flag = PPMDraw(width, height);
    flag.fill(0, 0, 0);

    // draw white circle in middle
    flag.set_color(255, 255, 255);
    flag.draw_fill_circle(xc, yc, scale/2);

    // draw red and blue portions of circle
    flag.set_color(255, 0, 0);
    flag.draw_fill_circle(xc - .21*scale, yc - .14*scale, scale/3.9);
    flag.set_color(0, 0, 255);
    flag.draw_fill_circle(xc + .21*scale, yc + .14*scale, scale/3.9);
    flag.set_color(255, 0, 0);
    flag.recursive_fill(xc + .21*scale, yc - .21*scale);
    flag.set_color(0, 0, 255);
    flag.recursive_fill(xc - .21*scale, yc + .21*scale);

    // draw the northwest bars
    flag.set_color(255, 255, 255);

    flag.draw_line(xc + nwax*scale, yc + nway*scale, xc + nwbx*scale, yc + nwby*scale);
    flag.draw_line(xc + nwax*scale, yc + nway*scale, xc + nwdx*scale, yc + nwdy*scale);
    flag.draw_line(xc + nwbx*scale, yc + nwby*scale, xc + nwcx*scale, yc + nwcy*scale);
    flag.draw_line(xc + nwcx*scale, yc + nwcy*scale, xc + nwdx*scale, yc + nwdy*scale);

    flag.draw_line(xc + nwex*scale, yc + nwey*scale, xc + nwfx*scale, yc + nwfy*scale);
    flag.draw_line(xc + nwex*scale, yc + nwey*scale, xc + nwhx*scale, yc + nwhy*scale);
    flag.draw_line(xc + nwfx*scale, yc + nwfy*scale, xc + nwgx*scale, yc + nwgy*scale);
    flag.draw_line(xc + nwhx*scale, yc + nwhy*scale, xc + nwgx*scale, yc + nwgy*scale);

    flag.draw_line(xc + nwix*scale, yc + nwiy*scale, xc + nwjx*scale, yc + nwjy*scale);
    flag.draw_line(xc + nwix*scale, yc + nwiy*scale, xc + nwlx*scale, yc + nwly*scale);
    flag.draw_line(xc + nwjx*scale, yc + nwjy*scale, xc + nwkx*scale, yc + nwky*scale);
    flag.draw_line(xc + nwlx*scale, yc + nwly*scale, xc + nwkx*scale, yc + nwky*scale);
    //NE
    flag.draw_line(xc + neax*scale, yc + neay*scale, xc + nebx*scale, yc + neby*scale);
    flag.draw_line(xc + neax*scale, yc + neay*scale, xc + nedx*scale, yc + nedy*scale);
    flag.draw_line(xc + nebx*scale, yc + neby*scale, xc + necx*scale, yc + necy*scale);
    flag.draw_line(xc + necx*scale, yc + necy*scale, xc + nedx*scale, yc + nedy*scale);

    flag.draw_line(xc + neex*scale, yc + neey*scale, xc + nefx*scale, yc + nefy*scale);
    flag.draw_line(xc + neex*scale, yc + neey*scale, xc + nehx*scale, yc + nehy*scale);
    flag.draw_line(xc + nefx*scale, yc + nefy*scale, xc + negx*scale, yc + negy*scale);
    flag.draw_line(xc + nehx*scale, yc + nehy*scale, xc + negx*scale, yc + negy*scale);

    flag.draw_line(xc + neix*scale, yc + neiy*scale, xc + nejx*scale, yc + nejy*scale);
    flag.draw_line(xc + neix*scale, yc + neiy*scale, xc + nelx*scale, yc + nely*scale);
    flag.draw_line(xc + nejx*scale, yc + nejy*scale, xc + nekx*scale, yc + neky*scale);
    flag.draw_line(xc + nelx*scale, yc + nely*scale, xc + nekx*scale, yc + neky*scale);

    flag.draw_line(xc + nemx*scale, yc + nemy*scale, xc + nenx*scale, yc + neny*scale);
    flag.draw_line(xc + nemx*scale, yc + nemy*scale, xc + nepx*scale, yc + nepy*scale);
    flag.draw_line(xc + nepx*scale, yc + nepy*scale, xc + neox*scale, yc + neoy*scale);
    flag.draw_line(xc + nenx*scale, yc + neny*scale, xc + neox*scale, yc + neoy*scale);

    flag.draw_line(xc + neqx*scale, yc + neqy*scale, xc + nerx*scale, yc + nery*scale);
    flag.draw_line(xc + neqx*scale, yc + neqy*scale, xc + netx*scale, yc + nety*scale);
    flag.draw_line(xc + nerx*scale, yc + nery*scale, xc + nesx*scale, yc + nesy*scale);
    flag.draw_line(xc + netx*scale, yc + nety*scale, xc + nesx*scale, yc + nesy*scale);

    //sw
    flag.draw_line(xc + swax*scale, yc + sway*scale, xc + swbx*scale, yc + swby*scale);
    flag.draw_line(xc + swax*scale, yc + sway*scale, xc + swdx*scale, yc + swdy*scale);
    flag.draw_line(xc + swbx*scale, yc + swby*scale, xc + swcx*scale, yc + swcy*scale);
    flag.draw_line(xc + swcx*scale, yc + swcy*scale, xc + swdx*scale, yc + swdy*scale);

    flag.draw_line(xc + swex*scale, yc + swey*scale, xc + swfx*scale, yc + swfy*scale);
    flag.draw_line(xc + swex*scale, yc + swey*scale, xc + swhx*scale, yc + swhy*scale);
    flag.draw_line(xc + swfx*scale, yc + swfy*scale, xc + swgx*scale, yc + swgy*scale);
    flag.draw_line(xc + swhx*scale, yc + swhy*scale, xc + swgx*scale, yc + swgy*scale);

    flag.draw_line(xc + swix*scale, yc + swiy*scale, xc + swjx*scale, yc + swjy*scale);
    flag.draw_line(xc + swix*scale, yc + swiy*scale, xc + swlx*scale, yc + swly*scale);
    flag.draw_line(xc + swjx*scale, yc + swjy*scale, xc + swkx*scale, yc + swky*scale);
    flag.draw_line(xc + swlx*scale, yc + swly*scale, xc + swkx*scale, yc + swky*scale);

    flag.draw_line(xc + swmx*scale, yc + swmy*scale, xc + swnx*scale, yc + swny*scale);
    flag.draw_line(xc + swmx*scale, yc + swmy*scale, xc + swpx*scale, yc + swpy*scale);
    flag.draw_line(xc + swpx*scale, yc + swpy*scale, xc + swox*scale, yc + swoy*scale);
    flag.draw_line(xc + swnx*scale, yc + swny*scale, xc + swox*scale, yc + swoy*scale);

    //se
    flag.draw_line(xc + seax*scale, yc + seay*scale, xc + sebx*scale, yc + seby*scale);
    flag.draw_line(xc + seax*scale, yc + seay*scale, xc + sedx*scale, yc + sedy*scale);
    flag.draw_line(xc + sebx*scale, yc + seby*scale, xc + secx*scale, yc + secy*scale);
    flag.draw_line(xc + secx*scale, yc + secy*scale, xc + sedx*scale, yc + sedy*scale);

    flag.draw_line(xc + seex*scale, yc + seey*scale, xc + sefx*scale, yc + sefy*scale);
    flag.draw_line(xc + seex*scale, yc + seey*scale, xc + sehx*scale, yc + sehy*scale);
    flag.draw_line(xc + sefx*scale, yc + sefy*scale, xc + segx*scale, yc + segy*scale);
    flag.draw_line(xc + sehx*scale, yc + sehy*scale, xc + segx*scale, yc + segy*scale);

    flag.draw_line(xc + seix*scale, yc + seiy*scale, xc + sejx*scale, yc + sejy*scale);
    flag.draw_line(xc + seix*scale, yc + seiy*scale, xc + selx*scale, yc + sely*scale);
    flag.draw_line(xc + sejx*scale, yc + sejy*scale, xc + sekx*scale, yc + seky*scale);
    flag.draw_line(xc + selx*scale, yc + sely*scale, xc + sekx*scale, yc + seky*scale);

    flag.draw_line(xc + semx*scale, yc + semy*scale, xc + senx*scale, yc + seny*scale);
    flag.draw_line(xc + semx*scale, yc + semy*scale, xc + sepx*scale, yc + sepy*scale);
    flag.draw_line(xc + sepx*scale, yc + sepy*scale, xc + seox*scale, yc + seoy*scale);
    flag.draw_line(xc + senx*scale, yc + seny*scale, xc + seox*scale, yc + seoy*scale);

    flag.draw_line(xc + seqx*scale, yc + seqy*scale, xc + serx*scale, yc + sery*scale);
    flag.draw_line(xc + seqx*scale, yc + seqy*scale, xc + setx*scale, yc + sety*scale);
    flag.draw_line(xc + serx*scale, yc + sery*scale, xc + sesx*scale, yc + sesy*scale);
    flag.draw_line(xc + setx*scale, yc + sety*scale, xc + sesx*scale, yc + sesy*scale);

    flag.draw_line(xc + seux*scale, yc + seuy*scale, xc + sevx*scale, yc + sevy*scale);
    flag.draw_line(xc + seux*scale, yc + seuy*scale, xc + sexx*scale, yc + sexy*scale);
    flag.draw_line(xc + sevx*scale, yc + sevy*scale, xc + sewx*scale, yc + sewy*scale);
    flag.draw_line(xc + sexx*scale, yc + sexy*scale, xc + sewx*scale, yc + sewy*scale);

    // fill in the black to white
    flag.draw_line(xc, yc - scale/2, xc, 0);
    flag.draw_line(xc, yc + scale/2, xc, height);
    flag.draw_line(xc - scale/2, yc, 0, yc);
    flag.draw_line(xc + scale/2, yc, width, yc);

    flag.recursive_fill(0, 0);
    flag.recursive_fill(0, height-1);
    flag.recursive_fill(width - 1, 0);
    flag.recursive_fill(width - 1, height - 1);

    flag.save("flag.ppm");

}
— user137
स्रोत
@SohamChowdhury पूरी तरह से अनजाने में, SEXY साउथईस्ट कॉर्नर, प्वाइंट X, Y समन्वय है।
— user137
3
तुम्हारा ही एक मात्र उपाय है जहाँ झंडा हवा में लहराता है!
— CJ डेनिस
2

पोस्टस्क्रिप्ट , 572 477 बाइट्स

गोल्फ कोड:

5 5 scale 36 24 translate /R{.75 .05 .19 setrgbcolor}def/B{0 .20 .47 setrgbcolor}def/a 2 3 atan def/b{0 setgray[18 -6 2 12 21 -6 2 12 24 -6 2 12]rectfill 1 setgray{[18 -.5 2 1 24 -.5 2 1]rectfill}if{21 -.5 2 1 rectfill}if}def a neg rotate R 0 0 12 0 180 arc closepath fill B 0 0 12 180 0 arc closepath fill R -6 0 6 0 360 arc closepath fill B 6 0 6 0 360 arc closepath fill true true b 2 a mul rotate false true b 180 rotate true false b -2 a mul rotate false false b
showpage

अघोषित कोड:

5 5 scale                                     % over-all scale
36 24 translate                               % over-all shift
/R {.75 .05 .19 setrgbcolor} def              % prodecure for setting red color
/B {0 .20 .47 setrgbcolor} def                % procedure for setting blue color
/a 2 3 atan def                               % calculate angle = arctan(2/3) = 33.7°
/b {                                          % procedure for drawing bars
 0 setgray                                    %   black
 [18 -6 2 12 21 -6 2 12 24 -6 2 12] rectfill  %   draw 3 bars
 1 setgray                                    %   white
 {[18 -.5 2 1 24 -.5 2 1] rectfill} if        %   conditionally draw gap in inner/outer bars 
 {21 -.5 2 1 rectfill} if                     %   conditionally draw gap in middle bar 
} def
a neg rotate                                  % rotate -33.7°
R 0 0 12 0 180 arc closepath fill             % big red half circle
B 0 0 12 180 0 arc closepath fill             % big blue half circle
R -6 0 6 0 360 arc closepath fill             % small red circle
B  6 0 6 0 360 arc closepath fill             % small blue circle
true true b                                   % draw bars (with gap in all bars)
2 a mul rotate                                % rotate 67.4°
false true b                                  % draw bars (with gap in inner/outer bars)
180 rotate                                    % rotate 180°
true false b                                  % draw bars (with gap in middle bar)
-2 a mul rotate                               % rotate -67.4°
false false b                                 % draw bars (without gaps)
showpage

नतीजा:

नतीजा

— थॉमस फ्रिट्च
स्रोत
1

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

from math import*
w,k,r,b="255 "*3,"0 "*3,"198 12 48 ","0 52 120 "
print "P3 600 400 255 "
a=atan2(2,3)
c,s=cos(a),sin(a)
T=lambda x,y:(c*x-s*y,s*x+c*y)
S=lambda x,y:150<x<216.6and x%25<16.6and y*y<2500
C=lambda x,y,p=50:(x-p)**2+y*y<2500
for y in range(-200,200):
 for x in range(-300,300):X,Y=T(x,y);W,Z=T(-x,y);print [[w,k][(S(abs(X),Y)and(Y*Y>16or(166.6<X<191.4or-200>X or 0>X>-166.6)))or(S(abs(W),Z)and(W>0 or abs(Z)>4))],[b,r][(Z<0 or C(W,Z))and not C(W,Z,-50)]][W*W+Z*Z<10000]

संभावित सुधार:

  • cos, cos, sin constants को हार्डकोड करता है
  • बाइनरी पीपीएम
  • [३,२] विमान में बदलना
  • बूलियन स्टेटमेंट का अनुकूलन करें

टेक्स्ट PPM के रूप में आउटपुट, उपयोग:

python golf_korea.py > korea.ppm

यहाँ छवि विवरण दर्ज करें

ungolfed बीटा संस्करण

from math import*
w,k,r,b="255 255 255 ", "0 0 0 ", "255 0 0 ", "0 0 255 "
g="0 255 0 "
print "P3 600 400 255 "
a=atan2(2,3)
c,s=cos(a),sin(a)
trans=lambda x,y:(c*x-s*y,s*x+c*y)
stripe=lambda x:150<x<216.6 and x%25<16.6
small=lambda x,y,p=50:(x-p)**2+y*y<2500
for y in range(-200,200):
 for x in range(-300,300):
  X,Y=trans(x,y)
  W,Z=trans(-x,y)
  if stripe(abs(X)) and Y*Y<2500:
   if abs(Y)>4:  
    print k
   else:
    if X>0:
     if 166.6<X<191.4:
      print k
     else:
      print w
    else:
     if -200<X<-166.6:
      print w
     else:
      print k
  elif stripe(abs(W)) and Z*Z<2500 and(W>0 or abs(Z)>4):
   print k
  elif W*W+Z*Z<100*100:
   if (Z<0 or small(W,Z)) and not small(W,Z,-50):
    print r
   else:
    print b
  else:
   print w
— कार्ल नेफ
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.