Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą N i wysyła piksel N × N logo Google „G” zgodnie z następującą * konstrukcją:

Na przykład, jeśli N ma wartość 400, należy wydrukować logo o wymiarach 400 x 400 pikseli, o prawidłowych wymiarach i kolorach:

Powinien on wyglądać dokładnie, niezależnie od tego, jak duży lub mały jest N. np. tutaj jest N = 13:

Twój kod nie powinien wymagać połączenia z Internetem. Na przykład skalowanie hostowanego zewnętrznie pliku SVG jest niedozwolone. (Skalowanie pliku svg zakodowanego w kodzie byłoby jednak w porządku).

Wygładzanie może być stosowane lub nie. To zależy od Ciebie.

Zauważ, że poziomy pasek „G” nie rozciąga się aż do prawej krawędzi obrazu. Okrąg wygina się normalnie do wewnątrz na prawej krawędzi przed odcięciem.

Najkrótszy kod w bajtach wygrywa.

^{* Konstrukcja logo została uproszczona dla tego wyzwania. Prawidłową konstrukcję można zobaczyć tu i tutaj .}

Mathematica, 229 226 225 224 221 206 169 bajtów

Dzięki @MartinEnder za 1 bajt, @ChipHurst za 37 bajtów!

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

Co za fajne wyzwanie!

Wyjaśnienie

...&~Array~4

Iteruj od 1 do 4 ...

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

Konwertuj kolorowe kody szesnastkowe na RGBColorobiekty, aby można je było zastosować do grafiki logo Google. Zmień paletę kolorów na <input>kolor th.

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

Utwórz wypełniony prostokąt (prostopadłościan 2D), którego narożniki po przekątnej to (0, -1) i (sqrt (24), 1).

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

Wygeneruj cztery wypełnione ćwiartki Annulus, wyśrodkowane na początku, z wewnętrznym promieniem 3 i zewnętrznym promieniem 5. Nie rysuj obok ArcCsc@5(gdzie kończy się niebieski segment).

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

Utwórz grafikę o rozmiarze N x N, od x = -5 do x = 5 (usuwa wypełnienie).

Wyjścia

N = 10

N = 100

N = 200

N = 10000 (kliknij obraz, aby uzyskać pełną rozdzielczość)

C (Windows), 311 bajtów

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

Bierze „N” jako argument wiersza poleceń i rysuje bezpośrednio na ekranie.

Bez golfa:

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

Python 2, 244 220 bajtów

używając transformacji Martina Rosenau na płaszczyźnie [-1,1] ^ 2 i drobnych golfa, takich jak usuwanie 0.lub nawiasy

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)

Wyjaśnienie:

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
 )

Wyjście jako binarny PPM, użycie:

python golf_google.py > google.ppm

Przykłady

• 13

• 50

• 100

• 1337

poprzednie rozwiązanie 244 bajtów

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

Ungolfed beta wersja przed eliminacją if / else:

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 bajtów

384 383 371 367 359 327 316 308 304 bajty JavaScript + 24 13 bajtów dla elementu canvas

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

Zapisano 1 bajt, rysując w lewo.
11 bajtów zapisanych w HTML dzięki Conor O'Brien.
12 bajtów zapisanych przy użyciu withbloku dzięki Prinzhorn.
4 bajty zapisane z lepszym wykorzystaniem z=q-y/2.
8 bajtów zapisanych przy użyciu parentNodei backgrounddzięki Alexis Tyler.
32 bajty zapisane dzięki bardziej precyzyjnemu rysowaniu niebieskiego łuku / paska, więc nie muszę już wymazywać jego części.
11 bajtów zapisanych przez ustawienie canvas css zamiast jego parentNode dzięki Tejas Kale.
8 bajtów zapisanych za pomocą withi mapza pomocą pojedynczej instrukcji, zamiast `2d` zamiast ('2d'), n/5zamiast .2*ninicjalizacji tła w prompt(...).
4 bajty zapisane, zastępowane Math.PI/4przez.7854 co wydaje się wystarczająco precyzyjne dzięki RobAu.

Wyjaśnienie:

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

