Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl N aufnimmt und ein N × N-Pixelbild des "G" -Logos von Google gemäß dieser * Konstruktion ausgibt :

Wenn N beispielsweise 400 ist, sollte ein 400 × 400-Pixel-Logo mit den richtigen Abmessungen und Farben ausgegeben werden:

Es sollte genau aussehen, unabhängig davon, wie groß oder klein N ist. zB hier ist N = 13:

Ihr Code muss keine Verbindung zum Internet herstellen. Das Skalieren von extern gehosteten SVG-Dateien ist beispielsweise nicht zulässig. (Das Skalieren einer in Ihrem Code codierten SVG-Datei ist jedoch in Ordnung.)

Anti-Aliasing kann verwendet werden oder nicht. Es liegt an dir.

Beachten Sie, dass der horizontale Balken des "G" nicht bis zum rechten Bildrand reicht. Der Kreis krümmt sich normalerweise am rechten Rand nach innen, bevor er abgeschnitten wird.

Der kürzeste Code in Bytes gewinnt.

^{* Der Aufbau des Logos wurde für diese Herausforderung vereinfacht. Die richtige Konstruktion ist hier und hier zu sehen .}

Mathematica, 229 226 225 224 221 206 169 Bytes

Danke @MartinEnder für 1 Byte, @ChipHurst für 37 Byte!

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

Was für eine lustige Herausforderung!

Erläuterung

...&~Array~4

Iteriere von 1 bis 4 ...

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

Konvertieren Sie die Farbhexcodes in RGBColorObjekte, damit sie auf die Google-Logo-Grafik angewendet werden können. Ändern Sie die Farbpalette in die <input>th Farbe.

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

Erstellen Sie ein gefülltes Rechteck (2D-Quader), dessen diagonale Ecken (0, -1) und (sqrt (24), 1) sind.

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

Generieren Sie vier gefüllte Viertel Annulus, zentriert am Ursprung, mit Innenradius 3 und Außenradius 5. Zeichnen Sie nicht an der Stelle vorbei, ArcCsc@5an der das blaue Segment endet.

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

Erstellen Sie eine Grafik mit der Größe N x N, von x = -5 bis x = 5 (entfernt die Polsterung).

Ausgänge

N = 10

N = 100

N = 200

N = 10000 (Bild anklicken für volle Auflösung)

C (Windows): 311 Byte

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

Nimmt "N" als Befehlszeilenargument und zeichnet direkt auf dem Bildschirm.

Nicht golfen:

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

Verwenden von Martin Rosenaus Transformation auf der [-1,1] ^ 2-Ebene und geringes Golfen wie Entfernen 0.oder Klammern

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)

Erläuterung:

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
 )

Ausgabe als binäres PPM, Verwendung:

python golf_google.py > google.ppm

Beispiele

• 13

• 50

• 100

• 1337

vorherige 244-Byte-Lösung

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 Version vor if / else Beseitigung:

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 Byte

384 383 371 367 359 327 316 308 304 Byte JavaScript + 24 13 Byte für das Zeichenflächenelement

