양의 정수 N을 취하고 다음과 같이 *의 구성에 따라 Google의 "G"로고 의 N × N 픽셀 이미지를 출력하는 프로그램 또는 함수를 작성하십시오 .

예를 들어, N이 400이면 올바른 크기와 색상으로 400 × 400 픽셀 로고가 출력되어야합니다.

N이 얼마나 크든 작든 관계없이 정확해야합니다. 예를 들어 여기 N = 13입니다

인터넷에 연결하지 않아도됩니다. 예를 들어 외부 호스팅 svg의 크기 조정은 허용되지 않습니다. (코드로 인코딩 된 svg를 확장하는 것이 좋습니다.)

앤티 앨리어싱 사용 여부 그것은 당신에게 달려 있습니다.

"G"의 가로 막대는 이미지의 오른쪽 가장자리까지 뻗어 있지 않습니다. 원은 잘 리기 전에 오른쪽 가장자리에서 안쪽으로 보통 구부러집니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

^{*이 과제를 위해 로고 구성이 단순화되었습니다. 올바른 구조는 여기 와 여기에서 볼 수 있습니다 .}

매쓰, 229 226 225 224 221 206 169 바이트

1 바이트의 경우 @MartinEnder, 37 바이트의 경우 @ChipHurst에게 감사 합니다!

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

정말 재미있는 도전입니다!

설명

...&~Array~4

1에서 4까지 반복 ...

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

색상 16 진수 코드를 RGBColor객체로 변환하여 Google 로고 그래픽에 적용 할 수 있습니다. 색상 표를 색상으로 변경하십시오 <input>.

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

대각선 모서리가 (0, -1) 및 (sqrt (24), 1) 인 채워진 사각형 (2D 직육면체)을 만듭니다.

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

Annulus안쪽 반지름이 3이고 바깥 반지름이 5 인 원점을 중심으로 채워진 4 분의 4를 생성 ArcCsc@5합니다.

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

크기가 N x N 인 그래픽을 x = -5에서 x = 5 (패딩 제거)로 만듭니다.

출력

N = 10

N = 100

N = 200

N = 10000 (전체 해상도를 보려면 이미지를 클릭하십시오)

C (Windows), 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, 244220 바이트

[-1,1] ^ 2 평면에서 Martin Rosenau의 변형을 사용하고 제거 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
 )

이진 PPM으로 출력, 사용법 :

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

if / else를 제거하기 전에 ungolfed 베타 버전 :

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

자바 스크립트 (ES6), 408 ... 321317 바이트

384 383 371 367 359 327316308304 바이트 JavaScript + 24 13 바이트 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>