Wymiary obszaru roboczego są inicjowane przez użytkownika, a tło jest ustawione na biały. qjest zainicjowany.

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

Dla każdego koloru rysuje część koła, z pewną korektą dla ostatniego (niebieskiego). Pasek jest rysowany dla każdego koloru w tym samym miejscu o tych samych wymiarach, więc widoczny jest tylko ostatni (niebieski).

BBC BASIC, 177 bajtów

Pobierz tłumacza na 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

BBC BASIC używa 2 jednostek = 1 piksel, więc wykreślamy G njednostek promienia (= n / 2 pikseli) w środku n,n.

Chodzi o to, aby narysować serię promieniowych linii, zmieniając odpowiednio kolor. Stwierdzono, że między liniami występowały niewielkie przerwy z powodu obcięcia liczb podczas konwersji na piksele, więc zamiast tego drukowane są cienkie trójkąty.

Po zakończeniu przeciągnięcia linii kursor znajduje się w prawym górnym rogu niebieskiego obszaru. Podano pojedynczą współrzędną dla przeciwległego rogu po przekątnej, aby narysować prostokąt w celu uzupełnienia kształtu.

Nie golfił

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 bajtów

Aby uzyskać 624 bajty, usuń ostatni ;, jest to konieczne dla poniższego fragmentu ze względu na sposób importowania HTML. Ponadto Firefox wydaje się nie obsługiwać image-rendering: pixelatedi potrzebuje -moz-crisp-edgeszamiast tego (dzięki @alldayremix !), Co sprawia, że ​​Firefox +7 działa, ale działa w Chrome zgodnie z oczekiwaniami.

Wykorzystuje JavaScript do żądania Noraz <style>blok do pozycjonowania / pokolorowania elementów. Wykorzystuje podstawowe elementy HTML, zamiast stosować style do kanwy (co, jak się wydaje, było znacznie krótsze!). Jest to zmienione podejście z użyciem data:obrazu tła URI zamiast tylko kolorowych elementów. Zachowałem poprzednie podejście na wypadek, gdyby to nowe działało na mniejszej liczbie przeglądarek.

Myślałem, że będzie o wiele mniejszy niż ostatecznie, ale mimo to było to ciekawe ćwiczenie!

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

Poprzednia wersja:

<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

Bash z Imagemagick (ale tak naprawdę Postscript), 268 255 249 bajtów

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

Podwojono skalowanie, aby usunąć setlinewidth, zastąpiono jednym współczynnikiem skali dupi połączyłem spację w Azmienną (nie można tego zrobić, Cponieważ $C45jest analizowany jako „zmienna C45”).

Dzięki joojaa za sugerowanie tych zmian!

Stara skala, 255 bajtów

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

Pobiera N jako jedyny argument i wysyła do o.png.

Ungolfed Postscript for Old Scale

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

MATLAB, 189 184 bajtów

[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])

bez golfa

[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])

Perl 5, 486 477 476 450 (+7 dla -MImagerflagi) = 457 bajtów

Za sprawą Dady zaoszczędziłem kilka bajtów, używając newwywołań funkcjonalnych i pozbywając się parenów, a także popzamiast $ARGV[0]ostatniego średnika. Zaoszczędziłem trochę więcej, umieszczając to $n=poptam , gdzie jest po raz pierwszy użyte, i używając notacji przestrzeni nazw Perl 4 'zamiast ::.

$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')

Wymaga modułu Imager , który należy zainstalować z CPAN. Bierze jedną liczbę całkowitą jako argument wiersza poleceń. Obraz nie jest wygładzony, więc jest trochę brzydki.

Skopiuj poniższy kod do pliku g.pl. Potrzebujemy dodatkowych +7 bajtów na -MImagerflagę, ale to oszczędza kilka bajtów, ponieważ nie jest to konieczne use Imager;.

$ perl -MImager g.pl 200

Oto różne rozmiary:

N = 10

N = 100

N = 200

Całkowicie nieznany kod jest prosty.

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