(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 Byte durch Zeichnen gegen den Uhrzeigersinn gespeichert.
Dank Conor O'Brien wurden 11 Bytes im HTML-Code gespeichert.
12 Bytes im withBlock gespeichert dank Prinzhorn.
4 Bytes gespart bei besserer Nutzung von z=q-y/2.
8 Bytes gespart mit parentNodeund backgrounddank Alexis Tyler.
32 Bytes gespart durch eine genauere Zeichnung des blauen Bogens / Balkens, so dass ich keinen Teil mehr löschen muss.
Dank Tejas Kale werden 11 Bytes gespart, indem Canvas CSS anstelle des übergeordneten Knotens festgelegt wird.
8 Bytes gespeichert wurden withund mapmit einer einzigen Anweisung, `2d` statt ('2d'), n/5statt .2*nund den Hintergrund in der Initialisierung prompt(...).
4 Bytes werden gespeichert und Math.PI/4durch ersetzt.7854 Das scheint genug Präzision dank RobAu.

Erläuterung:

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

Die Canvas-Dimensionen werden mit Benutzereingaben initialisiert und der Hintergrund wird auf Weiß gesetzt. qwird initialisiert.

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

Für jede Farbe wird der Kreisteil gezeichnet, wobei der letzte (blaue) Teil angepasst wird. Der Balken wird für jede Farbe an derselben Stelle mit denselben Abmessungen gezeichnet, sodass nur die letzte (blaue) Farbe sichtbar ist.

BBC BASIC, 177 Bytes

Laden Sie den Interpreter unter http://www.bbcbasic.co.uk/bbcwin/download.html herunter

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 verwendet 2 Einheiten = 1 Pixel, daher zeichnen wir ein G von Radiuseinheiten n(= n / 2 Pixel) in der Mitte n,n.

Die Idee ist, eine Reihe von radialen Linien zu zeichnen und die Farbe entsprechend zu ändern. Es wurde festgestellt, dass es aufgrund der Kürzung der Zahlen bei der Konvertierung in Pixel kleine Lücken zwischen den Linien gibt, sodass stattdessen tatsächlich dünne Dreiecke gezeichnet werden.

Sobald der Zeilenumbruch abgeschlossen ist, befindet sich der Cursor in der oberen rechten Ecke des blauen Bereichs. Eine einzige Koordinate für die diagonal gegenüberliegende Ecke dient zum Zeichnen eines Rechtecks, um die Form zu vervollständigen.

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 Bytes

Um 624 Bytes zu erhalten, entfernen Sie das letzte ;, das für das folgende Snippet benötigt wird, da es den HTML-Code importiert. Außerdem scheint Firefox nicht zu unterstützen image-rendering: pixelatedund benötigt -moz-crisp-edgesstattdessen (danke @alldayremix !) Eine Firefox-Lösung +7, aber dies funktioniert in Chrome wie erwartet.

Verwendet JavaScript zum Anfordern Nund einen <style>Block zum Positionieren / Färben der Elemente. Verwendet grundlegende HTML-Elemente, anstatt Stile auf eine Zeichenfläche anzuwenden (was anscheinend ein viel kürzerer Ansatz war!). Dies ist ein überarbeiteter Ansatz, bei dem data:anstelle nur farbiger Elemente ein URI-Hintergrundbild verwendet wird. Ich habe den vorherigen Ansatz beibehalten, falls dieser neue mit weniger Browsern funktioniert.

Ich dachte, dass dies viel kleiner sein würde, als es am Ende war, aber es war trotzdem eine interessante Übung!

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

Vorherige Version:

<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 mit Imagemagick (aber wirklich Postscript), 268 255 249 Bytes

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

Verdoppelte die zu entfernende Skalierung setlinewidth, ersetzte einen Skalierungsfaktor mit dupund führte ein Leerzeichen in die AVariable ein (kann nicht mit, Cweil $C45als "die Variable C45" analysiert wird ).

Vielen Dank an joojaa, der diese Änderungen vorgeschlagen hat!

Alte Skala, 255 Bytes

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

Nimmt N als einziges Argument und gibt es an o.png aus.

Ungolfed Postscript für 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 Bytes

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

Perl 5, 486 477 476 450 (+7 für -MImagerFlag) = 457 Bytes

Ich habe dank Dada ein paar Bytes gespart, indem ich funktionale newAufrufe verwendet und Parens entfernt habe, und indem ich popanstelle des $ARGV[0]letzten Semikolons verwendet habe. Ich habe etwas mehr gespart, indem ich das, $n=popwo es zuerst verwendet wurde, und indem ich die Perl 4-Namespace-Notation mit 'anstelle von verwendet habe ::.

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

Hierfür ist das Modul Imager erforderlich , das über CPAN installiert werden muss. Nimmt eine Ganzzahl als Befehlszeilenargument. Das Bild ist nicht geglättet, daher ist es etwas hässlich.

Kopieren Sie den folgenden Code in eine Datei g.pl. Wir brauchen zusätzliche +7 Bytes für das -MImagerFlag, aber es spart ein paar Bytes, weil wir das nicht brauchen use Imager;.

$ perl -MImager g.pl 200

Hier sind verschiedene Größen:

N = 10

N = 100

N = 200

Der völlig ungolfed Code ist unkompliziert.

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

Dieser Beitrag hatte zuvor den Code wie das Ausgabebild geformt. Da das gegen die Regeln für Code Golf verstößt, musste ich es entfernen. Sehen Sie sich den Revisionsverlauf an, wenn Sie einen Blick darauf werfen möchten. Ich habe Acme :: EyeDrops verwendet , um dies mit einer Form zu erstellen, die ich aus einem Bild erstellt habe, das mit dem Programm selbst erstellt wurde, das ich in ASCII-Grafik konvertiert habe. Der Code, den ich verschleiert habe, war bereits golfen, was man sehen kann, wenn man den ersten evaldurch einen ersetzt print.

PHP + SVG, 300 Bytes

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

Der Skalierungsteil ist width=<?=$_GET[w]?>

Ausgabe für Wert 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 Bytes

... weil ich mir vorstelle, dass Logos mit Logo erstellt werden sollen . Dies ist als eine Funktion implementiert. Ich habe es mit dem Online-Logo-Interpreter von Calormen.com entwickelt

Ich habe ursprünglich versucht, jedes Segment zu zeichnen und es mit Farbe zu füllen, aber es stellte sich heraus, dass es größer war als erwartet. Es gab viel verschwendetes Zurückverfolgen von Bewegungen und so weiter. Stattdessen entschied ich mich für einen Polardiagramm-Sweep und passte die Farbe an die Überschrift an. Der schwierigere Teil der Mathematik bestand darin, die Geometrie für die Kurve am oberen Rand des G-Rechtecks ​​zu erstellen. Sie könnten einige Dezimalstellen zuschneiden und haben eine geringere Genauigkeit, aber ich wollte, dass dies auf ungefähr 3 Stellen genau ist, um typische Bildschirmgrößen zu berücksichtigen.

Golf gespielt

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

Stichprobe

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

JavaScript (ES7), 285 258 254 252 251 Byte

Fordert zur Eingabe der Breite des Logos auf (bis zu 999) und zeichnet es pixelweise auf eine Leinwand.

Bearbeiten : Die ursprüngliche Version konvertierte kartesische Koordinaten (x,y)in Polarkoordinaten (r,a), aber wir brauchen den Winkel nicht wirklich. Es ist einfacher (und deutlich kürzer), nur Vergleiche anzustellen xund yherauszufinden, in welchem ​​Quartal wir uns befinden.

Edit : Dank ETHproductions 1 Byte gespeichert.

JS, 251 224 220 218 217 Bytes

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 Bytes

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

ES6-Version: 258 231 227 225 224 + 34 = 258 Byte

Empfohlene maximale Breite für das Snippet: 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 Bytes

276 Byte für Methode + 21 Byte für System.Drawing-Import.

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

Basierend auf Martin Rosenaus Algorithmus. Vielen Dank, dass Sie sich die Mühe gemacht haben, ein Bild zu konstruieren!

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 Byte

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

Verwendet eher lineare Verläufe als Transformationen. Bearbeiten: 140 Bytes dank @darrylyeo gespeichert. Durch Verwendung eines zusätzlichen Elements anstelle eines Farbverlaufs wurden 20 Byte gespart. 24 Bytes gespart dank @DBS. 16 Bytes dank @Hedi eingespart. Von hinten nach vorne sind die verschiedenen Schichten:

• a Der blaue Kreis
• b Ein weißes Rechteck, um den Teil über dem Balken zu verdecken
• c Das rot / gelbe obere linke Viertel
• d Der rote Oktant oben rechts
• e Das gelb / grüne untere linke Viertel
• f Das grün / blaue untere rechte Viertel
• g Der innere weiße Kreis
• h Die horizontale blaue Leiste

Ruby 2.3.1, 376 359 Bytes

Mit dem RMagick Gem.

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

Beispiele

50x50

250 x 250

500 x 500

1000x1000

Die Datei akzeptiert zwei Parameter - der erste ist die Dimension und der zweite ist der Dateiname, unter dem die Ausgabe gespeichert werden soll.

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

Ich hatte anfänglich damit begonnen, dies mit oily_png / chunky_png zu lösen, aber das würde im Vergleich zu RMagick wahrscheinlich viel zu kompliziert werden. RMagicks .ellipse-Funktion machte dies zu einem Kinderspiel und die Hauptarbeit bestand darin, die Formen / Größen von allem zu optimieren.

Dies ist meine erste Code Golf Einreichung (erste SE Antwort auch) und ich betrachte mich nur als etwas mittelschwer mit Ruby. Wenn Sie Anregungen zu Verbesserungen / Tipps haben, teilen Sie diese bitte mit!

Python 2, 378 373 Bytes

Ich wollte das wirklich mit machen turtle. Dafür musste ich meine Geometriekenntnisse abstauben und Winkel und Längen berechnen, die nicht in der Herausforderungsbeschreibung angegeben sind.

Bearbeiten: entfernt up(), da dadurch der kleine weiße Streifen zwischen Grün und Blau entfernt wird und der innere Kreis besser aussieht. Dies verlangsamt das Programm noch mehr.

Bearbeiten: ersetzt 9*ndurch 2*num schneller zu machen. Ich entschied, dass es immer noch einen glatten Kreis schaffen würde.

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)

