ධනාත්මක නිඛිල N එකක් ගන්නා වැඩසටහනක් හෝ ශ්‍රිතයක් ලියන්න, සහ මෙම * ඉදිකිරීම අනුව ගූගල් හි “G” ලාංඡනයේ N × N පික්සල් රූපයක් ප්‍රතිදානය කරයි :

උදාහරණයක් ලෙස, N 400 නම්, නිවැරදි මානයන් සහ වර්ණ සහිත 400 × 400 පික්සල් ලාංඡනයක් ප්‍රතිදානය විය යුතුය:

N කොතරම් විශාල හෝ කුඩා වුවත් එය නිවැරදිව පෙනිය යුතුය. උදා: මෙහි N = 13:

ඔබේ කේතය අන්තර්ජාලයට සම්බන්ධ වීමට අවශ්‍ය නොවිය යුතුය. උදාහරණයක් ලෙස, බාහිරව සත්කාරක svg පරිමාණය කිරීමට අවසර නැත. (ඔබේ කේතයේ කේතනය කර ඇති එස්.වී.ජී. පරිමාණය කිරීම හොඳය.)

ප්‍රති-අන්වර්ථකරණය භාවිතා කළ හැකිය හෝ නොකෙරේ. එය ඔයාට බාරයි.

"ජී" හි තිරස් තීරුව රූපයේ දකුණු දාරය දක්වා විහිදෙන්නේ නැති බව සැලකිල්ලට ගන්න. රවුම කපා හැරීමට පෙර සාමාන්‍යයෙන් දකුණු දාරයේ වක්‍රය වක්‍ර වේ.

බයිට් වල කෙටිම කේතය ජය ගනී.

^{* මෙම අභියෝගය සඳහා ලාංඡනය ඉදිකිරීම සරල කර ඇත. නිවැරදි ඉදිකිරීම් මෙහි සහ මෙහි දැකිය හැකිය .}

ගණිතය, 229 226 225 224 221 206 169 බයිට්

ස්තූතියි art බයිට් 1 ක් සඳහා මාටින් එන්ඩර්, බයිට් 37 ක් සඳහා චිප්හර්ස්ට් !

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 දක්වා ...

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

වර්ණ හෙක්ස් කේත RGBColorවස්තු බවට පරිවර්තනය කරන්න , එවිට ඒවා ගූගල් ලාංඡන ග්‍රැෆික් වෙත යෙදිය හැකිය. වර්ණ මාලාව <input>th වර්ණයට වෙනස් කරන්න .

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

(0, -1) සහ (වර්ග (24), 1) හි විකර්ණ කොන් වන පිරවූ සෘජුකෝණාස්රයක් (2D කියුබොයිඩ්) සාදන්න.

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

Annulusඅභ්‍යන්තර අරය 3 සහ පිටත අරය 5 සහිත මූලාරම්භය කේන්ද්‍ර කර ගත් පිරවූ කාර්තු හතරක් ජනනය කරන්න. අතීතය අඳින්න එපා ArcCsc@5(නිල් කොටස අවසන් වන තැන).

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

X = -5 සිට x = 5 දක්වා N x N ප්‍රමාණයෙන් ග්‍රැෆික් එකක් සාදන්න (පෑඩින් ඉවත් කරයි).

නිමැවුම්

එන් = 10

එන් = 100

එන් = 200

N = 10000 (සම්පූර්ණ විභේදනය සඳහා රූපය ක්ලික් කරන්න)

සී (වින්ඩෝස්), බයිට් 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);}}

"N" විධාන රේඛා තර්කය ලෙස ගෙන කෙලින්ම තිරය මතට ඇද ගනී.

ගොල්ෆ් නොකළ:

#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! */
}

පයිතන් 2, 244 220 බයිට්

[-1,1] plane 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

JavaScript (ES6), 408 ... 321 317 බයිට්

කැන්වස් මූලද්‍රව්‍යය සඳහා ජාවාස්ක්‍රිප්ට් + 24 13 බයිට් 384 383 371 367 359 327 316 308