Ten post poprzednio miał kod w kształcie obrazu wyjściowego. Ponieważ jest to niezgodne z zasadami kodeksu golfowego, musiałem go usunąć. Zobacz historię zmian, jeśli chcesz rzucić okiem. Użyłem Acme :: EyeDrops do stworzenia tego, o kształcie, który utworzyłem z obrazu utworzonego za pomocą samego programu, który przekonwertowałem na grafikę ASCII. Kod I ukrywane już grałem, które mogą być postrzegane przez zastąpienie pierwszy evalz print.

PHP + SVG, 300 bajtów

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

Część skalująca jest width=<?=$_GET[w]?>

Wyjście dla wartości 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>

Logo, 258 bajtów

... bo myślę, że logo powinno być wykonane przy użyciu Logo . Jest to realizowane jako funkcja. Opracowałem go za pomocą internetowego interpretera logo Calormen.com

Początkowo próbowałem narysować każdy segment i malować go, ale okazało się, że był większy niż oczekiwano. Było wiele zmarnowanych ruchów i takie tam. Zamiast tego zdecydowałem się na zamiatanie wykresu biegunowego, dostosowując kolor na podstawie nagłówka. Trudniejszą częścią matematyki było wykonywanie geometrii krzywej u góry prostokąta G. Możesz przyciąć niektóre miejsca po przecinku i mieć mniejszą dokładność, ale chciałem, aby była to dokładność do około 3 cyfr, aby pomieścić typowe rozmiary ekranu.

Grał w golfa

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

Próba

g 200

Nie golfił

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

JavaScript (ES7), 285 258 254 252 251 bajtów

Monituje o szerokość logo (do 999) i rysuje je na kanwie, piksel na piksel.

Edycja : Początkowa wersja konwertuje współrzędne kartezjańskie na współrzędne (x,y)biegunowe (r,a), ale tak naprawdę nie potrzebujemy kąta. Łatwiej (i znacznie krócej) po prostu dokonać porównań xi ydowiedzieć się, w którym kwartale jesteśmy.

Edycja : Zapisano 1 bajt dzięki produktom ETH.

J, 251 224 220 218 217 bajtów

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 bajty

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

Wersja ES6: 258 231 227 225 224 + 34 = 258 bajtów

Zalecana maksymalna szerokość fragmentu: 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>

C #, 276 + 21 = 297 bajtów

276 bajtów dla metody + 21 bajtów dla importu System.Drawing.

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

Na podstawie algorytmu Martina Rosenau. Dzięki za trudny pomysł wymyślenia sposobu na zbudowanie obrazu!

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 bajtów

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

Używa gradientów liniowych zamiast przekształceń. Edycja: Zapisano 140 bajtów dzięki @darrylyeo. Zaoszczędzono 20 bajtów, używając dodatkowego elementu zamiast gradientu. Zaoszczędź 24 bajty dzięki @DBS. Zaoszczędź 16 bajtów dzięki @Hedi. Od tyłu do przodu różne warstwy to:

• a Niebieskie koło
• b Biały prostokąt zasłaniający część nad paskiem
• c Czerwono-żółta górna lewa ćwiartka
• d Czerwony oktant w prawym górnym rogu
• e Żółto-zielony dolny lewy kwartał
• f Zielona / niebieska dolna prawa ćwiartka
• g Wewnętrzny biały okrąg
• h Poziomy niebieski pasek

Ruby 2.3.1, 376 359 bajtów

Korzystanie z klejnotu 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])

Przykłady

50 x 50

250 x 250

500 x 500

1000 x 1000

Plik przyjmuje dwa parametry - pierwszy to wymiar, a drugi to nazwa pliku, w którym zapisuje się wynik.

Nie golfił

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

Początkowo zacząłem rozwiązywać to za pomocą oily_png / chunky_png, ale to prawdopodobnie skończyłoby się o wiele za skomplikowane w porównaniu z RMagick. Funkcja .ellipse firmy RMagick sprawiła, że ​​było to proste, a głównym zadaniem było dopracowanie kształtów / rozmiarów wszystkiego.