Anmerkungen:

1. Die Schmuckstücke verwenden Python 3, daher muss die Eingabe in int umgewandelt werden.
2. Die Schmuckstücke gehen sehr langsam für große, nwenn Sie entfernen speed(0), die ich nur für die Geschwindigkeit hinzugefügt habe.
3. Die Langsamkeit des Codes ist hauptsächlich auf den dritten Parameter des circleWachstums zurückzuführen O(n), da dieser bestimmt, wie viele Seiten das beschriftete Polygon zum Zeichnen des Kreises hat.

Probieren Sie es online aus

Ungolfed: Probieren Sie es online

Unterhaltsame Tatsache: Trinket ist ein Anagramm von TkinterPythons GUI-Paket und die Grundlage für turtle.

PHP + GD, 529 449 Bytes

Dabei wird ein Abfragezeichenfolgenparameter verwendet nund eine PNG-Version des Logos mit der angegebenen Größe ausgegeben.

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

N = 200:

Java, 568 Bytes

Nicht die stärkste Sprache zum Golfen, aber hier ist mein ernsthafter Versuch:

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

Verwendungszweck:

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

Ungolf-Version - Die Grundidee besteht darin, im Koordinatensystem u, v ∈ [−0,5, 0,5] zu arbeiten und den Abstand und den Winkel jedes Pixels von der Bildmitte zu berechnen:

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

}