시계 반대 방향으로 그려서 1 바이트를 절약했습니다.
Conor O'Brien 덕분에 HTML에 11 바이트가 절약되었습니다. Prinzhorn 덕분에 블록을
사용하여 12 바이트가 절약 with되었습니다.
를 더 잘 사용하여 4 바이트가 절약되었습니다 z=q-y/2. Alexis Tyler를
사용 parentNode하고 background덕분에 8 바이트가 절약되었습니다 .
더 정확한 파란색 호 / 막대기를 사용하여 32 바이트를 절약하므로 더 이상 일부를 지울 필요가 없습니다.
Tejas Kale 덕분에 parentNode 대신 canvas css를 설정하여 11 바이트를 절약했습니다.
8 바이트를 사용하여 저장 with하고 map대신 2d` 하나의 문 '으로 ('2d'), n/5대신 .2*n과의 배경을 초기화 prompt(...).
4 바이트 대체 저장 Math.PI/4하여.7854 RobAu 덕분에 충분한 정밀도로 보입니다.

설명:

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

캔버스 치수는 사용자 입력으로 초기화되고 배경은 흰색으로 설정됩니다. 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)))

각 색상마다 마지막 부분 (파란색)을 조정하여 원 부분을 그립니다. 같은 크기의 같은 장소에 각 색상에 대해 막대가 그려 지므로 마지막 (파란색) 색상 만 표시됩니다.

BBC 기본, 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

BBC BASIC은 2 단위 = 1 픽셀을 사용하므로 n중심 에 반경 단위 G (= n / 2 픽셀)를 플로팅합니다 n,n.

아이디어는 색상을 적절하게 변경하여 일련의 방사형 선을 그리는 것입니다. 픽셀로 변환 할 때 숫자가 잘려서 선 사이에 작은 간격이 있었으므로 얇은 삼각형이 대신 실제로 그려집니다.

선 스윕이 완료되면 커서가 파란색 영역의 오른쪽 상단에 있습니다. 대각선으로 마주 보는 코너의 단일 좌표는 모양을 완성하기 위해 사각형을 그립니다.

언 골프

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을 가져 오는 방식으로 인해 아래 스 니펫에 필요합니다. 또한 Firefox는 지원하지 않으며 대신 @alldayremix 덕분 에 Firefox 솔루션을 +7로 만드는 것이 image-rendering: pixelated필요 하지만 Chrome에서 예상대로 작동합니다.-moz-crisp-edges

JavaScript를 사용하여 요청 N하고 <style>요소를 배치 / 색칠하기 위한 블록을 사용합니다. 캔버스에 스타일을 적용하는 대신 기본 HTML 요소를 사용합니다 (매우 짧은 접근 방식이었습니다). 이것은 data:단지 컬러 요소 대신 URI 배경 이미지를 사용하는 개선 된 접근 방식 입니다. 이 새로운 방법이 더 적은 브라우저에서 작동하는 경우를 대비하여 이전 방법을 아래에 유지했습니다.

나는 이것이 끝나는 것보다 훨씬 작을 것이라고 생각했지만 그럼에도 불구하고 재미있는 운동이었습니다!

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

이전 버전:

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

있는 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되기 때문에 사용할 수 없습니다 ).$C45C45

이러한 수정 사항을 제안 해 주신 joojaa에게 감사드립니다!

이전 스케일, 255 바이트

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

취하고 N은 o.png하는 펜텐 인자를 출력한다.

오래된 스케일을위한 Ungolfed Postscript

%!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, 189184 바이트

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

언 골프

[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 (+7 -MImager플래그) = 457 바이트

Dada 덕분에 함수 new호출 을 사용 하고 parens를 제거 하고 최종 세미콜론 pop대신 사용하여 몇 바이트를 절약했습니다 $ARGV[0]. $n=pop처음 사용 하는 위치에을 '대신 하여 Perl 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

다양한 크기는 다음과 같습니다.

N = 10

N = 100

N = 200

완전히 ungolfed 코드는 간단합니다.

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

이 게시물에는 이전에 출력 이미지와 같은 코드가있었습니다. 그것이 코드 골프 규칙에 위배되므로 그것을 제거해야했습니다. 살펴 보려면 개정 내역을 참조하십시오 . 내가 사용 애 크미 :: 안약을 나는 예술을 ASCII로 변환 프로그램 자체로 만든 이미지에서 만든 모양으로, 그것을 만들 수 있습니다. 내가 난독 화 코드는 이미 첫째를 대체하여 볼 수있는, 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의 온라인 로고 통역사를 사용하여 개발했습니다.

나는 원래 각 세그먼트를 그리고 칠하기 위해 시도했지만 예상보다 더 큰 것으로 판명되었습니다. 역 추적 등 많은 낭비가있었습니다. 대신 제목을 기준으로 색상을 조정하여 극좌표 그래프 스윕을하기로 결정했습니다. 수학의 어려운 부분은 G의 사각형의 상단에있는 곡선의 기하 도형을 수행하는 것이 었습니다. 소수를자를 수 있고 정확도가 떨어질 수 있지만 일반적인 화면 크기를 수용 할 수 있도록 약 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

언 골프

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

자바 스크립트 (ES7), 285 258 254 252 251 바이트

로고 너비를 입력하라는 메시지 (최대 999 개)를 캔버스 당 픽셀 당 픽셀로 그립니다.

편집 : 초기 버전은 직교 좌표 (x,y)를 극좌표 로 변환 (r,a)했지만 실제로 각도가 필요하지 않습니다. 비교를 x하고 y우리가 어느 분기에 있는지 알아내는 것이 더 간단합니다 (그리고 훨씬 더 짧습니다) .

편집 : ETH 프로덕션 덕분에 1 바이트가 절약되었습니다.

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

C #, 276 + 21 = 297 바이트

메서드의 경우 276 바이트, System.Drawing 가져 오기의 경우 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;};

Martin Rosenau의 알고리즘을 기반으로합니다. 이미지를 구성하는 방법을 생각해내는 데 어려움을 겪어 주셔서 감사합니다!

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>

변형 대신 선형 그라디언트를 사용합니다. 편집 : @darrylyeo 덕분에 140 바이트를 절약했습니다. 그라데이션 대신 추가 요소를 사용하여 20 바이트를 절약했습니다. @DBS 덕분에 24 바이트를 절약했습니다. @Hedi 덕분에 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

파일은 두 가지 매개 변수를 취합니다. 첫 번째는 차원이고 두 번째는 출력을 저장할 파일 이름입니다.

언 골프

require "RMagick"

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

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

c = Magick::Draw.new

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

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

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

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

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

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

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

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

  # draws to the created canvas
  .draw(e)

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

나는 처음에 oily_png / chunky_png를 사용하여 이것을 해결하기 시작했지만 RMagick에 비해 너무 복잡해질 것입니다. RMagick의 .ellipse 함수는 이것을 산들 바람으로 만들었으며 주요 작업은 모든 모양 / 크기 조정에 관한 것입니다.

이것은 나의 첫 번째 코드 골프 제출 (첫 번째 SE 답변이기도 함)이며 Ruby의 중간 단계라고 생각합니다. 개선 / 팁에 대한 의견이 있으시면 언제든지 공유하십시오!

파이썬 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. 장신구는 Python 3을 사용하므로 입력을 int로 캐스트해야합니다.
2. 장신구 를 제거하면 악세사리가 크게 느려집니다 . 속도에만 추가했습니다.nspeed(0)
3. 코드의 속도 저하는 대부분 원의 그림에 포함 된 다각형의면이 몇 개인 지 결정하기 때문에 circle성장 의 세 번째 매개 변수 때문입니다 O(n).

온라인으로 사용해보십시오

Ungolfed : 온라인으로 사용해보십시오

재미있는 사실 : Trinket 은 Tkinter파이썬의 GUI 패키지와의 기초입니다 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);

언 골프 드 :

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

자바, 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

Ungolfed 버전-기본 아이디어는 좌표계 u, v ∈ [−0.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"));
    }

}

내 구현은 원시 픽셀을 계산하고 그립니다. 특히 앤티 앨리어싱을 사용하여 Graphics2D 및 Arc2D 와 같은 고급 그래픽 루틴을 사용 하여 드로잉을 수행 하는 대체 구현을 작성할 수 있습니다 .

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 이미지를 출력합니다.

Ideone에서 온라인으로 사용해보십시오 .

출력 예 :

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

Google 대 군주를 자신의 언어를 제외한 모든 프로그래밍 언어로 달래는 것은 잘못된 것 같습니다.

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*

온라인으로 사용해보십시오

이미지를 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

자바 스크립트 (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-sqrt (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 10 진수를 생성합니다.
• unlines == 소수점을 줄로 분리
• n == 길이 [0..m]의 대칭에 대한 m = n-1
• m²- (2x-m) ²- (2y-m) ²> 0 == (xm / 2) ² + (ym / 2) ² <(m / 2) ² == insideOuterCircle
• (10x-5m) ² + (10y-5m) ²- (3m) ²> 0 == (xm / 2) ² + (ym / 2) ²> (m3 / 10) ² == outsideInnerCircle
• mxy> 0 == x + y <m == in 왼쪽
• xy> 0 == x> y == inUpperRight
• 5y-2m> 0 == y> m2 / 5 == 이하
• 3y-5y> 0 == y <m3 / 5 == 이상
• 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 Annotation 기능을 사용합니다 . 입력은 첫 번째 행의 매크로 변수에 지정됩니다. 약간의 추가 바이트의 경우 전체를 매크로로 정의 할 수 있습니다. 아무것도 그래프로 만들 수 있도록 null 그래프 템플릿을 정의해야하더라도 여전히 Java와 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 데모

하스켈 과 JuicyPixels의 패키지, 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-N의 자릿수에 대한 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)

작은 치트 : 로고에서 일부 를 잘라낸 원이 기본 배경색 인 Processing의 회색조 음영 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)