To jest moje pierwsze zgłoszenie do Code Golf (również pierwsza odpowiedź SE) i uważam się za trochę pośredniego w Ruby. Jeśli masz jakieś uwagi na temat ulepszeń / wskazówek, podziel się nimi!

Python 2, 378 373 bajtów

Naprawdę chciałem to zrobić za pomocą turtle. W tym celu musiałem odkurzyć swoją wiedzę na temat geometrii, obliczając kąty i długości, których nie podano w opisie wyzwania.

Edycja: usunięto up(), ponieważ powoduje to usunięcie małego fragmentu bieli między zielonym a niebieskim i sprawia, że ​​wewnętrzny okrąg wygląda lepiej. To jeszcze bardziej spowalnia program.

Edycja: zastąpione 9*nprzez, 2*naby przyspieszyć. Ustaliłem, że nadal będzie tworzyć gładki okrąg.

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)

Uwagi:

1. Talizmany używają Pythona 3, więc dane wejściowe muszą być rzutowane na int.
2. Drobiazgi stają się naprawdę wolne, njeśli je usuniesz speed(0), co dodałem tylko dla szybkości.
3. Powolność kodu wynika głównie z trzeciego parametru circlewzrostu O(n), ponieważ określa on, ile stron ma wielokąt wpisany do rysowania koła.

Wypróbuj online

Ungolfed: Wypróbuj online

Ciekawostka: Trinket jest anagramem Tkinterpakietu GUI Pythona i podstawą turtle.

PHP + GD, 529 449 bajtów

Pobiera parametr ciągu zapytania ni wyświetla wersję PNG logo o określonym rozmiarze.

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

Nie golfowany:

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

N = 200:

Java, 568 bajtów

Nie najsilniejszy język do gry w golfa, ale oto moja największa próba:

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"));}}

Stosowanie:

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

Wersja bez gry w golfa - podstawową ideą jest praca w układzie współrzędnych u, v ∈ [−0,5, 0,5] i obliczanie odległości i kąta każdego piksela od centrum obrazu:

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"));
    }

}

Moja implementacja oblicza i rysuje surowe piksele. Możliwe jest stworzenie alternatywnej implementacji korzystającej z procedur graficznych wysokiego poziomu, takich jak Graphics2D i Arc2D, do rysowania, szczególnie z wygładzaniem krawędzi .

Idź, 379 bajtów

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

Funkcja fpobiera pojedynczy intargument (współczynnik skali) i wyświetla odpowiednio skalowany obraz SVG.

Wypróbuj online w Ideone.

Przykładowe dane wyjściowe:

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

Wydaje się niewłaściwe uspokajanie naszych władców Google w jakimkolwiek języku programowania oprócz własnego.

CJam, 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*

Wypróbuj online

Wysyła obraz w formacie ASCII ppm.
W przypadku wersji ASCII-art, która jest ładniejsza w przeglądarce, wypróbuj ten kod . Pomaga również wizualizować algorytm.

Wyjaśnienie:

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 bajtów, niekonkurujący

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)

Niestety łączenie linii okrągłej nie jest pożądanym efektem, ale jest całkiem blisko.

FreeMarker + HTML / CSS, 46 + 468 = 514 bajtów

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}

Zakładając, że procesor FreeMarker jest wykonywany przy użyciu nzestawu zmiennych reprezentujących dane wejściowe.

Objaśnienie liczb magicznych:

Wszystko opiera się na opakowaniu 10x10 pikseli, a następnie skalowane według n/10.

• Odległość do prawej od niebieskiego prostokątnego pola [px]: 5 - sqrt (5 ^ 2 - 1 ^ 2) = 0,10102051443 ( Pitagoras )
• Obrót łuku niebieskiego [stopni]: 45 - arcSin (1/5) = 33,4630409671 ( sinusoida )

Ungolfed JSFiddle

343 oktetów Haskell

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

Wyjaśnienie