Meine Implementierung berechnet und zeichnet rohe Pixel. Es ist möglich, eine alternative Implementierung zu erstellen, die Grafikroutinen auf hoher Ebene wie Graphics2D und Arc2D zum Zeichnen verwendet, insbesondere mit Anti-Aliasing.

Los, 379 Bytes

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

Die Funktion verwendet fein einzelnes intArgument (den Skalierungsfaktor) und gibt ein entsprechend skaliertes SVG-Bild aus.

Probieren Sie es online bei Ideone.

Beispielausgabe:

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

Es erscheint falsch, unsere Google-Overlords in einer anderen Programmiersprache als ihrer eigenen zu beschwichtigen.

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*

Probieren Sie es online aus

Gibt das Bild im ASCII-ppm-Format aus.
Versuchen Sie diesen Code für eine ASCII-Art-Version, die im Browser besser zu sehen ist . Es hilft auch, den Algorithmus zu visualisieren.

Erläuterung:

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 Byte, nicht konkurrierend

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)

Leider ist der Round Line Join nicht ganz der gewünschte Effekt, aber er ist ziemlich nahe.

FreeMarker + HTML / CSS, 46 + 468 = 514 Byte

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}

Angenommen, der FreeMarker-Prozessor wird mit einer Variablengruppe ausgeführt n, die die Eingabe darstellt.

Erklärung der magischen Zahlen:

Alles basiert auf einem 10x10px-Wrapper, der dann durch skaliert wird n/10.

• Abstand rechts vom blauen horizontalen Feld [px]: 5 - sqrt (5 ^ 2 - 1 ^ 2) = 0.10102051443 ( Pythagoras )
• Drehung des blauen Bogens [Grad]: 45 - arcSin (1/5) = 33.4630409671 ( Sinus )

Ungolfed JSFiddle

343 Oktette von 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"
};

Erläuterung