(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 ක් ඉතිරි කර ඇත.
කොනෝර් ඕ බ්‍රයන් හට ස්තූතියි බයිට් 11 ක් HTML හි සුරකින ලදි. ප්‍රින්ස්හෝර්න්ට ස්තූතිවන්ත වෙමින්
බයිට් 12 ක් ඉතිරි කර withඇත.
වඩා හොඳ භාවිතයෙන් බයිට් 4 ක් ඉතිරි කර ඇත z=q-y/2.
8 බයිට් භාවිතා ගැලවීම parentNodeහා backgroundඇලෙක්සිස් ටයිලර් ස්තුති.
නිල් චාප / තීරුව වඩාත් නිවැරදිව ඇඳීමෙන් බයිට් 32 ක් ඉතිරි කර ඇති බැවින් එහි කොටසක් මකා දැමීමට මට අවශ්‍ය නැත.
තේජස් කැලේට ස්තූතිවන්ත වෙමින් එහි මව් නෝඩ් වෙනුවට කැන්වස් සීඑස්එස් සැකසීමෙන් බයිට් 11 ක් ඉතිරි කර ඇත.
8 බයිට් භාවිතා ගැලවීම withහා mapතනි ප්රකාශය, '' 2d` වෙනුවට සමග ('2d'), n/5වෙනුවට .2*nසහ පසුතලය ආරම්භනය prompt(...).
ආදේශ Math.PI/4කිරීමෙන් බයිට් 4 ක් සුරකින ලදි.7854 එය රොබ් ඕට ස්තූතිවන්ත වන බව පෙනේ.

පැහැදිලි කිරීම:

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

කැන්වස් මානයන් පරිශීලක ආදානය සමඟ ආරම්භ කර ඇති අතර පසුබිම සුදු පැහැයට සකසා ඇත. 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)))

මක්නිසාද යත් එක් එක් වර්ණය රවුම් කොටස ඇද ගන්නා අතර අවසාන (නිල්) සඳහා යම් ගැලපීමක් සිදු කරයි. සෑම වර්ණයක් සඳහාම එකම ස්ථානයක එකම මානයන් සහිත තීරුව අඳින්නේ අවසාන (නිල්) වර්ගය පමණි.

බීබීසී බේසික්, බයිට් 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.

HTML / JS, බයිට් 680 624

බයිට් 624 ක් ලබා ගැනීම සඳහා, අන්තිම ඉවත් කරන්න ;, මෙය HTML ආනයනය කරන ආකාරය නිසා පහත ස්නිපටය සඳහා අවශ්‍ය වේ. එසේම, ෆයර්ෆොක්ස් සහාය නොදක්වන image-rendering: pixelatedඅතර -moz-crisp-edgesඒ වෙනුවට අවශ්‍ය බව පෙනේ (ස්තූතියි @alldayremix !) එය ෆයර්ෆොක්ස් විසඳුමක් +7 කරයි, නමුත් මෙය ක්‍රෝම් හි අපේක්ෂිත පරිදි ක්‍රියාත්මක වේ.

උපයෝගී JavaScript ඉල්ලීමක් Nහා <style>තත්ත්වය / වර්ණ දී මූලද්රව්ය වාරණ. කැන්වසයකට මෝස්තර යෙදීමට වඩා මූලික HTML අංග භාවිතා කරයි (එය පෙනෙන ආකාරයට වඩා කෙටි ප්‍රවේශයකි!). මෙය data:වර්ණවත් මූලද්‍රව්‍ය වෙනුවට යූආර්අයි පසුබිම් රූපයක් භාවිතා කරමින් නවීකරණය කරන ලද ප්‍රවේශයකි . මෙම නව බ්‍රව්සර් අඩුවෙන් ක්‍රියා කරන්නේ නම් මම පෙර ප්‍රවේශය පහතින් තබා ඇත.

මම හිතුවේ මෙය අවසන් වීමට වඩා බොහෝ කුඩා වනු ඇති බවයි, නමුත් එය සිත්ගන්නාසුලු ව්‍යායාමයක් විය!

<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

Imagemagick (නමුත් ඇත්ත වශයෙන්ම තැපැල් පිටපත), 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).

මෙම සංස්කරණ යෝජනා කිරීම ගැන ජුජාට ස්තූතියි!

පැරණි පරිමාණය, බයිට් 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

මැට්ලැබ්, 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])

පර්ල් 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 වෙතින් ස්ථාපනය කළ යුතු Imager මොඩියුලය අවශ්‍ය වේ . එක් පූර්ණ සංඛ්‍යාවක් විධාන රේඛා තර්කයක් ලෙස ගනී. රූපය ප්‍රති-අන්වර්ථ නොවේ, එබැවින් එය ටිකක් කැතයි.

පහත කේතය ගොනුවකට පිටපත් කරන්න 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 භාවිතා කළෙමි . මම obfuscated කේතය දැනටමත් පළමු වෙනුවට දැක ගත හැකි, golfed විය evalසමඟ print.

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>

ලාංඡනය, බයිට් 258

... ලාංඡනය භාවිතයෙන් ලාංඡන සෑදිය යුතු යැයි මම සිතමි . මෙය ශ්‍රිතයක් ලෙස ක්‍රියාත්මක වේ. මම එය සංවර්ධනය කළේ Calormen.com හි මාර්ගගත ලාංඡන පරිවර්තකය භාවිතා කරමිනි

මම මුලින් උත්සාහ කළේ එක් එක් කොටස අඳින්න සහ තීන්ත පුරවන්න, නමුත් එය බලාපොරොත්තු වූවාට වඩා විශාල විය. නාස්ති වූ චලනයන් පසුබැසීම් සහ එවැනි දේ රාශියක් විය. ඒ වෙනුවට, ධ්‍රැවීය ප්‍රස්ථාර අතුගෑමක් කිරීමට මම තීරණය කළෙමි. ගණිතයේ දුෂ්කර කොටස වූයේ ජී හි සෘජුකෝණාස්රයේ ඉහළින් ඇති වක්‍රය සඳහා ජ්‍යාමිතිය කිරීමයි. ඔබට දශම කිහිපයක් කපා අඩු නිරවද්‍යතාවයක් තිබිය හැකිය, නමුත් සාමාන්‍ය තිර ප්‍රමාණයට සරිලන පරිදි මෙය ඉලක්කම් 3 ක් පමණ නිවැරදි වීමට මට අවශ්‍ය විය.

ගොල්ෆ්

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

ජාවාස්ක්‍රිප්ට් (ඊඑස් 7), 285 258 254 252 251 බයිට්

ලාංඡනයේ පළල (999 දක්වා) ඉල්ලා සිටින අතර එය කැන්වසයකින් ඇද ගනී, පික්සෙල් එකකට පික්සෙල්.

සංස්කරණය කරන්න : ආරම්භක අනුවාදය වූයේ කාටිසියානු ඛණ්ඩාංක (x,y)ධ්‍රැවීය ඛණ්ඩාංක බවට පරිවර්තනය කිරීමයි (r,a), නමුත් අපට ඇත්ත වශයෙන්ම කෝණය අවශ්‍ය නොවේ. අතර සැසඳීම් කිරීම xසහ yඅප කුමන කාර්තුවේ දැයි සොයා ගැනීම සරල (හා සැලකිය යුතු ලෙස කෙටි) ය .

සංස්කරණය කරන්න : ETHproductions වලට ස්තූතියි බයිට් 1 ක් ඉතිරි කර ඇත.

ජේඑස්, 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>

ES6 අනුවාදය: 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>

සී #, 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:

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>

පරිණාමනයන්ට වඩා රේඛීය ශ්‍රේණි භාවිතා කරයි. සංස්කරණය කරන්න: ardarrylyeo ට ස්තූතියි බයිට් 140 ක් ඉතිරි කර ඇත. ශ්‍රේණිය වෙනුවට අමතර මූලද්‍රව්‍යයක් භාවිතා කරමින් බයිට් 20 ක් ඉතිරි කර ඇත. BSDBS ට ස්තූතියි බයිට් 24 ක් ඉතිරි කර ඇත. Ed හෙඩිට ස්තූතියි බයිට් 16 ක් ඉතිරි කර ඇත. පිටුපස සිට ඉදිරිපස දක්වා, විවිධ ස්ථර:

• a නිල් කවය
• b තීරුවට ඉහළින් ඇති කොටස අපැහැදිලි කිරීමට සුදු සෘජුකෝණාස්රයක්
• c රතු / කහ ඉහළ වම් කාර්තුව
• d රතු අෂ්ටකය ඉහළ දකුණ
• e කහ / කොළ පහළ වම් කාර්තුව
• f කොළ / නිල් පහළ දකුණු කාර්තුව
• g අභ්යන්තර සුදු කවය
• h තිරස් නිල් තීරුව

රූබි 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])

මම මුලින් මෙය තෙල් සහිත_පං / චන්කි_පන්ග් භාවිතයෙන් විසඳීමට පටන් ගෙන ඇති නමුත් එය ආර්මැජික් හා සසඳන විට බොහෝ සෙයින් සංකීර්ණ වනු ඇත. RMagick ගේ .ellipse ශ්‍රිතය මෙය සුළඟක් බවට පත් කළ අතර ප්‍රධාන කාර්යය වූයේ සෑම දෙයකම හැඩයන් / ප්‍රමාණයන් සුසර කිරීමයි.

මෙය මගේ පළමු කෝඩ් ගොල්ෆ් ඉදිරිපත් කිරීම (පළමු SE පිළිතුර ද) වන අතර මා සලකන්නේ රූබී සමඟ තරමක් අතරමැදියෙකු ලෙස පමණි. වැඩිදියුණු කිරීම / ඉඟි පිළිබඳව ඔබට කිසියම් ආදානයක් තිබේ නම්, කරුණාකර බෙදා ගැනීමට නිදහස් වන්න!

පයිතන් 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 භාවිතා කරයි, එබැවින් ආදානය int වෙත දැමිය යුතුය.
2. ඔබ ඉවත් කළහොත් විශාල ප්‍රමාණයක් සඳහා ට්‍රින්කෙට් ඉතා මන්දගාමී වේ .nspeed(0)
3. කේතයේ මන්දගාමී වීමට බොහෝ දුරට හේතු වන්නේ circleවර්ධනය වන තුන්වන පරාමිතියයි O(n), මන්ද එය රවුම ඇඳීම සඳහා කොටා ඇති බහුඅවයවයේ පැති කොපමණ දැයි තීරණය කරයි.

එය මාර්ගගතව උත්සාහ කරන්න

Ungolfed: එය මාර්ගගතව උත්සාහ කරන්න

විනෝදජනක කාරණය: පයිතන්ගේ GUI පැකේජයේ Trinketඇනග්‍රෑම් එකක් Tkinterවන අතර ඒ සඳහා අඩිතාලම වේ turtle.

PHP + GD, බයිට් 529 449

මෙය විමසුම් නූල් පරාමිතියක් nගෙන නිශ්චිත ප්‍රමාණයේ ලාංඡනයේ PNG අනුවාදයක් ප්‍රතිදානය කරයි.

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

N = 13:

එන් = 200:

ජාවා, බයිට් 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

ගොල්ෆ් නොකළ අනුවාදය - මූලික අදහස වන්නේ සම්බන්ධීකරණ පද්ධතියේ u, v ∈ [.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 ඩී වැනි ඉහළ මට්ටමේ ග්‍රැෆික් චර්යාවන් භාවිතා කරන විකල්ප ක්‍රියාත්මක කිරීමක් නිර්මාණය කළ හැකිය , විශේෂයෙන් ප්‍රති- අන්වර්ථකරණය සමඟ.

යන්න, බයිට් 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තර්කයක් (පරිමාණ සාධකය) ගෙන සුදුසු පරිදි පරිමාණය කරන ලද SVG රූපයක් ප්‍රතිදානය කරයි.

අයිඩියොන් හි එය මාර්ගගතව උත්සාහ කරන්න .

උදාහරණ ප්‍රතිදානය:

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

අපගේ ගූගල් අධිපතීන් ඔවුන්ගේ භාෂාව හැර වෙනත් ක්‍රමලේඛන භාෂාවකින් සතුටු කිරීම වැරදිය.

සී ජෑම්, 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 ppm ආකෘතියෙන් ප්‍රතිදානය කරයි.
බ්රවුසරයේ බැලීමට වඩා සුදුසු 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

JavaScript (ES6) (+ SVG), බයිට් 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)

කනගාටුවට කරුණක් නම්, වටකුරු සම්බන්ධ වීම ඉල්ලූ බලපෑමක් නොවේ, නමුත් එය ඉතා ආසන්නයි.

FreeMarker + HTML / CSS, 46 + 468 = බයිට් 514

HTML:

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

CSS:

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 - වර්ග (5 ^ 2 - 1 ^ 2) = 0.10102051443 ( පයිතගරස් )
• නිල් චාපයේ භ්‍රමණය [deg]: 45 - arcSin (1/5) = 33.4630409671 ( සයින් )

Ungolfed JSFiddle

හස්කල්ගේ අෂ්ටක 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" == සරල පෙළ අතේ ගෙන යා හැකි පික්ස්මැප්
• show == "\ xFF \ xFF \ xFF" සඳහා UTF-8 දූෂණයට බිය වන ASCII දශම නිෂ්පාදනය කරන්න.
• unlines == දශම සංඛ්‍යා රේඛා වලට වෙන් කරන්න
• n == දිග [0..m] හි සමමිතිය සඳහා m = n-1
• m²- (2x-m) ²- (2y-m) ²> 0 == (xm / 2) ² + (ym / 2) ² <(m / 2) ² == ඇතුළත පිටත චක්‍රය
• (10x-5m) ² + (10y-5m) ²- (3m) ²> 0 == (xm / 2) ² + (ym / 2) ²> (m3 / 10) ² == outsideInnerCircle
• mxy> 0 == x + y <m == inUpperLeft
• xy> 0 == x> y == inUpperRight
• 5y-2m> 0 == y> m2 / 5 == belowGbarTop
• 3y-5y> 0 == y <m3 / 5 == ඉහත GbarBot
• 2x-m> 0 == x> m / 2 == inRightHalf
• [234,67,53] == රතු
• [251,188,5] == කහ
• [52,168,83] == කොළ
• [66,13,244] == නිල්
• [255,255,255] == සුදු

SAS - 590 536 521 බයිට්

මෙය GTL විවරණ පහසුකම භාවිතා කරයි . පළමු පේළියේ සාර්ව විචල්‍යයකින් ආදානය නියම කර ඇත. අමතර බයිට් කිහිපයක් සඳහා ඔබට සියල්ල සාර්ව ලෙස අර්ථ දැක්විය හැකිය. ඕනෑම දෙයක් කුමන්ත්‍රණය කිරීමට ඔබට ශුන්‍ය ප්‍රස්ථාර අච්චුවක් නිර්වචනය කළ යුතු වුවද, එය තවමත් ජාවා සහ HTML පිළිතුරු කිහිපයක් යටින් ගිලී යයි!

කියවීමේ හැකියාව සඳහා මා රේඛාව කැඩී ගොස් ඇත, නමුත් ඒවා නොමැතිව ක්‍රියා කරන බැවින් මම ඒවා ගණන් නොගනිමි.

%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;

සංස්කරණය කරන්න: සාර්ව වර්ස්, පෙරනිමි සැකසුම් සහ ක්‍රියාකරුවන් තෝරා ගැනීමෙන් තවත් බයිට් කිහිපයක් කපා දමන්න.

2 වන සංස්කරණය: තර්කනය do-endසඳහා වූ කොටස් ඉවත් කර if-then-elseඑය කෙසේ හෝ තවමත් ක්‍රියාත්මක වේ - කෙසේ දැයි මට සම්පූර්ණයෙන්ම වැටහෙන්නේ නැත. එසේම, මම euclidකාර්යය සොයා ගත්තා !

SCSS - බයිට් 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 හි නිරූපණය

ජුසිපික්සෙල් පැකේජය සමඟ හස්කල් , බයිට් 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

මෙය බොහෝ විට වැඩිදියුණු කළ හැකිය. generateImageX, y ස්ථානයට යා යුතු පික්සෙල් (වර්ණය සැබවින්ම) තෝරා ගන්නා ශ්‍රිතයක් සම්මත කිරීම මෙහි අදහසයි . ඒ සඳහා අපි nපරාමිතියක් ලෙස එකතු කරන ලැම්බඩා භාවිතා කරන අතර ඒවා සියල්ලම එකවර පාවෙන බවට පරිවර්තනය කරමු. මෙම #කාර්යය මූලික වශයෙන් චෙක්පත් අපි මුද්ද, බාර්, හෝ වත් ඉන්නේ නම්. එය මුද්ද නම් අපි බැටන් පොල්ල පසුකර යන්නෙමු %, බාර්එක අපි නිල් පැහැයට හැරේ නම්, එසේ නොමැතිනම් සුදු ය. %අප සිටින්නේ කුමන වර්ගයේදැයි පරීක්ෂා කර නිල් පාට නොවේ නම් සුදුසු වර්ණය ලබා දෙයි. නිල් පැහැය විශේෂ අවස්ථාවකි, මන්ද එය රතු පැහැයට නොගැලපෙන බවට වග බලා ගත යුතුය, එබැවින් අපි නිල් පාටට yඑන්නේ “තීරු රේඛාවට” පහළින් නම් පමණි . සාමාන්‍ය දළ විශ්ලේෂණය එයයි.

Processing.py - එන් හි ඉලක්කම් ගණන සඳහා බයිට් 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)