• „P3” == przenośna pixmapa w postaci zwykłego tekstu
• pokaż == generuj dziesiętne znaki ASCII obawiając się uszkodzenia UTF-8 dla „\ xFF \ xFF \ xFF”
• unlines == dziel dziesiętne na linie
• m = n-1 dla symetrii w n == długość [0..m]
• m²- (2x-m) ²- (2y-m) ²> 0 == (xm / 2) ² + (ym / 2) ² <(m / 2) ² == wewnątrz Zewnętrzne koło
• (10x-5m) ² + (10y-5m) ²- (3m) ²> 0 == (xm / 2) ² + (ym / 2) ²> (m3 / 10) ² == na zewnątrz Wewnętrzny okrąg
• mxy> 0 == x + y <m == inUpperLeft
• xy> 0 == x> y == inUpperRight
• 5 lat-2 m> 0 == y> m2 / 5 == poniżej GbarTop
• 3–5 lat> 0 == y <m3 / 5 == powyżej GbarBot
• 2x-m> 0 == x> m / 2 == inRightHalf
• [234,67,53] == czerwony
• [251,188,5] == żółty
• [52,168,83] == zielony
• [66,13,244] == niebieski
• [255,255,255] == biały

SAS - 590 536 521 bajtów

Wykorzystuje to funkcję Adnotacji GTL . Dane wejściowe są określone w makrozmiennej w pierwszym wierszu. Dla kilku dodatkowych bajtów możesz zdefiniować całość jako makro. Nadal zakrada się pod Javą i kilkoma odpowiedziami HTML, nawet jeśli musisz zdefiniować szablon wykresu zerowego, aby w ogóle móc wykreślić cokolwiek!

Zostawiłem przerwy w linii dla odrobiny czytelności, ale nie liczę ich do sumy, ponieważ działa bez nich.

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

Edycja: zeskrobano kilka kolejnych bajtów za pomocą zmiennych makr, ustawień domyślnych i wyboru operatorów.

Edycja 2: pozbyłem się do-endbloków dla if-then-elselogiki i jakoś nadal działa - nie do końca rozumiem jak. Odkryłem też euclidfunkcję!

SCSS - 415 bajtów

Pobiera dane wejściowe jako $N: 100px;i <div id="logo"></div>, nie jestem pewien, czy powinny one liczyć się w sumie ...

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

Demo na JSFiddle

Haskell z pakietem JuicyPixels , 306 bajtów

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

Przykład użycia:

main = writePng "google.png" $ f 1001

Można to prawdopodobnie poprawić. Chodzi o to, aby przekazać funkcję, generateImagektóra wybiera piksel (naprawdę kolor), który powinien przejść w pozycji x, y. W tym celu używamy lambda, która dodaje njako parametr i konwertuje je wszystkie na liczby zmiennoprzecinkowe w tym samym czasie. #Funkcja zasadzie sprawdza, czy jesteśmy w ringu, w barze, lub też nie. Jeśli to pierścień, przekazujemy pałeczkę %, jeśli pasek po prostu zwracamy niebieski, w przeciwnym razie biały. %sprawdza, w którym kwadrancie się znajdujemy, i zwraca odpowiedni kolor, jeśli nie jest niebieski. Niebieski jest szczególnym przypadkiem, ponieważ musimy upewnić się, że nie zawija się na czerwony, więc zwracamy niebieski tylko, jeśli yznajduje się poniżej „linii kreskowej”, w przeciwnym razie zwracamy biały. To jest ogólny przegląd.

Processing.py - 244 bajty + 1 bajt na liczbę cyfr w N

Zacznijmy od kodu. Można to wkleić w środowisku przetwarzania i uruchomić (zmieniając Ndla różnych rozmiarów).

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)

Mały cheat: okrąg, który wycina część z logo, jest rysowany w odcieniu 205 w skali szarości firmy Processing, który jest domyślnym kolorem tła. Eksportowanie tego do obrazu nie wyglądałoby tak samo. To oszczędza połączenie z background(255).

Wyjaśnienie

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

Przykłady

N = 400

N = 13 (minimalny rozmiar przetwarzania to 100 x 100)

Uwaga

Jeśli pozwolimy na ręczną edycję wielu wartości dla Njawnych wywołań do setupi drawnie są one potrzebne i jest to do 213 bajtów + 3 bajty na cyfrę w 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)