• "P3" == Portable Pixmap im Klartext
• show == erzeugt ASCII-Dezimalzahlen, die eine UTF-8-Beschädigung für "\ xFF \ xFF \ xFF" befürchten
• Unlines == trennen Dezimalstellen in Zeilen
• m = n-1 für Symmetrie in n == Länge [0..m]
• m²- (2x-m )²- (2y-m )²> 0 == (xm / 2 )² + (ym / 2 )² <(m / 2 )² == insideOuterCircle
• (10x-5m )² + (10y-5m )²- (3m )²> 0 == (xm / 2 )² + (ym / 2 )²> (m³ / 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 == aboveGbarBot
• 2x-m> 0 == x> m / 2 == inRightHalf
• [234,67,53] == rot
• [251,188,5] == gelb
• [52,168,83] == grün
• [66,13,244] == blau
• [255,255,255] == Weiß

SAS - 590 536 521 Byte

Dies verwendet die GTL Annotation-Funktion . Die Eingabe wird in einer Makrovariablen in der ersten Zeile angegeben. Für ein paar zusätzliche Bytes können Sie das Ganze als Makro definieren. Es schleicht sich immer noch unter Java und einige der HTML-Antworten ein, obwohl Sie eine Null-Diagrammvorlage definieren müssen, um überhaupt etwas zeichnen zu können!

Ich habe den Zeilenumbruch für ein Minimum an Lesbarkeit verlassen, aber ich zähle diese nicht zur Gesamtsumme, da es ohne sie funktioniert.

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

Bearbeiten: Ein paar Bytes mehr durch Verwendung von Makro-Variablen, Standardeinstellungen und Auswahl von Operatoren entfernt.

Edit 2: habe die do-endBlöcke für die if-then-elseLogik entfernt und es funktioniert irgendwie immer noch - ich verstehe nicht ganz wie. Auch ich habe die euclidFunktion entdeckt!

SCSS - 415 Bytes

Nimmt die Eingabe als $N: 100px;und <div id="logo"></div>, nicht sicher, ob diese in der Summe zählen sollten, obwohl ...

$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 auf JSFiddle

Haskell mit JuicyPixels- Paket, 306 Byte

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

Anwendungsbeispiel:

main = writePng "google.png" $ f 1001

Dies könnte wahrscheinlich verbessert werden. Die Idee ist, eine Funktion zu übergeben generateImage, die das Pixel (Farbe wirklich) auswählt, das sich an Position x, y befinden soll. Dazu verwenden wir ein Lambda, das nals Parameter addiert und alle gleichzeitig in Floats konvertiert. Die #Funktion prüft grundsätzlich, ob wir im Ring, in der Bar oder in keiner der beiden sind. Wenn es der Ring ist, an den wir den Staffelstab weitergeben %, wenn der Balken gerade blau ist, ansonsten weiß. %prüft, in welchem ​​Quadranten wir uns befinden und gibt die entsprechende Farbe zurück, wenn sie nicht blau ist. Blau ist ein Sonderfall, da wir sicherstellen müssen, dass es sich nicht um das Rot dreht. Deshalb geben wir Blau nur dann zurück, wenn yes sich unter der "Balkenlinie" befindet, andernfalls geben wir Weiß zurück. Das ist die allgemeine Übersicht.

Processing.py - 244 Bytes + 1 Byte für die Anzahl der Stellen in N

Beginnen wir mit dem Code. Dies kann in die Verarbeitungsumgebung eingefügt und ausgeführt werden (Änderung Nfür verschiedene Größen).

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)

Kleiner Cheat: Der Kreis, der einen Teil des Logos ausschneidet, wird in Processing's Graustufen-Farbton 205 gezeichnet, der die Standard-Hintergrundfarbe ist. Das Exportieren in ein Bild würde nicht gleich aussehen. Dadurch wird ein Anruf bei gespeichert background(255).

Erläuterung

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

Beispiele

N = 400

N = 13 (Mindestgröße der Verarbeitung ist 100x100)

Hinweis

Wenn wir es uns erlauben, mehrere Werte für Ndie expliziten Aufrufe manuell zu bearbeiten , setupund dies drawnicht erforderlich ist, sind es nur 213 Bytes + 3 Bytes pro Ziffer 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)