अपने Google ओवरलेर्स को अपील करें: "जी" लोगो को ड्रा करें

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है, और इस * निर्माण के अनुसार Google के "जी" लोगो की एक एन × एन पिक्सेल छवि को आउटपुट करता है :

उदाहरण के लिए, यदि N 400 है, तो 400 × 400 पिक्सेल का लोगो सही आयामों और रंगों के साथ आउटपुट होना चाहिए:

यह सही दिखना चाहिए कि एन कितना बड़ा या छोटा है। यहाँ उदाहरण N = 13 है:

आपके कोड को इंटरनेट से कनेक्ट करने की आवश्यकता नहीं होनी चाहिए। उदाहरण के लिए, बाहरी रूप से होस्ट किए गए svg को स्केल करने की अनुमति नहीं है। (अपने कोड में एनकोडेड एक svg स्केलिंग हालांकि ठीक होगा।)

एंटी-अलियासिंग का उपयोग किया जा सकता है या नहीं। यह आप पर निर्भर करता है।

ध्यान दें कि "जी" की क्षैतिज पट्टी छवि के दाहिने किनारे तक सभी तरह से विस्तारित नहीं होती है। सर्कल काटे जाने से पहले दाहिने किनारे पर सामान्य रूप से अंदर की ओर झुकता है।

बाइट्स में सबसे छोटा कोड जीतता है।

---

^{* इस चुनौती के लिए लोगो का निर्माण सरल किया गया है। सही निर्माण यहाँ और यहाँ देखा जा सकता है ।}

Comments

क्या कोई न्यूनतम N है? एक 1x1 छवि संभवतया बिना पहचाने उत्पादन का उत्पादन करेगी, भले ही समाधान कितना अच्छा हो।

— jpmc26

@ jpmc26 N एक सकारात्मक पूर्णांक है, इसलिए न्यूनतम 1. बेशक 1x1 छवि पहचानने योग्य नहीं हो सकती है, लेकिन "इसे सटीक रूप से देखना चाहिए", उदाहरण के लिए, एक काली छवि समझ में नहीं आएगी, उस पैमाने पर भी।

— केल्विन के शौक

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

— jpmc26

@ jpmc26 नहीं। लोग यह समझने के लिए सामान्य ज्ञान का उपयोग कर सकते हैं कि क्या 1x1 या अन्य छोटी छवि सटीक है।

— केल्विन के शौक

क्या हमें पूर्व-निर्मित डाउनलोड करने .svgऔर इसे हमारे समाधान में एन्कोड करने की अनुमति है , या क्या हमें इसे मूल रूप से बनाना है?

— जूनियुब्रिस्ट

Answer 1

गणितज्ञ, 229 226 225 224 221 206 169 बाइट्स

1 बाइट के लिए @MartinEnder को धन्यवाद, 37 बाइट्स के लिए @ChipHurst !

Graphics[{RGBColor@{"#EA4335","#FBBC05","#34A853","#4285F4"}[[#]],{0,-1}~Cuboid~{√24,1},Annulus[0{,},{3,5},{(2#-9)Pi/4,ArcCsc@5}]}&~Array~4,ImageSize->#,PlotRange->5]&

क्या मजेदार चुनौती है!

व्याख्या

...&~Array~4

1 से 4 तक Iterate ...

RGBColor@{"#EA4335","#FBBC05","#34A853","#4285F4"}[[#]]

रंग हेक्स कोड्स को RGBColorऑब्जेक्ट्स में कनवर्ट करें , ताकि उन्हें Google लोगो ग्राफिक पर लागू किया जा सके। रंग पैलेट को <input>वें रंग में बदलें ।

{0,-1}~Cuboid~{√24,1}

एक भरा हुआ आयत (2 डी क्यूबॉइड) बनाएं, जिसके विकर्ण कोने (0, -1) और (sqrt (24), 1) हैं।

Annulus[0{,},{3,5},{(2#-9)Pi/4,ArcCsc@5}]}

Annulusआंतरिक त्रिज्या 3 और बाहरी त्रिज्या के साथ मूल में केंद्रित चार भरे हुए क्वार्टर - एस उत्पन्न करें , अतीत को आकर्षित न करें ArcCsc@5(जहां नीला खंड समाप्त होता है)।

Graphics[ ... , ImageSize->#,PlotRange->5]

आकार x x -5, से x = -5 से x = 5 तक एक ग्राफ़िक बनाएँ (पैडिंग को हटाता है)।

आउटपुट

एन = 10

एन = 100

एन = 200

N = 10000 (पूर्ण रिज़ॉल्यूशन के लिए छवि पर क्लिक करें)

Answer 2

सी (विंडोज), 311 बाइट्स

#include <windows.h>
main(int c,char**v){float x,y,a,b,N=atoi(*++v);HDC d=GetDC(GetDesktopWindow());for(x=0;x<N;x+=1)for(y=0;y<N;y+=1){a=2*x/N-1;b=2*y/N-1;SetPixel(d,x,y,(a>0&&a<.8&&b*b<.04)?0xF48542:(a*a+b*b>1||a*a+b*b<.36)?0xFFFFFF:(a*a<b*b)?((b<0)?3490794:5482548):(a<0)?376059:(b<-.2)?0xFFFFFF:0xF48542);}}

कमांड लाइन तर्क के रूप में "एन" लेता है और स्क्रीन पर सीधे खींचता है।

संयुक्त राष्ट्र के golfed:

#include <windows.h>
// atoi() will work fine without any #include file!
// -> don't #include it!

main(int c,char **v)
{
    float x,y,a,b,N=atoi(*++v);

    /* Access the screen for directly drawing! */
    HDC d=GetDC(GetDesktopWindow());

    /* Iterate over the pixels */
    for(x=0;x<N;x+=1)
        for(y=0;y<N;y+=1)
    {
        /* Convert x,y into "relative" coordinates: The image
         * is 2.0x2.0 in size with (0.0,0.0) in the center */
        a=2*x/N-1;
        b=2*y/N-1;

        /* Draw each pixel */
        SetPixel(d,x,y,
            (a>0 && a<.8 && b*b<.04)?0xF48542: /* The bar of the "G" in the middle */
            (a*a+b*b>1 || a*a+b*b<.36)?0xFFFFFF: /* Not on one of the circle segments */
            (a*a<b*b)?((b<0)?0x3543EA:0x53A834): /* Top and bottom segments */
            (a<0)?0x5BCFB: /* Left segment */
            (b<-.2)?0xFFFFFF:0xF48542); /* Right segment: A bit more complicated... */
    }

    /* Note: Under good old Windows 3.x we would require to
     * call "ReleaseDC" here; otherwise the system would
     * "crash" (however the image would have been drawn!)
     * No need for this in modern Windows versions! */
}

Comments

आप 0xF48542और 0xFFFFFFपूर्णांक में रख सकते हैं।

— यति

आपने किस कंपाइलर / लिंकर का उपयोग किया?

— मिंगव के

@vsz संभवतः, विजुअल स्टूडियो के संकलक।

— क्रॉल्टन

@vsz मैं इसे gcc g.c -lgdi32mingw के साथ संकलित कर सकता हूं ।

— jingyu9575

-1>>8यह भी काम कर सकता है

— मार्क के कोवान

Answer 3

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

मार्टिन रोसेनौ के परिवर्तन का उपयोग करते हुए [-1,1] ^ 2 विमान और हटाने 0.या कोष्ठक जैसे मामूली गोल्फिंग

N=input()
R=[2*z/(N-1.)-1for z in range(N)]
B="\xFF"*3,"B\x85\xF4"
print"P6 %d %d 255 "%(N,N)+"".join([B[0<x<.8and.04>y*y],["4\xA8S",B[y>-.2],"\xFB\xBC\x05","\xEAC5"][(x>y)+2*(-x>y)]][.36<x*x+y*y<1]for y in R for x in R)

स्पष्टीकरण:

N=input()
R=[2*z/(N-1.)-1for z in range(N)]
#N*N points on the [-1,1]^2 plane

B="\xFF"*3,"B\x85\xF4"
#white and blue

print"P6 %d %d 255 "%(N,N) + "".join(
#binary PPM header
 [
  B[0<x<.8and.04>y*y],
  #blue rectangle part of the G, or white
  ["4\xA8S",B[y>-.2],"\xFB\xBC\x05","\xEAC5"][(x>y)+2*(-x>y)]
  #[green, [white,blue], yellow, red]-arcs with 4 way selector
 ]
 [.36<x*x+y*y<1]
 #radius checker, outside=0 blue rectangle or white, inside=1 colored arcs
  for y in R for x in R
  #for all points
 )

बाइनरी पीपीएम के रूप में आउटपुट, उपयोग:

python golf_google.py > google.ppm

उदाहरण

• 13

• 50

• 100

• 1337

पिछले 244 बाइट्स समाधान

N=input()
S="P6 %d %d 255 "%(N,N)
R=range(N)
B=["\xFF"*3,"B\x85\xF4"]
for Y in R:
 for X in R:y=Y-N/2;x=X-N/2;S+=[B[0<x<0.4*N and abs(y)<0.1*N],["4\xA8S",B[y>-0.1*N],"\xFB\xBC\x05","\xEAC5"][(x>y)+2*(-x>y)]][0.3*N<(y**2+x**2)**.5<0.5*N]
print S

इससे पहले कि अन्यथा समाप्त हो जाए

N=input()
print"P3 %d %d 255 "%(N,N)
R=range
M=N/2
r="255 0 0 "
g="0 255 0 "
b="0 0 255 "
c="255 255 0 "
w="255 255 255 "
for Y in R(N):
 for X in R(N):
  y=Y-M
  x=X-M
  d=(y**2+x**2)**.5 #radius
  if 0.3*N<d<0.5*N: #inside circle
   if x>y:          #diagonal cut bottom-left to top right
    if -x>y:        #other diagonal cut
     print r
    else:
     if y>-0.1*N:print b #leave some whitespace at blue
     else: print w
   else:
     if -x>y:
      print c
     else:
      print g
  else:
   if 0<x<0.4*N and -0.1*N<y<0.1*N: #the straight part of G
    print b
   else:
    print w

Comments

हम्म, यकीन नहीं तो 1forकाम करता है।

— यति

@TuukkaX यह करता है।

— mbomb007

आप नमूना उत्पादन शामिल कर सकते हैं?

— साइओस

@Cyoce 1forनमूना उत्पादन के लिए @TuukkaX धन्यवाद जोड़ा गया

— कार्ल नेफ

आपके कोड में सभी दशमलव जो 0.xघटाए जा सकते हैं .x:)

— Ytstsi

Answer 4

जावास्क्रिप्ट (ईएस 6), 408 ... 321 317 बाइट्स

कैनवास तत्व के लिए 384 383 371 367 359 327 316 308 304 बाइट्स जावास्क्रिप्ट + 24 13 बाइट्स

(f=d.style).width=f.height=(d.width=d.height=n=prompt(f.background='#FFF'))+'px';q=n/2;with(d.getContext`2d`)['#EA4335','#FBBC05','#34A853','#4285F4'].map((c,i)=>beginPath(lineWidth=y=n/5,strokeStyle=fillStyle=c,arc(q,q,z=q-y/2,(j=2*i+1)*(r=-.7854),(j+(i-3?2:1.256))*r,1),stroke(),fillRect(q,z,q*.98,y)))

<canvas id=d>

काउंटर-दक्षिणावर्त ड्राइंग द्वारा 1 बाइट बचाई गई।
Conor O'Brien के लिए HTML धन्यवाद पर 11 बाइट्स बचाए गए। प्रिज़ोर्न के लिए ब्लॉक
बाइट का उपयोग करके 12 बाइट्स बचाए गए with।
4 बाइट्स बेहतर उपयोग के साथ सहेजे गए z=q-y/2। एलेक्सिस टायलर के
उपयोग parentNodeऔर backgroundधन्यवाद के द्वारा 8 बाइट्स बचाए गए ।
नीली चाप / बार के अधिक सटीक ड्राइंग का उपयोग करके 32 बाइट्स बचाए गए ताकि मुझे अब इसके एक हिस्से को मिटाने की आवश्यकता न हो।
11 बाइट्स अपने मूल के बजाय कैनवस सीएसएस को सेट करके बचाई गईं। तेजस काले को धन्यवाद।
8 बाइट्स का उपयोग कर बचाया withऔर mapएक सिंगल स्टेटमेंट, `बजाय 2d` साथ ('2d'), n/5के बजाय .2*nऔर में पृष्ठभूमि आरंभ prompt(...)।
4 बाइट की जगह बचाया Math.PI/4द्वारा.7854 जो RobAu के लिए पर्याप्त सटीक लगता है।

---

स्पष्टीकरण:

(f=d.style).width=f.height=(d.width=d.height=n=prompt(f.background='#FFF'))+'px';q=n/2 

कैनवास आयाम उपयोगकर्ता इनपुट के साथ initilized हैं और पृष्ठभूमि सफेद पर सेट है। qआरंभिक है।

with(d.getContext`2d`)['#EA4335','#FBBC05','#34A853','#4285F4'].map((c,i)=>beginPath(lineWidth=y=n/5,strokeStyle=fillStyle=c,arc(q,q,z=q-y/2,(j=2*i+1)*(r=-.7854),(j+(i-3?2:1.256))*r,1),stroke(),fillRect(q,z,q*.98,y)))

प्रत्येक रंग के लिए सर्कल का हिस्सा खींचता है, आखिरी (नीला) के लिए कुछ समायोजन के साथ। बार को प्रत्येक रंग के लिए एक ही स्थान पर एक ही आयाम के साथ खींचा जाता है ताकि केवल अंतिम (नीला) दिखाई दे।

Comments

<canvas id=d></canvas>काम करना चाहिए, और <canvas id=d>काम कर सकते हैं।

— कॉनर ओ'ब्रायन

आप बैकग्राउंड के साथ बैकग्राउंड को बदलकर एक और 5 चर खो सकते हैं।

— एलेक्सिस टायलर

इसके अलावा d.parentEode के बजाय d.parentNode का उपयोग करें

— एलेक्सिस टायलर

आप पेरेंटोड आयाम क्यों सेट कर रहे हैं बस d.styleकाम भी करता है। जो अनुमति देता है(f = d.style).width = f.height = n = prompt() + 'px';

— तेजस काले

आप 2 बाइट्स .785398को Math.PI/4शेविंग करने के बजाय इस्तेमाल कर सकते हैं (या अधिक अगर कम परिशुद्धता ठीक है।

— रोबो

Answer 5

बीबीसी बेसिक, 177 बाइट्स

Http://www.bbcbasic.co.uk/bbcwin/download.html पर दुभाषिए को डाउनलोड करें

I.n
V.19;16,234,67,53,275;64272;1468;531;16,43060;83,787;16,34114;7668;n;n;
F.t=1TO8.256S.1/n
a=t*PI/4y=n*SIN(a)x=n*COS(a)V.18;t-1>>1,25,85,x*.6;y*.6;25,85,x;y;
N.PLOT101,0,-n/5

बीबीसी बेसिक 2 इकाइयों = 1 पिक्सेल का उपयोग करता है, इसलिए हम केंद्र में जी त्रिज्या nइकाइयों (= n / 2 पिक्सेल) की साजिश रचते हैं n,n।

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

एक बार जब लाइनों का स्वीप पूरा हो जाता है, तो कर्सर नीले क्षेत्र के शीर्ष दाएं कोने पर होता है। तिरछे विपरीत कोने के लिए एक एकल समन्वय आकार को पूरा करने के लिए एक आयत खींचने के लिए दिया गया है।

Ungolfed

INPUTn
REM reprogram pallette
VDU19;16,&EA,&43,&35,275;16,&FB,&BC,5,531;16,&34,&A8,&53,787;16,&42,&85,&F4
ORIGINn,n               :REM move origin to position n,n on screen.
FORt=1TO8.256STEP1/n    :REM from 1/8 turn to 8.56 turns in small steps
  GCOL0,t-1>>1          :REM set the colours, 0=red, 1=yellow, 2=green, 3=blue
  a=t*PI/4              :REM convert angle from 1/8 turns into radians
  y=n*SIN(a)            :REM find position of outer end of ray
  x=n*COS(a)            :REM plot to coordinates of inner and outer ends of ray
  PLOT85,x*.6,y*.6      :REM PLOT85 actually draws a triangle between the specified point              
  PLOT85,x,y            :REM and the last two points visited.
NEXT                    
PLOT101,0,-n/5          :REM once all is over, cursor is at top right corner of blue rectangle. Draw a rectangle to the bottom left corner as specified.

Comments

अच्छा काम! मैंने आपका उत्तर देखने से पहले इसी तरह की विधि का उपयोग करके मेरा लोगो किया था। आपने मुझे लगभग 81 बाइट्स से हराया है।

— गिटारपीकर

Answer 6

HTML / JS, 680 624 बाइट्स

624 बाइट्स प्राप्त करने के लिए, अंतिम निकालें ;, यह HTML को आयात करने के तरीके के कारण नीचे स्निपेट के लिए आवश्यक है। इसके अलावा, फ़ायरफ़ॉक्स समर्थन image-rendering: pixelatedऔर जरूरतों के -moz-crisp-edgesबजाय लगता है (धन्यवाद @alldayremix !) जो फ़ायरफ़ॉक्स समाधान +7 बनाता है लेकिन यह उम्मीद के मुताबिक क्रोम में काम करता है।

तत्वों को स्थिति / रंग के लिए अनुरोध करने Nऔर <style>ब्लॉक करने के लिए जावास्क्रिप्ट का उपयोग करता है। एक कैनवास पर शैलियों को लागू करने के बजाय मूल HTML तत्वों का उपयोग करता है (जो, ऐसा प्रतीत होता है, बहुत छोटा दृष्टिकोण था!)। यह data:केवल रंगीन तत्वों के बजाय एक URI पृष्ठभूमि छवि का उपयोग करते हुए एक नया दृष्टिकोण है । मैंने पिछले दृष्टिकोण को नीचे रखा है अगर यह नया कम ब्राउज़रों पर काम करता है।

मैंने सोचा था कि यह समाप्त होने की तुलना में बहुत छोटा होने जा रहा था, लेकिन फिर भी यह एक दिलचस्प अभ्यास था!

<body id=x onload=x.style.fontSize=prompt()+'px'><u><a></a><b></b><i></i><s><style>u,a,b,i,s{position:relative;display:block}b,i,s{position:absolute}a,u{width:1em;height:1em}a,b{border-radius:50%}a{image-rendering:pixelated;background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAFklEQVQI12N45Wzq1PqF4fceVpMVwQAsHQYJ1N3MAQAAAABJRU5ErkJggg)no-repeat;background-size:100%;transform:rotate(45deg)}b{top:.2em;left:.2em;width:.6em;height:.6em;background:#fff}i{border-top:.4em solid transparent;border-right:.4em solid#fff;top:0;right:0}s{top:.4em;right:.1em;width:.4em;height:.2em;background:#4285f4;

पुराना वर्जन:

<body id=x onload=x.style.fontSize=prompt()+'px'><a b><b l style=padding-left:.5em></b><b y></b><b g></b></a><i style=height:.4em></i><i style="background:#ea4335;border-radius:0 1em 0 0;transform-origin:0%100%;transform:rotate(-45deg)"></i><i b z style=top:.2em;left:.2em;width:.6em;height:.6em></i><i l z style="top:.4em;height:.2em;border-radius:0 2%10%0/0 50%50%0;width:.4em"><style>*{position:relative;background:#fff}a,b,i{display:block;float:left;width:.5em;height:.5em}a{height:1em;width:1em;transform:rotate(45deg);overflow:hidden}i{position:absolute;top:0;left:.5em}[b]{border-radius:50%}[g]{background:#34a853}[l]{background:#4285f4}[y]{background:#fbbc05}[z]{z-index:1

Comments

गद्दार! (बस मजाक कर रहे हैं, एक अच्छा ;-))

— दादा

मेरे ब्राउज़र पर पुराने संस्करण में रंगों के बीच मामूली अंतर दिखाई देता है, और नया संस्करण रंगों के बीच एक क्रमिक संक्रमण देता है (फ़ायरफ़ॉक्स 49.0.1 Win10 x64 पर 32-बिट)

— alldayremix

@alldayremix हममम, लग रहा है फ़ायरफ़ॉक्स की जरूरत है की तरह image-rendering: -moz-crisp-edgesके बजाय pixelated। उस प्रभाव के लिए एक नोट जोड़ देगा। मुझे ढाल शैली बहुत पसंद है! :)

— डोम हेस्टिंग्स

आपने "HTML / JS" पढ़ने के लिए हेडर को संशोधित किया है, क्योंकि आप HTML और जावास्क्रिप्ट दोनों का उपयोग करते हैं।

— मेगो

Answer 7

इमेजमाजिक के साथ बैश (लेकिन वास्तव में पोस्टस्क्रिप्ट), 268 255 249 बाइट्स

C=' setrgbcolor 2.5 2.5 2'
A=' arc stroke '
echo "%!PS
122.4 dup scale
.92 .26 .21$C 45 136$A.98 .74 .02$C 135 226$A.20 .66 .33$C 225 316$A.26 .52 .96$C 315 371$A
4.95 2.5 moveto
2.5 2.5 lineto
stroke"|convert - -crop 612x612+0+180 -scale "$1" o.png

स्केलिंग को निकालने के लिए दोगुना कर setlinewidthदिया, एक स्केल फैक्टर को बदल दिया dup, और एक स्पेस को Aवेरिएबल में मिला दिया ( Cक्योंकि $C45"वेरिएबल C45" के रूप में पार्स किया गया है )।

इन सम्पादनों के सुझाव के लिए joojaa का धन्यवाद!

ओल्ड स्केल, 255 बाइट्स

C=' setrgbcolor 5 5 4'
A=' arc stroke'
echo "%!PS
61.2 61.2 scale
2 setlinewidth
.92 .26 .21$C 45 136$A
.98 .74 .02$C 135 226$A
.20 .66 .33$C 225 316$A
.26 .52 .96$C 315 371$A
9.9 5 moveto
5 5 lineto
stroke"|convert - -crop 612x612+0+180 -scale "$1" o.png

ले जाता है एन अकेला तर्क और आउटपुट o.png के रूप में।

ओल्ड स्केल के लिए अनगॉल्ड पोस्टस्क्रिप्ट

%!PS
% Scale so default page has width of 10
61.2 61.2 scale
2 setlinewidth
% Red arc
.92 .26 .21 setrgbcolor
5 5 4 45 136 arc
stroke
% Yellow arc
.98 .74 .02 setrgbcolor
5 5 4 135 226 arc
stroke
% Green arc
.20 .66 .33 setrgbcolor
5 5 4 225 316 arc
stroke
% Blue arc
.26 .52 .96 setrgbcolor
5 5 4 315 371 arc
% Blue in-tick
9.9 5 moveto
5 5 lineto
stroke

Comments

आप इसे स्केल की लाइन से एक चार को शेव करके छोटा बना सकते हैं। 61.2 dup scaleआप सी की तरह एक स्पेस भी जोड़ सकते हैं C=' setrgbcolor 5 5 4 'और 4 स्पेस शेव कर सकते हैं । आप आधा पैमाने पर यह तैयार किया गया है, तो आप छोड़ सकता है2 setlinewidth

— joojaa

Answer 8

MATLAB, 189 184 बाइट्स

[X,Y]=meshgrid(-5:10/(input("")-1):5);[A,R]=cart2pol(-X,Y);I=round(A*2/pi+3);I(R<3)=1;I(X>0&Y.^2<1)=5;I(R>5)=1;image(I)
colormap([1,1,1;[234,67,53;251,188,5;52,168,83;66,133,244]/255])

ungolfed

[X,Y]=meshgrid(-5:10/(input("")-1):5);    % coordinates in 10th of image width
[A,R]=cart2pol(-X,Y);                     % angle and radius
I=round(A*2/pi+3); % map [0-45,45-135,135-225,225-315,315-360] to [1,2,3,4,5]
I(R<3)=1;                                 % clear inner pixels
I(X>0&Y.^2<1)=5;                          % draw horizontal line
I(R>5)=1;                                 % clear outer pixels
image(I)
colormap([1,1,1;[234,67,53;251,188,5;52,168,83;66,133,244]/255])

Answer 9

पर्ल 5, 486 477 476 450 ( -MImagerध्वज के लिए +7 ) = 457 बाइट्स

मैंने कार्यात्मक newकॉल का उपयोग करके और मुर्गियों से छुटकारा पाने के लिए दादा के लिए कुछ बाइट्स को बचाया , और अंतिम अर्धविराम popके $ARGV[0]साथ-साथ उपयोग करके । मैंने $n=popइसे डालकर कुछ और बचा लिया, जहां यह पहली बार इस्तेमाल किया गया है, और 'इसके बजाय पर्ल 4 नामस्थान नोटेशन का उपयोग करके ::।

$i=new Imager xsize=>$n=pop,ysize=>$n;$h=$n/2;$s=$n*.6;$f=$n*.4;$c='color';($b,$r,$y,$g,$w)=map{new Imager'Color"#$_"}qw(4285f4 ea4335 fbbc05 34a853 fff);$i->box(filled=>1,$c,$w);$i->arc($c,$$_[0],r=>$h,d1=>$$_[1],d2=>$$_[2])for[$b,315,45],[$r,225,315],[$y,135,225],[$g,45,135];$i->circle($c,$w,r=>$n*.3,filled=>1);$i->box($c,$b,ymin=>$f,ymax=>$s,xmin=>$h,xmax=>$n*.9,filled=>1);$i->polygon($c,$w,x=>[$n,$n,$s],y=>[0,$f,$f]);$i->write(file=>'g.png')

इसके लिए मॉड्यूल इमेजर की आवश्यकता होती है , जिसे CPAN से स्थापित करने की आवश्यकता होती है। कमांड लाइन तर्क के रूप में एक पूर्णांक लेता है। छवि विरोधी नहीं है, इसलिए यह थोड़ा बदसूरत है।

नीचे दिए गए कोड को फ़ाइल g.pl में कॉपी करें। हमें -MImagerध्वज के लिए एक अतिरिक्त +7 बाइट्स की आवश्यकता है , लेकिन यह कुछ बाइट्स को बचाता है क्योंकि हमें इसकी आवश्यकता नहीं है use Imager;।

$ perl -MImager g.pl 200

यहाँ विभिन्न आकार हैं:

एन = 10

एन = 100

एन = 200

पूरी तरह से अनलॉक्ड कोड सीधा-आगे है।

use Imager;
my $n = $ARGV[0];
my $i = Imager->new( xsize => $n, ysize => $n );

my $blue   = Imager::Color->new('#4285f4');
my $red    = Imager::Color->new('#ea4335');
my $yellow = Imager::Color->new('#fbbc05');
my $green  = Imager::Color->new('#34a853');
my $white  = Imager::Color->new('white');

$i->box( filled => 1, color => 'white' );
$i->arc( color => $blue,   r => $n / 2, d1 => 315, d2 => 45 );     # b
$i->arc( color => $red,    r => $n / 2, d1 => 225, d2 => 315 );    # r
$i->arc( color => $yellow, r => $n / 2, d1 => 135, d2 => 225 );    # y
$i->arc( color => $green,  r => $n / 2, d1 => 45,  d2 => 135 );    # g
$i->circle( color => $white, r => $n * .3, filled => 1 );
$i->box(
    color  => $blue,
    ymin   => $n * .4,
    ymax   => $n * .6,
    xmin   => $n / 2,
    xmax   => $n * .9,
    filled => 1
);
$i->polygon( color => $white, x => [ $n, $n, $n * .6 ], y => [ 0, $n * .4, $n * .4 ] );
$i->write( file => 'g.png' );

---

इस पोस्ट में पहले आउटपुट इमेज की तरह कोड था। चूंकि यह कोड गोल्फ के लिए नियमों के खिलाफ था इसलिए मुझे इसे हटाना पड़ा। यदि आप एक बार देखना चाहते हैं तो संशोधन इतिहास देखें । मैंने Acme :: EyeDrops का उपयोग उस बनाने के लिए किया, जो एक आकृति से बना है जो मैंने उस प्रोग्राम के साथ बनाई गई छवि से बनाया है जिसे मैंने ASCII कला में बदल दिया। मेरे द्वारा कोड किया गया कोड पहले ही गोल्फ हो चुका था, जिसे पहले evalके स्थान पर a के साथ देखा जा सकता है print।

Comments

बहुत अच्छा! गोल्फ के बारे में बस कुछ विवरण: के popबजाय $ARGV[0]। $h=($n=pop)/2के बजाय $n=pop;...;$h=$n/2। new Imager::Color"#$_"के बजाय Imager::Color->new("#$_")। (और आप अंतिम अर्धविराम छोड़ना भूल गए)। लेकिन एक बार फिर, यह सिर्फ कुछ छोटे विवरण हैं, आपका कोड वास्तव में बहुत अच्छा है! (मैं ऐसा नहीं कर सकता था! मैं भी इसके बारे में नहीं जानता था Imager, जो बहुत सुविधाजनक है!)

— दादा

@ दादा धन्यवाद। वास्तव में यह बहुत सीधा-आगे वाला कोड है। मैं SO पर विधि संकेतन का उपयोग करने के बारे में लोगों को इतना सही करता हूं कि वास्तव में ऐसा करना मुश्किल नहीं है। लेकिन तुम सही हो। यह पहला मौका था जब मैंने खुद इमेजर का इस्तेमाल किया। मुझे लगता है कि मैंने इसे पर्ल वीकली में देखा।

— सिमबेक

@ दादा Imager'Colorपर्ल 4 नेमस्पेस सीमांकक के साथ एक और बाइट बचाता है। :)

— सिमबेक

दरअसल, पहली बार मुझे उस वाक्य रचना के लिए एक उपयोग दिखाई दे रहा है! इसके अलावा, :) -MImagerसे छोटा हैuse Imager;

— दादा

@Dada मैं वैसे भी है कि एक करने के लिए जा रहा था: पी और डाल $n=popमें newआर्ग कोष्ठक और अर्धविराम की बचत होती है

— simbabque

Answer 10

PHP + SVG, 300 बाइट्स

<svg width=<?=$_GET["w"]?> viewBox=0,0,10,10><def><path id=c d=M0,5A5,5,0,0,1,5,0V2A3,3,0,0,0,2,5 /></def><?foreach(["fbbc05"=>-45,"ea4335"=>45,"4285f4"=>168.5,"34a853"=>225]as$k=>$v)echo"<use xlink:href=#c fill=#$k transform=rotate($v,5,5) />"?><rect x=5 y=4 fill=#4285f4 width=4.9 height=2 /></svg>

स्केलिंग हिस्सा है width=<?=$_GET[w]?>

मूल्य 333 के लिए आउटपुट

<svg width="333" viewBox="0 0 10 10">
<def><path id="c" d="M 0,5 A 5 5 0 0 1 5,0 V 2 A 3,3 0 0 0 2,5"/></def>
<use xlink:href="#c" fill="#fbbc05" transform="rotate(-45,5,5)"/><use xlink:href="#c" fill="#ea4335" transform="rotate(45,5,5)"/><use xlink:href="#c" fill="#4285f4" transform="rotate(168.5,5,5)"/><use xlink:href="#c" fill="#34a853" transform="rotate(225,5,5)"/>
<rect x="5" y="4" fill="#4285f4" width="4.9" height="2"/>
</svg>

Comments

क्या आप विशेषताओं के दोहरे उद्धरण चिह्नों ( ") और अगली विशेषता के बीच की जगह को नहीं बढ़ा सकते? जैसे <svg width="333" viewBox="0 0 10 10">-><svg width="333"viewBox="0 0 10 10">

— बोजिदर मारिनोव

@BojidarMarinov हाँ, यह निस्संदेह यह कुछ बाइट्स बचाता है। धन्यवाद

— Jörg Hülsermann

पथ डेटा में अक्षरों और संख्याओं के बीच रिक्त स्थान निकालें: M 0,5 A 5 5 0 0 1 5,0 V 2 A 3,3 0 0 0 2,5=>M0,5A5 5 0 0 1 5,0V2A3,3 0 0 0 2,5

— darrylyeo

ज़रूर। इसके अलावा, अपने echoबयान के लिए, इनलाइन चर को अनुमति देने के लिए एक डबल-उद्धृत स्ट्रिंग का उपयोग करें और अर्धविराम को हटा दें: echo'<use xlink:href="#c"fill="#'.$k.'"transform="rotate($v,5,5)"/>';=>echo"<use xlink:href='#c'fill='#$k'transform='rotate($v,5,5)'/>"

— darrylyeo

मुझे लगता है कि अधिकांश दोहरे उद्धरण सुरक्षित रूप से हटाए जा सकते हैं। जैसे <rect x=5 y=4 fill=#4285f4 width=4.9 height=2 />(यहाँ, आपको इससे पहले एक स्थान की आवश्यकता होगी /।)

— अरनौल्ड

Answer 11

लोगो, 258 बाइट्स

... क्योंकि मैं लोगो का उपयोग लोगो बनाना चाहिए । यह एक फ़ंक्शन के रूप में कार्यान्वित किया जाता है। मैंने इसे Calormen.com के ऑनलाइन लोगो दुभाषिया का उपयोग करके विकसित किया

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

golfed

to g:n
ht
make"a arctan 1/:n
seth 78.46
repeat 326.54/:a[make"h heading
pu fd:n/2 pd
setpc"#4285f4
if:h>135[setpc"#34a853]if:h>225[setpc"#fbbc05]if:h>315[setpc"#ea4335]bk:n*.2 pu bk:n*.3
rt:a]home bk:n*.1
filled"#4285f4[fd:n/5 rt 90 fd:n*.49 rt 90 fd:n/5]end

नमूना

g 200

Ungolfed

to g :n ; Draw a G of width/height n

hideturtle ; Hide the turtle, since she's not part of the Google logo

;Determine the proper size of the angle to rotate so that the circle stays smooth within 1 px at this size
make "a arctan 1/:n 

setheading 78.46 ; Point toward the top corner of the upcoming rectangle

repeat 326.54 / :a [ ; Scoot around most of the circle, :a degrees at a time

  make"h heading ; Store heading into a variable for golfing purposes

  ; Position pen at the next stroke
  penup 
  forward :n / 2
  pendown

  ; Set the pen color depending on the heading
  setpencolor "#4285f4
  if :h > 135 [ setpencolor "#34a853]
  if :h > 225 [ setpencolor "#fbbc05]
  if :h > 315 [ setpencolor "#ea4335]

  ; Draw the stroke and return to center
  back :n * .2
  penup
  back :n * .3

  right :a ; Rotate to the next sweep heading
]

; Draw the rectangle
home
back :n * .1
filled "#4285f4 [
  forward :n/5
  right 90
  forward :n * .49 ;This is just begging to be :n / 2 but I couldn't bring myself to do it.  Proper math is more like :n * (sqrt 6) / 5
  right 90 
  forward :n / 5
]

end

Answer 12

जावास्क्रिप्ट (ईएस 7), 285 258 254 252 251 बाइट्स

लोगो की चौड़ाई (999 तक) के लिए संकेत और एक कैनवास, पिक्सेल प्रति पिक्सेल में खींचता है।

संपादित करें : प्रारंभिक संस्करण कार्टेशियन निर्देशांक (x,y)को ध्रुवीय निर्देशांक में परिवर्तित कर रहा था (r,a), लेकिन हमें वास्तव में कोण की आवश्यकता नहीं है। यह सरल (और काफी छोटा) है कि हम किस तिमाही में हैं xऔर yयह पता लगाने के लिए तुलना करें ।

संपादित करें : सहेजे गए 1 बाइट को ETHproductions के लिए धन्यवाद।

जेएस, 251 224 220 218 217 बाइट्स

for(w=x=y=prompt(c=c.getContext`2d`)/2;r=(x*x+y*y)**.5,q=(x<y)+2*(x<-y),c.fillStyle='#'+'4285F434A853EA4335FBBC05FFF'.substr(x>0&r<w&y*y<w*w/25?0:r<w*.6|r>w|!q&y<0?24:q*6,6),x-->-w||y-->-(x=w);)c.fillRect(x+w,y+w,1,1)

HTML, 34 बाइट्स

<canvas id=c width=999 height=999>

ईएस 6 संस्करण: 258 231 227 225 224 + 34 = 258 बाइट्स

स्निपेट के लिए अनुशंसित अधिकतम चौड़ाई: 190।

for(w=x=y=prompt(c=c.getContext`2d`)/2;r=Math.pow(x*x+y*y,.5),q=(x<y)+2*(x<-y),c.fillStyle='#'+'4285F434A853EA4335FBBC05FFF'.substr(x>0&r<w&y*y<w*w/25?0:r<w*.6|r>w|!q&y<0?24:q*6,6),x-->-w||y-->-(x=w);)c.fillRect(x+w,y+w,1,1)

<canvas id=c width=999 height=999>

Comments

मैंने जावास्क्रिप्ट भाग के माध्यम से देखा और तुरंत सोचा, "पृथ्वी पर ये <-और -->ऑपरेटर क्या हैं ??" मुझे लगता है कि जब आप काल्पनिक भाषा के लिए काल्पनिक संचालकों के बारे में 24 घंटों के लिए सोच रहे होते हैं तो क्या होता है ...: P

— ETHproductions

@ETHproductions वे भी नोटपैड ++ वाक्यविन्यास हाइलाइटर को भ्रमित कर रहे हैं जो -->एक HTML टिप्पणी के प्रारंभ (?) के रूप में व्याख्या कर रहा है अगर यह <script>एक html फ़ाइल में टैग के अंदर रखा गया है ।

— अरनौलद

मानो या न मानो, नोटपैड ++ अधिकार की तरह है (हालांकि पूरी तरह से नहीं)। ईएस 6 कॉम्पिटिटर टेबल में बहुत अंतिम आइटम देखें ।

— ETHproductions

@ETHproductions - वाह। मुझे लगता है कि इस सिंटैक्स के पीछे एक अच्छा कारण है, लेकिन मैं इसे देखने में विफल हूं। इस पर ध्यान दिलाने के लिए धन्यवाद।

— अरनौलद

बस इतना पता है, मेरा मानना ​​है कि यह केवल एक लाइन की शुरुआत में मान्य है। 123 --> commentमेरे ब्राउज़र कंसोल (फ़ायरफ़ॉक्स 49) में एक त्रुटि फेंकता है, जबकि --> commentऐसा नहीं है।

— ETHproductions

Answer 13

सी #, 276 + 21 = 297 बाइट्स

276 बाइट्स विधि के लिए + 21 बाइट्स सिस्टम के लिए। आयात आयात करना।

using System.Drawing;n=>{var q=new Bitmap(n,n);uint W=0xFFFFFFFF,B=0xFF4285F4;for(int y=0,x=0;x<n;y=++y<n?y:x-x++){float a=2f*x/n-1,b=2f*y/n-1,c=b*b;q.SetPixel(x,y,Color.FromArgb((int)(a>0&&a<.8&&c<.04?B:a*a+c>1||a*a+c<.36?W:a*a<c?b<0?0xFFEA4335:0xFF34A853:a<0?0xFFFBBC05:b<-.2?W:B)));}return q;};

मार्टिन रोसेनॉ के एल्गोरिथ्म पर आधारित। छवि बनाने के तरीके के साथ आने वाले कठिन भाग को करने के लिए धन्यवाद!

using System.Drawing;             // Import System.Drawing
/*Func<int, Bitmap>*/ n =>
{
    var q = new Bitmap(n, n);     // Create nxn output bitmap
    uint W=0xFFFFFFFF,            // White, color used more than once
         B=0xFF4285F4;            // Blue, color used more than once
    for(int y = 0, x = 0; x < n;  // Loops for(x=0;x<N;x+=1) for(y=0;y<N;y+=1) combined
        y = ++y < n               // Increment y first until it reaches n
            ? y           
            : x - x++)            // Then increment x, resetting y
    {
        float a = 2f * x / n - 1, // Relative coords. Refer to Martin Rosenau's
              b = 2f * y / n - 1, // for what this magic is.
              c = b * b;          // b*b is used more than 3 times

        q.SetPixel(x, y,          // Set pixel (x,y) to the appropriate color
            Color.FromArgb((int)  // Cast uint to int :(
            ( // Here lies magic
                a > 0 && a < .8 && c < .04 
                    ? B
                    : a * a + c > 1 || a * a + c < .36
                        ? W
                        : a * a < c 
                            ? b < 0 
                                ? 0xFFEA4335
                                : 0xFF34A853
                            : a < 0
                                ? 0xFFFBBC05
                                : b < -.2
                                    ? W
                                    : B
            )));
    }
    return q;
};

26:

400:

Comments

आप रंग कोड में पारदर्शिता को शामिल नहीं करके बाइट्स बचा सकते हैं0xFF...

— TheLethalCoder

Answer 14

JS / CSS / HTML (+ JS), 40 0 + 701 644 617 593 + 173 90 97 121 = 914 774 754 730 714 बाइट्स

*{position:absolute}a,h{height:100%;background:#4285F4}a,g{width:100%;border-radius:100%}h{width:30%;height:20%;top:40%}b,c,d,e,f{width:50%;height:50%}b,d,f,h{left:50%}e,f{top:50%}c{border-radius:100% 0 0;background:linear-gradient(45deg,#FBBC05 50%,#EA4335 50%)}d{border-radius:0 100% 0 0;background:linear-gradient(-45deg,transparent 50%,#EA4335 50%)}e{border-radius:0 0 0 100%;background:linear-gradient(-45deg,#34A853 50%,#FBBC05 50%)}f{border-radius:0 0 100%;background:linear-gradient(45deg,#34A853 50%,#4285F4 50%)}b,g{height:40%;background:#FFF}g{width:60%;height:60%;top:20%;left:20%}

<input oninput=with(o.style)height=width=value+"px"><o id=o><a></a><b></b><c></c><d></d><e></e><f></f><g></g><h></h></o>

परिवर्तनों के बजाय रैखिक ग्रेडिएंट का उपयोग करता है। संपादित करें: @darrylyeo के लिए 140 बाइट्स सहेजे गए। एक ढाल के बजाय एक अतिरिक्त तत्व का उपयोग करके 20 बाइट्स को बचाया। @DBS के लिए धन्यवाद 24 बाइट्स सहेजे गए। 16 बाइट्स @Hedi की बदौलत सहेजे गए। आगे से, विभिन्न परतें हैं:

• a नीला घेरा
• b बार के ऊपर के भाग को अस्पष्ट करने के लिए एक सफेद आयत
• c लाल / पीला शीर्ष बाईं तिमाही
• d लाल सप्तक ऊपर दाईं ओर
• e पीले / हरे रंग की नीचे की तिमाही
• f हरे / नीले नीचे सही तिमाही
• g भीतर का सफेद घेरा
• h क्षैतिज नीली पट्टी

Comments

आईडी के बजाय, आप इस तरह के रूप तत्व नामों का उपयोग करना a, b, i, s, आदि का प्रयोग करें *बजाय divCSS चयनकर्ता के लिए।

— darrylyeo

इसके अलावा, backgroundशॉर्टहैंड के रूप में उपयोग करें background-image।

— darrylyeo

@darrylyeo धन्यवाद, कि मेरे स्कोर के लिए एक बड़ा अंतर है, मेरे एचटीएमएल से उद्धरणों को हटाने के लिए भी मेरी मदद नहीं की ...

— नील

हे, कोई बात नहीं!

— darrylyeo

मेरा मानना ​​है कि आप यौगिक का उपयोग करके यहां और वहां कुछ पात्रों को बचा सकते हैं border-radius। जैसे c{border-radius:100% 0 0;कीc{border-top-left-radius:100%;

— DBS

Answer 15

रूबी 2.3.1, 376 359 बाइट्स

RMagick रत्न का उपयोग करना।

d,f=$*[0].to_i,2.5;g,h,e,c=d-1,d/2,Magick::ImageList.new,Magick::Draw.new;e.new_image(d,d);c.stroke('#EA4335').fill_opacity(0).stroke_width(d*0.2).ellipse(h,h,g/f,g/f,225,315).stroke('#FBBC05').ellipse(h,h,g/f,g/f,135,225).stroke('#34A853').ellipse(h,h,g/f,g/f,45,135).stroke('#4285F4').ellipse(h,h,g/f,g/f,348.5,45).line(h,h,d*0.989,h).draw(e);e.write($*[1])

उदाहरण

50x50

250x250

500x500

1000x1000

फ़ाइल दो मापदंडों को लेती है- पहला आयाम है और दूसरा आउटपुट के रूप में सहेजने के लिए फ़ाइल नाम है।

Ungolfed

require "RMagick"

# Take the user's input for dimension
d = $*[0].to_i

e = Magick::ImageList.new
e.new_image(d, d)

c = Magick::Draw.new

# Start by setting the color to red
c.stroke('#EA4335')

  # set opacity to nothing so that we don't get extra color.
  .fill_opacity(0)

  # set thickness of line.
  .stroke_width(d*0.2)

  # #ellipse creates an ellipse taking
  # x, y of center
  # width, height,
  # arc start, arc end
  .ellipse(d / 2, d / 2, (d - 1) / 2.5, (d - 1) / 2.5, 225, 315)

  # change to yellow and draw its portion
  .stroke('#FBBC05')
  .ellipse(d / 2, d / 2, (d - 1) / 2.5, (d - 1) / 2.5, 135, 225)

  # change to green and draw its portion
  .stroke('#34A853')
  .ellipse(d / 2, d / 2, (d - 1) / 2.5, (d - 1) / 2.5, 45, 135)

  # change to blue and draw its portion
  .stroke('#4285F4')
  .ellipse(d / 2, d / 2, (d-1)/2.5, (d - 1)/2.5, 348.5, 45)

  # creates the chin for the G
  .line(d/2, d/2, d*0.99, d/2)

  # draws to the created canvas
  .draw(e)

# save out the file
# taking the filename as a variable saves a byte over
# "a.png"
e.write($*[1])

मैंने शुरुआत में इसे oily_png / chunky_png का उपयोग करके हल करना शुरू कर दिया था, लेकिन यह RMMick की तुलना में बहुत अधिक जटिल होगा। RMagick की .ellipse फ़ंक्शन ने इसे एक हवा बना दिया और मुख्य काम सब कुछ के आकार / आकार को ट्यूनिंग के आसपास किया गया था।

यह मेरा पहला कोड गोल्फ सबमिशन (पहला एसई उत्तर भी है) और मैं केवल रूबी के साथ खुद को कुछ हद तक मध्यवर्ती मानता हूं। यदि आपके पास सुधार / सुझाव पर कोई इनपुट है, तो कृपया बेझिझक साझा करें!

Comments

मैं अपनी पोस्ट (404 त्रुटि) को संपादित करने के लिए प्रतीत नहीं कर सकता, लेकिन अगर मैं अपने गोल्फ समाधान से आवश्यकता रेखा को हटाने के लिए था जो 17 बाइट्स से दाढ़ी बनाता था और इसे 359 बाइट्स तक लाता था।

— महानगर

Answer 16

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

मैं वास्तव में यह प्रयोग करना चाहता था turtle। मुझे इसके लिए ज्योमेट्री के अपने ज्ञान को धूल चटाना था, चुनौती के विवरण में प्रदान किए गए कोण और लंबाई की गणना करना।

संपादित करें: हटा दिया गया है up(), क्योंकि ऐसा करने से हरे और नीले रंग के बीच सफेद रंग के छोटे ज़ुल्फ़ को हटा दिया जाता है और आंतरिक चक्र बेहतर दिखता है। यह कार्यक्रम को और भी धीमा कर देता है।

संपादित करें: तेजी से बनाने के लिए प्रतिस्थापित 9*nकिया 2*nगया। मैंने निर्धारित किया कि यह अभी भी एक चिकनी सर्कल बनाएगा।

from turtle import*
n=input()
C=circle
F=fill
K=color
q=90
w="white"
t=n*.3
lt(45)
def P(c,x,A):K(c);F(1);fd(x);lt(q);C(x,A,2*n);F(0);goto(0,0);rt(q)
for c in"#EA4335","#FBBC05","#34A853":P(c,n/2,q)
P(w,t,360)
K("#4285F4")
F(1)
fd(n/2)
lt(q)
a=11.537
C(n/2,45+a,2*n)
seth(0)
bk(.489*n)
rt(q)
fd(n/5)
lt(q)
fd(t)
F(0)
bk(t)
K(w)
F(1)
fd(.283*n)
lt(94-2*a)
C(t,a-45,2*n)
F(0)

टिप्पणियाँ:

1. ट्रिंकट्स पायथन 3 का उपयोग करते हैं, इसलिए इनपुट को इंट में डालना होगा।
2. ट्रिंकेट वास्तव में बड़े के लिए धीमी गति से चलते हैंnयदि आप हटाते हैं तोspeed(0) , जिसे मैंने केवल गति के लिए जोड़ा था।
3. कोड की सुस्ती ज्यादातर के तीसरे पैरामीटर की वजह से है circleबढ़ रही है O(n), क्योंकि यह ड्राइंग चक्र है के लिए कितने पक्षों को निर्धारित करता है खुदा बहुभुज,।

इसे ऑनलाइन आज़माएं

Ungolfed: इसे ऑनलाइन आज़माएं

मज़ेदार तथ्य: Trinket का विपर्यय शब्द है Tkinter, पायथन के GUI पैकेज और के लिए नींव turtle।

Comments

इसके अलावा, अगर किसी ने पायथन स्थापित किया है, तो क्या वे इसे nमेरे लिए बड़े मूल्य के साथ चला सकते हैं ? यदि यह अच्छा नहीं लगता है, तो मुझे sqrtअधिक सटीक होने के लिए कुछ एस लगाने की आवश्यकता हो सकती है । मैं हजारवें चक्कर लगा आया।

— mbomb007 17

500 के लिए आउटपुट। मुझे ठीक लगता है

— एक्रोलिथ

यह केवल बड़े मूल्य हैं जिनकी मुझे चिंता है। Trinket पर कैनवास की अधिकतम 400 है।

— mbomb007

तीन बड़े त्रिकोण दिखाई देते हैं और फिर ऐसा होता है।

— एक्रोलिथ

@daHugLenny कोई विचार नहीं। यह एक स्मृति समस्या हो सकती है, क्योंकि 10000 इतना बड़ा मूल्य है।

— mbomb007

Answer 17

PHP + GD, 529 449 बाइट्स

यह एक क्वेरी स्ट्रिंग पैरामीटर लेता है nऔर निर्दिष्ट आकार के लोगो के पीएनजी संस्करण को आउटपुट करता है।

<?php $n=$_GET['n'];$h=$n/2;$c='imagecolorallocate';$a='imagefilledarc';$i=imagecreatetruecolor($n,$n);$m=[$c($i,66,133,244),$c($i,52,168,83),$c($i,251,188,5),$c($i,234,67,53),$c($i,255,255,255)];imagefill($i,0,0,$m[4]);$j=-11.6;foreach([45,135,225,315]as$k=>$e){$a($i,$h,$h,$n,$n,$j,$e,$m[$k],0);$j=$e;}$a($i,$h,$h,$n*.6,$n*.6,0,0,$m[4],0);imagefilledrectangle($i,$h,$h-$n*.1,$h+$h*.98,$h+$h*.2,$m[0]);header('Content-Type:image/png');imagepng($i);

Ungolfed:

<?php

$n = $_GET['n'];$h=$n/2;
$c = 'imagecolorallocate';$a='imagefilledarc';
$i = imagecreatetruecolor($n,$n);

// Create array of colors
$m=[$c($i,66,133,244),$c($i,52,168,83),$c($i,251,188,5),$c($i,234,67,53),$c($i,255,255,255)];

// Fill background with white
imagefill($i, 0, 0, $m[4]);

// Create four arcs
$j=-11.6;
foreach([45,135,225,315]as$k=>$e){
    $a($i, $h, $h, $n, $n, $j, $e, $m[$k], 0);$j=$e;
}

// Hollow out the center and fill with white
$a($i, $h, $h, $n*.6,$n*.6,0,0,$m[4],0);

// create the horizontal bar
imagefilledrectangle($i,$h,$h-$n*.1,$h+$h*.98,$h+$h*.2,$m[0]);

// Output
header('Content-Type: image/png');
imagepng($i);

एन = 13:

एन = 200:

Comments

अधिकांश स्ट्रिंग स्थिरांक को कोई उद्धरण नहीं चाहिए। सच रंग छवि की जरूरत नहीं imagecolorallocate; ड्राइंग कार्यों को रंग के रूप में सिर्फ 0xRGGBB दें। कुछ और गोल्फिंग और 329 बाइट्स के लिए नीचे:, के imagefill($i=imagecreatetruecolor($n=$argv[1],$n),0,0,($m=[4359668,3450963,0xfbbc05,0xea4335,0xffffff])[4]);for($j=-11.6;$e=[45,135,225,315][$k];$j=$e)($a=imagefilledarc)($i,$h=$n/2,$h,$n,$n,$j,$e,$m[$k++],0);$a($i,$h,$h,$n*.6,$n*.6,0,0,$m[4],0);imagefilledrectangle($i,$h,$h-$n*.1,$h+$h*.98,$h+$h*.2,$m[0]);imagepng($i,"g.png");साथ चलाने -r, कमांड लाइन से इनपुट लेता है और आउटपुट करता है g.png।

— टाइटस

क्षमा करें, मेरा पिछला गोल्फ दो बाइट्स बहुत छोटा था: [$kहोना ही था [+$k। लेकिन यह एक के रूप में अच्छी तरह से काम करना चाहिए: imagefill($i=imagecreatetruecolor($n=$argv[1],$n),0,0,$w=2**24-1);$j=-11.6;foreach([$b=4359668,3450963,0xfbbc05,0xea4335]as$c)($a=imagefilledarc)($i,$h=$n/2,$h,$n,$n,$j,$j=45+90*$k++,$c,0);$a($i,$h,$h,$p=$n*.6,$p,0,0,$w,0);imagefilledrectangle($i,$h,$n*.4,$n*.99,$p,$b);imagepng($i,"g.png");(291 बाइट्स)

— टाइटस

@ टिट्स थैंक्स। मुझे इस उत्तर के बाद पता चला कि आपको इसकी आवश्यकता नहीं है imagecolorallocate। मैं आपके कोड के साथ अपना जवाब अपडेट करूंगा। लेकिन क्या आपको नाम दर्ज करने के लिए आउटपुट की आवश्यकता है? क्या आप सिर्फ फ़ाइल का नाम नहीं छोड़ सकते हैं imagepngऔर बस इसे स्टडआउट करने के लिए आउटपुट है?

— कोदोस जॉनसन

Answer 18

जावा, 568 बाइट्स

गोल्फ के लिए सबसे मजबूत भाषा नहीं है, लेकिन यहाँ मेरा सबसे अच्छा प्रयास है:

import java.awt.image.*;class G{public static void main(String[]b)throws Exception{int n=Integer.parseInt(b[0]),x,y,a,c;BufferedImage p=new BufferedImage(n,n,BufferedImage.TYPE_INT_RGB);for(y=0;y<n;y++){for(x=0;x<n;x++){double u=(x+.5)/n-.5,v=.5-(y+.5)/n,r=Math.hypot(u,v);a=(int)(Math.atan2(v,u)*4/Math.PI);c=0xFFFFFF;if(0<u&u<.4&-.1<v&v<.1)c=0x4285F4;else if(r<.3|r>.5);else if(a==0&v<.1)c=0x4285F4;else if(a==1|a==2)c=0xEA4335;else if(a==-1|a==-2)c=0x34A853;else if(a!=0)c=0xFBBC05;p.setRGB(x,y,c);}}javax.imageio.ImageIO.write(p,"png",new java.io.File("G.png"));}}

उपयोग:

> javac G.java
--> Compiles to G.class
> java G 400
--> Writes G.png in current working directory

Un-golfed version - मूल विचार समन्वय प्रणाली u, v ed [.50.5, 0.5] में काम करना है और छवि केंद्र से प्रत्येक पिक्सेल की दूरी और कोण की गणना करना है:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class Google {

    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(args[0]);
        int[] pixels = new int[n * n];

        for (int y = 0; y < n; y++) {
            for (int x = 0; x < n; x++) {
                double u = (x + 0.5) / n - 0.5;
                double v = 0.5 - (y + 0.5) / n;
                double r = Math.hypot(u, v);
                int a = (int)(Math.atan2(v, u) * 4 / Math.PI);
                int c = 0xFFFFFF;
                if (0 < u && u < 0.4 && Math.abs(v) < 0.1)
                    c = 0x4285F4;
                else if (r < 0.3 || r > 0.5)
                    /*empty*/;
                else if (a == 0 && v < 0.1)
                    c = 0x4285F4;
                else if (a == 1 || a == 2)
                    c = 0xEA4335;
                else if (a == -1 || a == -2)
                    c = 0x34A853;
                else if (a != 0)
                    c = 0xFBBC05;
                pixels[y * n + x] = c;
            }
        }

        BufferedImage image = new BufferedImage(n, n, BufferedImage.TYPE_INT_RGB);
        image.setRGB(0, 0, n, n, pixels, 0, n);
        ImageIO.write(image, "png", new File("G.png"));
    }

}

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

Answer 19

जाओ, 379 बाइट्स

import ."fmt"
func f(a int)(s string){
m:=map[string]float64{"fbbc05":-45,"ea4335":45,"4285f4":168.5,"34a853":225}
for k,v:=range m{s+=Sprintf("<use xlink:href=#c fill=#%v transform=rotate(%v,5,5) />",k,v)}
return Sprintf("<svg width=%v viewBox=0,0,10,10><def><path id=c d=M0,5A5,5,0,0,1,5,0V2A3,3,0,0,0,2,5 /></def>%v<rect x=5 y=4 fill=#4285f4 width=4.9 height=2 /></svg>",a,s)}

फ़ंक्शन fएक एकल intतर्क (स्केल फैक्टर) लेता है और एक एसवीजी छवि को उचित रूप से मापता है।

इसे Ideone पर ऑनलाइन आज़माएं।

उदाहरण आउटपुट:

<svg width=333 viewBox=0,0,10,10><def><path id=c d=M0,5A5,5,0,0,1,5,0V2A3,3,0,0,0,2,5 /></def><use xlink:href=#c fill=#34a853 transform=rotate(225,5,5) /><use xlink:href=#c fill=#fbbc05 transform=rotate(-45,5,5) /><use xlink:href=#c fill=#ea4335 transform=rotate(45,5,5) /><use xlink:href=#c fill=#4285f4 transform=rotate(168.5,5,5) /><rect x=5 y=4 fill=#4285f4 width=4.9 height=2 /></svg>

किसी भी प्रोग्रामिंग भाषा में हमारे Google अधिप्राप्तियों को उनके स्वयं के अलावा तुष्ट करना गलत लगता है।

Answer 20

सीजेएम, 141

ri:M.5*:K5/:T;'P3NMSMN255NM2m*[K.5-_]f.-{:X:mh:IK>0{X~0<\zT>|{IT3*<0{X~>X~W*>:Z2+{Z{X0=TW*>}4?}?}?}1?}?}%"^^G_8:nEhB%P9IW@zA"102b256b3/f=:+N*

इसे ऑनलाइन आज़माएं

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

स्पष्टीकरण:

ri:M                 read input, convert to int and store in M
.5*:K                multiply by 0.5 and store in K (M/2)
5/:T;                divide by 5 and store in T (M/10) and pop
'P3NMSMN255N         ppm header (N=newline, S=space)
M2m*                 generate all pixel coordinates - pairs of numbers 0..M-1
[K.5-_]              push the center (coordinates K-0.5, K-0.5)
f.-                  subtract the center from every pixel
{…}%                 map (transform) the array of coordinate pairs
  :X                 store the current pair in X
  :mh:I              calculate the hypotenuse of X (distance from the center)
                      and store in I
  K>0                if I>K (outside the big circle), push 0
  {…}                else…
    X~               dump X's coordinates (row, column)
    0<               check if the column is <0
    \zT>|            or the absolute value of the row is >T
    {…}              if true (outside the G bar)…
      IT3*<0         if I<T*3 (inside the small circle) push 0
      {…}            else (between the circles)…
        X~>          dump X and check if row>column (diagonal split)
        X~W*>:Z      also check if row>-column (other diagonal) and store in Z
                      (W=-1)
        2+           if in lower-left half, push Z+2 (2 for left, 3 for bottom)
        {…}          else (upper-right half)…
          Z{…}       if it's in the right quadrant
            X0=      get the row coordinate of X
            TW*>     compare with -T, resulting in 0 (above the bar) or 1
          4          else (top quadrant) push 4
          ?          end if
        ?            end if
      ?              end if
    1                else (inside the G bar) push 1
    ?                end if
  ?                  end if
"^^G … @zA"          push a string containing the 5 colors encoded
102b                 convert from base 102 to a big number
                      (ASCII values of chars are treated as base-102 digits)
256b                 convert to base 256, splitting into 15 bytes
3/                   split into triplets (RGB)
f=                   replace each generated number (0..4)
                      with the corresponding color triplet
:+N*                 join all the triplets, and join everything with newlines

Answer 21

जावास्क्रिप्ट (ईएस 6) (+ एसवीजी), 293 बाइट्स, गैर-प्रतिस्पर्धात्मक

document.write(`<svg id=o width=${prompt()} viewbox=0,0,50,50>`);m=`39,11`;`#EA433511,11
#FBBC0511,39
#34A85339,39
#4285F445,25L25,25`.replace(/(.{7})(.{5})(.*)/g,(_,s,t,u)=>m=document.write(`<path stroke=${s} d=M${m}A20,20,0,0,0,${t+u} fill=none stroke-width=10 stroke-linejoin=round />`)||t)

अफसोस की बात है कि गोल लाइन जॉइन काफी अनुरोधित प्रभाव नहीं है, लेकिन यह काफी करीब है।

Answer 22

FreeMarker + HTML / CSS, 46 + 468 = 514 बाइट्स

HTML:

<div><div></div><div></div><span></span></div>

सीएसएस:

div div,div span{position:absolute}div{width:10px;height:10px;box-sizing:border-box;transform-origin:top left;position:relative;transform:scale(${n*.1})}div div{border:2px solid;border-radius:9px;border-color:transparent #4285f4 transparent transparent;transform:rotate(33.4630409671deg);transform-origin:center}div div+div{border-color:#ea4335 transparent #34a853 #fbbc05;transform:none}div span{display:block;top:4px;bottom:4px;left:5px;right:.1px;background:#4285f4}

FreeMarker प्रोसेसर को एक चर nसेट के साथ निष्पादित किया जाता है , इनपुट का प्रतिनिधित्व करते हुए।

जादू की संख्या की व्याख्या:

सब कुछ 10x10px आवरण पर आधारित है, फिर इसके द्वारा स्केल किया गया है n/10।

• नीले क्षैतिज बॉक्स के दाईं ओर दूरी [px]: 5 - sqrt (5 ^ 2 - 1 ^ 2) = 0.10102051443 ( पाइथागोरस )
• नीले चाप का रोटेशन [गिरावट]: 45 - आर्किन (1/5) = 33.4630409671 ( साइन )

अनफॉस्लेटेड JSFiddle

Comments

CSS पार्ट को स्टाइल एलिमेंट में रखें और जावास्क्रिप्ट या PHP का उपयोग करें। की जगह transform:scale(n)के साथ transform:scale(<?=$_GET[n])?>(PHP)। जावास्क्रिप्ट में आप सीएसएस भाग को स्टाइल एलीमेंट में जोड़ सकते हैं

— Jörg Hülsermann

मैंने JS के बारे में सोचा, लेकिन कोड को बहुत ज्यादा खराब नहीं करना चाहता था। हालाँकि, टेम्प्लेटिंग भाषाएँ ठीक लगती हैं, इसलिए मैं FreeMarker के साथ गया और जल्दी से अपना उत्तर समायोजित कर दिया, धन्यवाद।

— सेड्रिक रीचेनबाक

नीले रंग की पट्टी दाईं ओर दाईं ओर बहुत दूर तक है

— रोबाऊ

नहीं, आप आसानी से सही लंबाई, 0.5, 0.1 और x के साथ एक समकोण त्रिभुज की कल्पना करके इसकी गणना कर सकते हैं, जहाँ x ब्लू बार की चौड़ाई को दर्शाता है, या तदनुसार 0.5 x इसकी दाईं ओर की दूरी। x तब पाइथागोरस प्रमेय का उपयोग करके निर्धारित किया जा सकता है (मैंने जो स्पष्टीकरण जोड़ा है)।

— सेड्रिक रीचेनबाक

JSFiddle ने मेरे द्वारा आजमाए गए दो ब्राउज़रों में सही तरीके से प्रदर्शित नहीं किया (Win10 x64) - क्रोम के साथ 54.0.2840.59 मीटर (64-बिट) नीली पट्टी दाईं ओर बहुत दूर तक फैली हुई है, और फ़ायरफ़ॉक्स 49.0.1 (32 के साथ) -बिट) नीले घुमावदार भाग के माध्यम से एक मामूली अंतर है

— एल्डरमैरेक्सिक्स

Answer 23

हास्केल के 343 ओकटेट

roman@zfs:~$ cat ppmG.hs
ppmG n='P':unlines(map show([3,n,n,255]++concat[
 case map signum[m^2-(2*x-m)^2-(2*y-m)^2,
 (10*x-5*m)^2+(10*y-5*m)^2-(3*m)^2,
 m-x-y,x-y,5*y-2*m,3*m-5*y,2*x-m]of
 1:1:1:1:_->[234,67,53]
 1:1:1:_->[251,188,5]
 [1,_,_,_,1,1,1]->[66,133,244]
 1:1:_:1:1:_->[66,133,244]
 1:1:_:_:1:_->[52,168,83]
 _->[255,255,255]|m<-[n-1],y<-[0..m],x<-[0..m]]))
roman@zfs:~$ wc ppmG.hs
 10  14 343 ppmG.hs
roman@zfs:~$ ghc ppmG.hs -e 'putStr$ppmG$42'|ppmtoxpm
ppmtoxpm: (Computing colormap...
ppmtoxpm: ...Done.  5 colors found.)

/* XPM */
static char *noname[] = {
/* width height ncolors chars_per_pixel */
"42 42 6 1",
/* colors */
"  c #4285F4",
". c #EA4335",
"X c #FBBC05",
"o c #34A853",
"O c #FFFFFF",
"+ c None",
/* pixels */
"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOO............OOOOOOOOOOOOOOO",
"OOOOOOOOOOOO..................OOOOOOOOOOOO",
"OOOOOOOOOO......................OOOOOOOOOO",
"OOOOOOOOO........................OOOOOOOOO",
"OOOOOOOO..........................OOOOOOOO",
"OOOOOOO............................OOOOOOO",
"OOOOOOXX..........................OOOOOOOO",
"OOOOOXXXX........................OOOOOOOOO",
"OOOOXXXXXX.......OOOOOOOO.......OOOOOOOOOO",
"OOOXXXXXXXX....OOOOOOOOOOOO....OOOOOOOOOOO",
"OOOXXXXXXXXX.OOOOOOOOOOOOOOOO.OOOOOOOOOOOO",
"OOXXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OOXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OOXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXOOOOOOOOOOOO                    O",
"OXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOO         O",
"OXXXXXXXXXOOOOOOOOOOOOOOOOOOOOOO         O",
"OOXXXXXXXXXOOOOOOOOOOOOOOOOOOOO         OO",
"OOXXXXXXXXXOOOOOOOOOOOOOOOOOOOO         OO",
"OOXXXXXXXXXXOOOOOOOOOOOOOOOOOO          OO",
"OOOXXXXXXXXooOOOOOOOOOOOOOOOOoo        OOO",
"OOOXXXXXXXoooooOOOOOOOOOOOOooooo       OOO",
"OOOOXXXXXooooooooOOOOOOOOoooooooo     OOOO",
"OOOOOXXXoooooooooooooooooooooooooo   OOOOO",
"OOOOOOXoooooooooooooooooooooooooooo OOOOOO",
"OOOOOOOooooooooooooooooooooooooooooOOOOOOO",
"OOOOOOOOooooooooooooooooooooooooooOOOOOOOO",
"OOOOOOOOOooooooooooooooooooooooooOOOOOOOOO",
"OOOOOOOOOOooooooooooooooooooooooOOOOOOOOOO",
"OOOOOOOOOOOOooooooooooooooooooOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOooooooooooooOOOOOOOOOOOOOOO",
"OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
};

व्याख्या

• "P3" == प्लेनटेक्स्ट पोर्टेबल पिक्समैप
• शो == "\ xFF \ xFF \ xFF" के लिए UTF-8 भ्रष्टाचार के डर से ASCII दशमलव का उत्पादन करें
• अनलाइन == अलग दशमलव को लाइनों में
• n == लंबाई [0..m] में समरूपता के लिए m = n-1
• m- (2x-m) ²- (2y-m) => 0 == (xm / 2) m + (ym / 2) (<(m / 2) = == आतंरिक घेरा
• (10x-5m) (+ (10y-5m) 3- (3m) 0> 0 == (xm / 2) ² + (ym / 2) ²> (m3 / 10) = = = OutInnerCircle
• mxy> 0 == x + y <m == inUpperLeft
• xy> 0 == x> y == inUpperRight
• 5y-2m> 0 == y> m2 / 5 == नीचे दिए गए
• 3y-5y> 0 == y <m3 / 5 == उपर
• 2x-m> 0 == x> m / 2 == inRightHalf
• [२३४,६ 23,५३] == लाल
• [२५१,१ 25 25,५] == पीला
• [५२,१६16, ]३] == हरा
• [६६,१३,२४४] == नीला
• [२५५,२५५,२५५] == सफेद

Comments

जब तक आप इसे 7-बिट ASCII (जो आप कर सकते हैं जब से आप उपयोग कर रहे उच्चतम चरित्र कोडपॉइंट के साथ कर सकते हैं 0x7C/ 124/ |) जिस स्थिति में यह हास्केल के 338 सेप्टेट होगा । लेकिन यह देखते हुए कि पिछले कुछ दशकों में 8-बिट्स-टू-ए-बाइट डेटा संग्रहण में कैसे मानक हो गया है, मुझे लगता है कि मृत घोड़े की धड़कन के बिना "बाइट्स" शब्द पर्याप्त विशिष्ट है।

— स्लिप डी। थॉम्पसन

Answer 24

एसएएस - 590 536 521 बाइट्स

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

मैंने पठनीयता के एक मोडिक के लिए लाइन ब्रेक को छोड़ दिया है, लेकिन मैं उन लोगों की गिनती नहीं कर रहा हूं, जो उनके बिना काम करते हैं।

%let R=;
%let F=FILLCOLOR;
ods graphics/width=&R height=&R;
proc template;
define statgraph a;
begingraph;
annotate;
endgraph;
end;
data d;
retain FUNCTION "RECTANGLE" DISPLAY "FILL" DRAWSPACE "graphPERCENT";
length &F$8;
_="CX4285F4";
P=100/&R;
HEIGHT=P;
width=P;
do i=1to &R;
x1=i*P;
U=x1-50;
do j=1to &R;
y1=j*P;
V=y1-50;
r=euclid(U,V);
&F="";
if 30<=r<=50then if V>U then if V>-U then &F="CXEA4335";
else &F="CXFBBC05";
else if V<-U then &F="CX34A853";
else if V<10then &F=_;
if &F>'' then output;
end;
end;
x1=65;
y1=50;
width=30;
height=20;
&F=_;
output;
proc sgrender sganno=d template=a;

संपादित करें: मैक्रो vars, डिफ़ॉल्ट सेटिंग्स और ऑपरेटरों की पसंद के उपयोग के माध्यम से कुछ और बाइट्स मुंडा।

संपादित करें 2: तर्क के do-endलिए ब्लॉकों से छुटकारा पा लिया if-then-elseऔर यह किसी भी तरह से अभी भी काम करता है - मुझे पूरी तरह से समझ में नहीं आता कि कैसे। इसके अलावा, मैं euclidसमारोह की खोज की !

Answer 25

एससीएसएस - 415 बाइट्स

इनपुट के रूप में $N: 100px;और <div id="logo"></div>, सुनिश्चित करें कि अगर ये कुल में गिना जाना चाहिए ...

$d:$N*.6;$b:$d/3;#logo{width:$d;height:$d;border:$b solid;border-color:#ea4335 transparent #34a853 #fbbc05;border-radius:50%;position:relative;&:before,&:after{content:'';position:absolute;right:-$b;top:50%;border:0 solid transparent}&:before{width:$b*4;height:$d/2;border-width:0 $b $b 0;border-right-color:#4285f4;border-bottom-right-radius:50% 100%}&:after{width:$N/2;margin:-$b/2 0;border-top:$b solid #4285f4}}

JSFiddle पर डेमो

Answer 26

रसदारपिक्सल्स पैकेज के साथ हास्केल , 306 बाइट्स

import Codec.Picture
p=PixelRGB8
c=fromIntegral
b=p 66 133 244
w=p 255 255 255
(n%x)y|y<=x,x+y<=n=p 234 67 53|y>x,x+y<=n=p 251 188 5|y>x,x+y>n=p 52 168 83|y>=0.4*n=b|1>0=w
(n#x)y|d<=h,d>=0.3*n=n%x$y|x>=h,d<=h,abs(y-h)<=n/10=b|1>0=w where h=n/2;d=sqrt$(x-h)^2+(y-h)^2
f n=generateImage(\x y->c n#c x$c y)n n

उपयोग उदाहरण:

main = writePng "google.png" $ f 1001

इसमें शायद सुधार किया जा सके। विचार एक समारोह को पास करना generateImageहै जो पिक्सेल का चयन करता है (रंग वास्तव में) जो कि स्थिति x, y पर जाना चाहिए। उसके लिए हम एक लैम्बडा का उपयोग करते हैं nजो एक पैरामीटर के रूप में जोड़ता है और उन सभी को एक ही समय में फ्लोट में रूपांतरित करता है। #समारोह मूल रूप से जाँच करता है अगर हम अंगूठी, बार, या कोई भी कर रहे हैं। यदि यह वह छल्ला है जिसे हम बैटन को पास करते हैं %, यदि बार हम सिर्फ नीले, अन्यथा सफेद रंग में लौटते हैं। %अगर हम नीले रंग में नहीं हैं, तो यह जाँचता है कि हम किस रंग में हैं और उपयुक्त रंग वापस करते हैं। नीला एक विशेष मामला है, क्योंकि हमें यह सुनिश्चित करने की आवश्यकता है कि यह लाल के चारों ओर लपेट नहीं करता है, इसलिए हम केवल नीले रंग में लौटते हैं यदि y"बार लाइन" से नीचे है अन्यथा हम सफेद वापस आते हैं। यह सामान्य अवलोकन है।

Answer 27

प्रसंस्करण संख्या - 244 बाइट + एन में अंकों की संख्या के लिए 1 बाइट

कोड के साथ शुरू करते हैं। यह प्रसंस्करण वातावरण में चिपकाया जा सकता है और भाग गया ( Nविभिन्न आकारों के लिए बदल रहा है )।

N=400
n=N/2
f=fill
a=['#34A853','#FBBC05','#EA4335','#4285F4']
def setup():
 size(N,N);noStroke()
def draw():
 for i in 1,3,5,7: f(a[i/2]);arc(n,n,N,N,i*PI/4+[0,.59][i>6],(i+2)*PI/4)
 f(205);ellipse(n,n,.6*N,.6*N);f(a[3]);rect(n,n-.1*N,.98*n,.2*N)

छोटा धोखा: लोगो से एक हिस्से को काट देने वाला सर्कल प्रसंस्करण के ग्रेस्केल शेड 205 में खींचा गया है, जो कि डिफ़ॉल्ट पृष्ठभूमि का रंग है। छवि को निर्यात करना समान नहीं लगेगा। यह करने के लिए एक कॉल बचाता है background(255)।

व्याख्या

N=400                 # set size
n=N/2                 # precompute center point
f=fill                # 3 usages, saves 3 bytes
a=['#34A853','#FBBC05','#EA4335','#4285F4']
                      # list of colors
def setup():          # called when starting sketch
 size(N,N)            # set size
 noStroke()           # disable stroking
def draw():           # drawing loop
 for i in 1,3,5,7:    # loop over increments of PI/4
  f(a[i/2])           # set fill color using integer
                      # division
  arc(n,n,N,N,i*PI/4+[0,.59][i>6],(i+2)*PI/4)
                      # draw a pizza slice between
                      # two coordinates. The 
                      #     [0,.59][i>6]
                      # accounts for the white part
 f(205)               # set fill color to Processing's
                      # default background
 ellipse(n,n,.6*N,.6*N)
                      # cut out center
 f(a[3])              # set fill to blue
 rect(n,n-.1*N,.98*n,.2*N)
                      # draw the straight part

उदाहरण

N = 400

N = 13 (प्रसंस्करण का न्यूनतम आकार 100x100 है)

ध्यान दें

हम हमारे मैन्युअल के लिए अनेक मान में संपादित करने के लिए अनुमति देते हैं Nकरने के लिए स्पष्ट कॉल setupऔर drawआवश्यक नहीं हैं और यह 213 बाइट्स + 3 में अंकों प्रति बाइट्स करने के लिए नीचे है N।

N=200
size(200,200)
n=N/2
f=fill
a=['#34A853','#FBBC05','#EA4335','#4285F4']
noStroke()
for i in 1,3,5,7:f(a[i/2]);arc(n,n,N,N,i*PI/4+[0,.59][i>6],(i+2)*PI/4)
f(205);ellipse(n,n,.6*N,.6*N);f(a[3]);rect(n,n-.1*N,.98*n,.2*N)

Comments

अपने आप में, यह एक पूर्ण कार्यक्रम नहीं है

— गायों की

काफी उचित। मैंने अधूरा कार्यक्रम को हटा दिया और इसे पूर्ण संस्करण के लिए प्रतिस्थापित किया।

— पिज्ज़यूयूडगैस्ट