Apaisez vos supérieurs Google: dessinez le logo «G»

136

Ecrivez un programme ou une fonction qui prend un entier positif N et génère une image N × N pixels du logo "G" de Google selon cette * construction:

Construction du logo "G"

Par exemple, si N est 400, vous devez générer un logo de 400 × 400 pixels, avec les dimensions et les couleurs correctes:

"G" exemple 400x400 logo

Il devrait sembler précis indépendamment de la taille ou de la taille du N. par exemple, voici N = 13:"G" logo exemple 13x13

Votre code ne devrait pas avoir besoin de se connecter à Internet. Par exemple, la mise à l'échelle d'un svg hébergé en externe n'est pas autorisée. (Mettre à l'échelle un svg encodé dans votre code conviendrait cependant.)

L'anti-aliasing peut être utilisé ou non. C'est à vous.

Notez que la barre horizontale du "G" ne s'étend pas jusqu'au bord droit de l'image. Le cercle se courbe normalement vers l'intérieur sur le bord droit avant d'être coupé.

Le code le plus court en octets gagne.


* La construction du logo a été simplifiée pour ce défi. La construction correcte peut être vue ici et ici .

Les passe-temps de Calvin
la source
1
Y a-t-il un minimum de N? Une image 1x1 produirait probablement une sortie non reconnaissable, quelle que soit la qualité de la solution.
jpmc26
@ jpmc26 N est un entier positif, donc minimum 1. Bien sûr, une image 1x1 ne peut pas être identifiée, mais le sens du mot "Cela devrait sembler précis", par exemple, une image noire n'aurait pas de sens, même à cette échelle.
Hobbies de Calvin
4
Quelle est la sortie attendue pour une image 1x1, alors? Un seul pixel de l'une des couleurs de l'image? Une image blanche? Qu'en est-il de 2x2? Il y a toujours plus de couleurs dans l'image que de pixels pour cette taille. Si une image est inacceptable à ces échelles, le défi doit définir ce qui est acceptable et ce qui ne l'est pas, car vous ne pouvez pas produire une image proche de l'apparence correcte, n'est-ce pas? (Si c'était mon défi, je les exclurais pour que cela reste simple, mais votre décision. Vous devrez également vérifier que vous n'excluez pas les réponses existantes avec les nouvelles spécifications, je pense.)
jpmc26
@ jpmc26 Non. Les gens peuvent utiliser le bon sens pour dire si une image 1x1 ou une autre petite image a l'air exacte.
Les passe-temps de Calvin
Sommes-nous autorisés à télécharger un fichier pré-créé .svget à le coder dans notre solution, ou devons-nous le créer à l’origine?
juniorRubyist

Réponses:

55

Mathematica, 229 226 225 224 221 206 169 octets

Merci @MartinEnder pour 1 octet, @ChipHurst pour 37 octets!

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

Quel défi amusant!

Explication

...&~Array~4

Itérer de 1 à 4 ...

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

Convertissez les codes hexadécimaux de couleur en RGBColorobjets afin qu'ils puissent être appliqués au logo de Google. Changer la palette de couleurs à la <input>couleur th.

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

Créez un rectangle plein (cuboïde 2D), dont les angles diagonaux sont (0, -1) et (sqrt (24), 1).

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

Générez quatre quarts remplis Annulus, centrés à l'origine, de rayon intérieur 3 et de rayon extérieur 5. Ne tracez pas au-delà ArcCsc@5(là où se termine le segment bleu).

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

Créez un graphique de taille N x N, de x = -5 à x = 5 (supprime le remplissage).

Les sorties

N = 10

entrez la description de l'image ici

N = 100

entrez la description de l'image ici

N = 200

entrez la description de l'image ici

N = 10000 (cliquez sur l'image pour la pleine résolution)

entrez la description de l'image ici

JungHwan Min
la source
44

C (Windows), 311 octets

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

Prend "N" comme argument de ligne de commande et dessine directement à l'écran.

Non-golfé:

#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! */
}
Martin Rosenau
la source
Vous pouvez garder 0xF48542et 0xFFFFFFen nombres entiers.
Yytsi
Quel compilateur / éditeur de liens avez-vous utilisé? Ne fonctionne pas avec mingw
vsz
@vsz Sans doute, le compilateur de Visual Studio.
Kroltan
@ vsz je peux le compiler avec gcc g.c -lgdi32mingw.
Jingyu9575
2
-1>>8peut aussi travailler
Mark K Cowan
33

Python 2, 244 220 octets

en utilisant la transformation de Martin Rosenau sur le plan [-1,1] ^ 2 et le jeu mineur comme l’enlèvement 0.ou les supports

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)

Explication:

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
 )

Sortie en PPM binaire, utilisation:

python golf_google.py > google.ppm

Exemples

  • 13

13

  • 50

50

  • 100

100

  • 1337

1337

solution précédente de 244 octets

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

Version beta non-gérée avant élimination si / sinon:

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
Karl Napf
la source
Hmm, je ne sais pas si ça 1formarche.
Yytsi
1
@ TuukkaX C'est le cas.
mbomb007
Pouvez-vous inclure un exemple de sortie?
Cyoce
@TuukkaX merci pour la 1forsortie de l'échantillon @Cyoce ajoutée
Karl Napf
Toutes les décimales dans votre code qui sont sous la forme de 0.xpeuvent être réduites à .x:)
Yytsi
27

JavaScript (ES6), 408 ... 321 317 octets

384 383 371 367 359 327 316 308 304 octets de JavaScript + 24 13 octets pour l'élément 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 octet enregistré en tirant dans le sens contraire des aiguilles d'une montre.
11 octets enregistrés sur le code HTML grâce à Conor O'Brien.
12 octets enregistrés en utilisant withbloc grâce à Prinzhorn.
4 octets enregistrés avec une meilleure utilisation de z=q-y/2.
8 octets sauvés en utilisant parentNodeet backgroundgrâce à Alexis Tyler.
32 octets sauvegardés en utilisant un dessin plus précis de l'arc bleu / barre donc je n'ai plus besoin d'en effacer une partie.
11 octets enregistrés en définissant canvas css à la place de son parentNode grâce à Tejas Kale.
8 octets enregistrés en utilisant withet mapavec une seule instruction, `2d` au lieu de ('2d'), n/5au lieu de .2*net en initialisant l’arrière-plan du fichier prompt(...).
4 octets enregistrés en remplacement Math.PI/4de.7854 ce qui semble assez précis grâce à RobAu.


Explication:

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

Les dimensions de la zone de travail sont définies avec la saisie de l'utilisateur et l'arrière-plan est défini sur blanc. qest initialisé.

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

Pour chaque couleur, dessine la partie cercle, avec quelques ajustements pour la dernière (bleue). La barre est dessinée pour chaque couleur au même endroit avec les mêmes dimensions, de sorte que seule la dernière (bleue) est visible.

Hedi
la source
2
<canvas id=d></canvas>devrait fonctionner et <canvas id=d>pourrait fonctionner.
Conor O'Brien
1
Vous pouvez perdre encore 5 caractères en remplaçant backgroundColor par background.
Alexis Tyler
1
Utilisez également d.parentNode au lieu de d.parentElement
Alexis Tyler
1
Pourquoi définissez-vous les dimensions parentNode? Tout d.stylefonctionne aussi. Ce qui permet(f = d.style).width = f.height = n = prompt() + 'px';
Tejas Kale
1
Vous pouvez utiliser .785398au lieu de Math.PI/4supprimer 2 octets (ou plus si moins de précision est
acceptable
25

BBC BASIC, 177 octets

Téléchargez l'interprète à l' adresse 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 utilise 2 unités = 1 pixel, nous traçons donc un G d' nunités de rayon (= n / 2 pixels) au centre n,n.

L'idée est de tracer une série de lignes radiales, en changeant de couleur selon les besoins. Il a été constaté qu'il y avait de petits espaces entre les lignes en raison de la troncature des nombres lors de la conversion en pixels, de sorte que des triangles minces sont tracés à la place.

Une fois le balayage des lignes terminé, le curseur se trouve dans le coin supérieur droit de la zone bleue. Une seule coordonnée pour le coin opposé en diagonale est donnée pour dessiner un rectangle afin de compléter la forme.

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.
Level River St
la source
Bon travail! J'ai fait le mien dans Logo en utilisant une méthode similaire avant de voir votre réponse. Vous m'avez battu d'environ 81 octets.
GuitarPicker
21

HTML / JS, 680 624 octets

Pour obtenir 624 octets, supprimez le dernier ;, ceci est nécessaire pour l'extrait de code ci-dessous en raison de la façon dont il importe le code HTML. En outre, Firefox semble ne pas prendre en charge image-rendering: pixelatedet a -moz-crisp-edgesplutôt besoin (merci @alldayremix !), Ce qui rend une solution Firefox +7, mais cela fonctionne dans Chrome comme prévu.

Utilise JavaScript pour demander Net un <style>bloc pour positionner / colorer les éléments. Utilise des éléments HTML de base, plutôt que d'appliquer des styles à une toile (approche apparemment beaucoup plus courte!). Il s’agit d’une approche remaniée utilisant une data:image d’arrière-plan URI au lieu d’éléments colorés. J'ai conservé l'approche précédente ci-dessous au cas où cette nouvelle solution fonctionnerait avec moins de navigateurs.

Je pensais que cela allait être beaucoup plus petit que ce n’était au final, mais c’était quand même un exercice intéressant!

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

La version précédente:

<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

Dom Hastings
la source
1
Traitre! (je plaisante, gentil ;-))
Dada
Sur mon navigateur, l'ancienne version affichait de légers écarts entre les couleurs et la nouvelle version offrait une transition de dégradé entre les couleurs (Firefox 49.0.1 32 bits sur Win10 x64)
alldayremix
1
@alldayremix hmmm, on dirait que Firefox doit avoir image-rendering: -moz-crisp-edgesau lieu de pixelated. Ajoutera une note à cet effet. J'aime assez le style dégradé! :)
Dom Hastings
J'ai modifié l'en-tête pour lire "HTML / JS", puisque vous utilisez à la fois HTML et Javascript.
Mego
20

Bash with Imagemagick (mais vraiment PostScript), 268 255 249 octets

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

Double la mise à l'échelle à supprimer setlinewidth, remplace un facteur d'échelle par dupet fusionne un espace dans la Avariable (impossible avec Ccar $C45est analysé comme "la variable C45").

Merci à joojaa d’avoir suggéré ces modifications!

Ancienne échelle, 255 octets

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

Prend N comme argument unique et renvoie o.png.

Postscript Ungolfed 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
NighttimeDriver50000
la source
2
Vous pouvez raccourcir cette distance en supprimant un caractère de la ligne d'échelle, 61.2 dup scalevous pouvez également ajouter un espace en C C=' setrgbcolor 5 5 4 'et 4 espaces. Si vous aviez conçu cela à demi-échelle, vous pourriez omettre2 setlinewidth
joojaa
19

MATLAB, 189 184 octets

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

non-golfé

[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])
Rainer P.
la source
19

Perl 5, 486 477 476 450 (+7 pour le -MImagerdrapeau) = 457 octets

J'ai économisé quelques octets grâce à Dada en utilisant des newappels fonctionnels et en supprimant les parens, et en utilisant popau lieu de $ARGV[0]ainsi que le point-virgule final. J'ai économisé un peu plus en mettant cela $n=poplà où il a été utilisé pour la première fois, et en utilisant la notation Perl 4 avec la 'place de ::.

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

Il nécessite le module Imager , qui doit être installé à partir de CPAN. Prend un entier comme argument de ligne de commande. L'image n'est pas anti-aliasée, donc c'est un peu moche.

Copiez le code ci-dessous dans un fichier g.pl. Nous avons besoin de +7 octets supplémentaires pour le -MImagerdrapeau, mais cela économise quelques octets car nous n'en avons pas besoin use Imager;.

$ perl -MImager g.pl 200

Voici différentes tailles:

N = 10

10px

N = 100

100px

N = 200

200px

Le code totalement non-golfé est simple.

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

Ce message avait précédemment le code en forme d’image de sortie. Comme cela est contraire aux règles du code golf, je devais le supprimer. Voir l' historique de révision si vous voulez jeter un coup d'oeil. J'ai utilisé Acme :: EyeDrops pour créer cela, avec une forme que j'ai créée à partir d'une image créée avec le programme lui-même que j'ai converti en art ASCII. Le code que j'avais masqué était déjà joué au golf, ce qui peut être vu en remplaçant le premier evalpar un print.

simbabque
la source
Très agréable! Quelques détails sur le golf: popau lieu de $ARGV[0]. $h=($n=pop)/2au lieu de $n=pop;...;$h=$n/2. new Imager::Color"#$_"au lieu de Imager::Color->new("#$_"). (et vous avez oublié de laisser tomber le dernier point-virgule). Mais encore une fois, ce ne sont que quelques petits détails, votre code est vraiment génial! (Je n'aurais pas pu le faire! Je ne connaissais même pas ce Imagerqui est assez pratique!)
Dada
@ Dada merci. En fait, c'est un code assez simple. Je corrige tellement les gens à propos de l'utilisation de la notation de méthode sur SO que c'est vraiment difficile de ne pas le faire exprès. Mais tu as raison. C'était la première fois que j'utilisais Imager moi-même. Je pense l'avoir vu dans Perl Weekly.
Simbabque
L'utilisation de @Dada Imager'Coloravec le délimiteur d'espaces de noms Perl 4 enregistre un autre octet. :)
simbabque
En effet, la première fois que je vois un usage pour cette syntaxe! Aussi, -MImagerest plus courte que use Imager;:)
Dada
1
@Dada j'allais le faire quand même: P Et mettre $n=popdans les newarguments sauve les parens et un point
simbabque
14

PHP + SVG, 300 octets

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

La partie mise à l'échelle est width=<?=$_GET[w]?>

Sortie pour la valeur 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>

Jörg Hülsermann
la source
1
Ne pouvez-vous pas jouer l'espace entre les guillemets ( ") des attributs et l'attribut suivant? Par exemple <svg width="333" viewBox="0 0 10 10">-><svg width="333"viewBox="0 0 10 10">
Bojidar Marinov
@ BojidarMarinov Oui, c’est bien, c’est économiser quelques octets. Merci
Jörg Hülsermann
1
Supprimer les espaces entre les lettres et les chiffres dans les données de chemin: M 0,5 A 5 5 0 0 1 5,0 V 2 A 3,3 0 0 0 2,5=>M0,5A5 5 0 0 1 5,0V2A3,3 0 0 0 2,5
darrylyeo
1
Sûr. En outre, pour votre echoinstruction, utilisez une chaîne entre guillemets pour autoriser les variables en ligne et supprimer le point-virgule: echo'<use xlink:href="#c"fill="#'.$k.'"transform="rotate($v,5,5)"/>';=>echo"<use xlink:href='#c'fill='#$k'transform='rotate($v,5,5)'/>"
darrylyeo
2
Je pense que la plupart des guillemets doubles peuvent être supprimés en toute sécurité. Comme <rect x=5 y=4 fill=#4285f4 width=4.9 height=2 />(ici, vous aurez besoin d'un espace avant le /, cependant.)
Arnauld
14

Logo, 258 octets

... parce que je pense que les logos doivent être créés à l'aide de Logo . Ceci est implémenté en tant que fonction. Je l'ai développé en utilisant l'interprète de logo en ligne de Calormen.com

Au départ, j'ai essayé de dessiner chaque segment et de le peindre, mais cela s'est avéré plus volumineux que prévu. Il y avait beaucoup de mouvements perdus de retour en arrière, etc. Au lieu de cela, j'ai décidé de faire un balayage polaire, en ajustant la couleur en fonction de l'en-tête. La partie la plus difficile du calcul consistait à faire la géométrie de la courbe au sommet du rectangle du G. Vous pouvez couper certaines décimales et avoir moins de précision, mais je voulais que ce soit précis à environ 3 chiffres pour s'adapter aux tailles d'écran typiques.

Golfé

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

Échantillon

g 200 Logo Google, taille 200px

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
GuitarPicker
la source
12

JavaScript (ES7), 285 258 254 252 251 octets

Demande la largeur du logo (jusqu'à 999) et le dessine dans un canevas, pixel par pixel.

Edit : La version initiale convertissait les coordonnées cartésiennes en coordonnées (x,y)polaires (r,a), mais nous n'avons pas vraiment besoin de l'angle. Il est plus simple (et nettement plus court) de simplement comparer xet yde savoir dans quel trimestre nous nous situons.

Edit : Sauvegardé 1 octet grâce à ETHproductions.

JS, 251 224 220 218 217 octets

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 octets

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

Version ES6: 258 231 227 225 224 + 34 = 258 octets

Largeur maximale recommandée pour l'extrait de code: 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>

Arnauld
la source
Je regardais à travers la partie JavaScript et immédiatement pensé, « Qu'est - ce sont ceux - ci <-et les -->opérateurs ?? » Je suppose que c'est ce qui se passe lorsque vous réfléchissez pendant 24 heures aux opérateurs hypothétiques pour un langage hypothétique ...: P
ETHproductions
@ETHproductions Ils confondent également le surligneur de syntaxe Notepad ++ qui interprète -->le début (?) D'un commentaire html s'il est placé entre des <script>balises dans un fichier html.
Arnauld
Croyez-le ou non, Notepad ++ a en quelque sorte raison (bien que pas complètement). Découvrez le tout dernier élément du tableau de compatibilité ES6 .
ETHproductions
@ETHproductions - Wow. Je suppose qu'il y a une bonne raison derrière cette syntaxe, mais je ne la vois pas. Merci de l'avoir signalé.
Arnauld
Juste pour que vous sachiez, je crois que ce n'est valable qu'au début d'une ligne. 123 --> commentjette une erreur dans la console de mon navigateur (Firefox 49), alors que ce --> commentn'est pas le cas.
ETHproductions
10

C #, 276 + 21 = 297 octets

276 octets pour la méthode + 21 octets pour l'importation 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;};

Basé sur l'algorithme de Martin Rosenau. Merci d'avoir fait le difficile en proposant un moyen de construire l'image!

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

400: 400

Lait
la source
Vous pouvez économiser des octets en 0xFF...
n’incluant
8

JS / CSS / HTML (+ JS), 40 0 + 701 644 617 593 + 173 90 97 121 = 914 774 754 730 714 octets

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

Utilise des gradients linéaires plutôt que des transformations. Edit: 140 octets enregistrés grâce à @darrylyeo. Sauvegardé 20 octets en utilisant un élément supplémentaire au lieu d'un dégradé. Sauvegardé 24 octets grâce à @DBS. Sauvegardé 16 octets grâce à @Hedi. De l'arrière à l'avant, les différentes couches sont:

  • a Le cercle bleu
  • b Un rectangle blanc pour masquer la partie au-dessus de la barre
  • c Le quart supérieur gauche rouge / jaune
  • d L'octant rouge en haut à droite
  • e Le quart inférieur gauche jaune / vert
  • f Le quartier vert / bleu en bas à droite
  • g Le cercle blanc intérieur
  • h La barre bleue horizontale
Neil
la source
Au lieu d'ID, vous devez utiliser les noms d'éléments tels que a, b, i, s, etc. Utilisez *plutôt divle sélecteur CSS.
darrylyeo
En outre, utiliser backgroundcomme un raccourci pour background-image.
darrylyeo
@darrylyeo Merci, cela a fait une grande différence pour mon score, je n'ai pas oublié d'oublier même les citations de mon code HTML ...
Neil
Hé, pas de problème!
darrylyeo
Je crois que vous pourriez sauver quelques personnages ici et là en utilisant le composé border-radius. Par exemple c{border-radius:100% 0 0;au lieu dec{border-top-left-radius:100%;
DBS
8

Ruby 2.3.1, 376 359 octets

Utilisation de la gemme 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])

Exemples

50x50

50x50

250x250

entrez la description de l'image ici

500x500

entrez la description de l'image ici

1000x1000

entrez la description de l'image ici

Le fichier prend deux paramètres, le premier étant la dimension et le second le nom de fichier dans lequel enregistrer la sortie.

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

J'avais initialement commencé à résoudre cela en utilisant oily_png / chunky_png mais cela finirait probablement par être beaucoup trop compliqué comparé à RMagick. La fonction .ellipse de RMagick en a fait un jeu d'enfant et le travail principal a consisté à ajuster les formes / tailles de tout.

Ceci est ma première soumission Code Golf (première réponse SE également) et je me considère seulement comme intermédiaire avec Ruby. Si vous avez des idées sur les améliorations / conseils, n'hésitez pas à les partager!

métropole
la source
Je n'arrive pas à éditer mon message (erreur 404), mais si je supprimais la ligne require de ma solution golfée, cela réduirait 17 octets et le réduirait à 359 octets.
Métropole
5

Python 2, 378 373 octets

Je voulais vraiment faire cela en utilisant turtle. Pour cela, j'ai dû épousseter mes connaissances en géométrie, en calculant les angles et les longueurs non fournis dans la description du défi.

Éditer: supprimé up(), car cela supprime le petit éclat de blanc entre le vert et le bleu et donne au cercle intérieur une meilleure apparence. Cela ralentit encore plus le programme.

Edit: remplacé 9*npar 2*npour faire plus vite. J'ai déterminé que cela créerait encore un cercle lisse.

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)

Remarques:

  1. Les bibelots utilisent Python 3, donc l'entrée doit être convertie en int.
  2. Les bibelots vont très lentement pour les gros nsi vous supprimez speed(0), que j'ai ajouté uniquement pour la vitesse.
  3. La lenteur du code est principalement due au troisième paramètre de circlecroissance O(n), puisqu'il détermine le nombre de côtés du polygone inscrit pour dessiner le cercle.

Essayez-le en ligne

Ungolfed: Essayez-le en ligne

Fun fact: Trinket est une anagramme de Tkinter, le package graphique de Python et les fondements de turtle.

mbomb007
la source
De plus, si quelqu'un a installé Python, pourrait-il l'exécuter avec une valeur importante de npour moi? Si cela n’a pas l’air sympa, j’aurai peut-être besoin d’y mettre quelques sqrts pour être plus précis. J'ai arrondi au millième.
mbomb007
Ce ne sont que les grandes valeurs qui m'inquiètent. La toile sur Trinket a un maximum de 400.
mbomb007
@daHugLenny Aucune idée. Cela pourrait être un problème de mémoire, car 10000 est une valeur si grande.
mbomb007
5

PHP + GD, 529 449 octets

Cela prend un paramètre de chaîne de requête net génère une version PNG du logo de la taille spécifiée.

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

N = 200:
200x200

Kodos Johnson
la source
La plupart des constantes de chaîne n'ont pas besoin de guillemets. L'image en vraie couleur n'a pas besoin imagecolorallocate; donnez simplement 0xRRGGBB comme couleur aux fonctions de dessin. Un peu plus de golf et il est réduit à 329 octets:, imagefill($i=imagecreatetruecolor($n=$argv[1],$n),0,0,($m=[4359668,3450963,0xfbbc05,0xea4335,0xffffff])[4]);for($j=-11.6;$e=[45,135,225,315][$k];$j=$e)($a=imagefilledarc)($i,$h=$n/2,$h,$n,$n,$j,$e,$m[$k++],0);$a($i,$h,$h,$n*.6,$n*.6,0,0,$m[4],0);imagefilledrectangle($i,$h,$h-$n*.1,$h+$h*.98,$h+$h*.2,$m[0]);imagepng($i,"g.png");exécuter avec -r, prend les entrées de la ligne de commande et les sorties à g.png.
Titus
Désolé, mon golf précédent était trop court sur deux octets: ça [$kdoit être [+$k. Mais celui-ci devrait également fonctionner: imagefill($i=imagecreatetruecolor($n=$argv[1],$n),0,0,$w=2**24-1);$j=-11.6;foreach([$b=4359668,3450963,0xfbbc05,0xea4335]as$c)($a=imagefilledarc)($i,$h=$n/2,$h,$n,$n,$j,$j=45+90*$k++,$c,0);$a($i,$h,$h,$p=$n*.6,$p,0,0,$w,0);imagefilledrectangle($i,$h,$n*.4,$n*.99,$p,$b);imagepng($i,"g.png");(291 octets)
Titus le
@Titus Merci. J'ai découvert après cette réponse que vous n'en aviez pas besoin imagecolorallocate. Je mettrai à jour ma réponse avec votre code. Mais avez-vous besoin de générer un nom de fichier? Ne pouvez-vous pas simplement laisser le nom de fichier imagepngdedans et le faire sortir vers stdout?
Kodos Johnson
5

Java, 568 octets

Ce n’est pas la langue la plus forte pour le golf, mais voici ma tentative la plus sérieuse:

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

Usage:

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

Version sans golf - L'idée de base est de travailler dans le système de coordonnées u, v [−0,5, 0,5] et de calculer la distance et l'angle de chaque pixel à partir du centre de l'image:

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

}

Mon implémentation calcule et dessine les pixels bruts. Il est possible de créer une implémentation alternative utilisant des routines graphiques de haut niveau telles que Graphics2D et Arc2D pour effectuer le dessin, en particulier avec l'anti-aliasing.

Nayuki
la source
4

Go, 379 octets

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

La fonction fprend un seul intargument (le facteur d'échelle) et génère une image SVG mise à l'échelle de manière appropriée.

Essayez-le en ligne sur Ideone.

Exemple de sortie:

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

Il semble faux d’apaiser nos seigneurs Google dans n’importe quel langage de programmation, sauf le leur.

Mego
la source
4

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*

Essayez-le en ligne

Sort l'image en format ASCII ppm.
Pour une version ASCII-art plus agréable à regarder dans le navigateur, essayez ce code . Cela aide aussi à visualiser l'algorithme.

Explication:

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
Aditsu
la source
3

JavaScript (ES6) (+ SVG), 293 octets, non en concurrence

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)

Malheureusement, la jointure de ligne ronde n’est pas tout à fait l’effet demandé, mais elle est assez proche.

Neil
la source
3

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

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}

En supposant que le processeur FreeMarker soit exécuté avec un njeu de variables représentant l'entrée.

Explication des nombres magiques:

Tout est basé sur un wrapper 10x10px, puis redimensionné par n/10.

  • Distance à droite de la boîte horizontale bleue [px]: 5 - sqrt (5 ^ 2 - 1 ^ 2) = 0,10102051443 ( Pythagore )
  • Rotation de l'arc bleu [deg]: 45 - arcSin (1/5) = 33.4630409671 ( Sine )

JSFiddle Ungolfed

Cedric Reichenbach
la source
Placez la partie CSS dans un élément de style et utilisez Javascript ou PHP. remplacer transform:scale(n)par transform:scale(<?=$_GET[n])?>(PHP). En javascript, vous pouvez ajouter la partie CSS au style Element
Jörg Hülsermann
Je pensais à JS mais je ne voulais pas trop gâcher le code. Cependant, les langages de gabarit semblent bien, alors je suis allé avec FreeMarker et j'ai rapidement ajusté ma réponse, merci.
Cedric Reichenbach
La barre bleue est trop loin à droite du côté droit, pense
t-
Non, vous pouvez facilement le calculer en imaginant un triangle rectangle dont les côtés mesurent 0,5, 0,1 et x, où x représente la largeur de la barre bleue ou, en conséquence, 0,5 x sa distance à droite. x peut ensuite être déterminé en utilisant le théorème de Pythagore (voir les explications que j'ai ajoutées).
Cedric Reichenbach,
JSFiddle n’affiche pas correctement dans les deux navigateurs que j’ai essayés (Win10 x64) - avec Chrome 54.0.2840.59 m (64 bits), la barre bleue s’allonge trop à droite et avec Firefox 49.0.1 (32 -bit) il y a un léger écart au milieu de la partie incurvée bleue
alldayremix
3

343 octets de 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"
};

Explication

  • "P3" == pixmap portable en texte brut
  • show == produire des décimales ASCII craignant la corruption UTF-8 pour "\ xFF \ xFF \ xFF"
  • unlines == séparer les décimales en lignes
  • m = n-1 pour la symétrie dans n == longueur [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) ²> (m3 / 10) ² == extérieurInnerCircle
  • mxy> 0 == x + y <m == inUpperLeft
  • xy> 0 == x> y == inUpperRight
  • 5y-2m> 0 == y> m2 / 5 == en dessous de BarreTop
  • 3y-5y> 0 == y <m3 / 5 == au-dessus de BarBot
  • 2x-m> 0 == x> m / 2 == inRightHalf
  • [234,67,53] == rouge
  • [251,188,5] == jaune
  • [52,168,83] == vert
  • [66,13,244] == bleu
  • [255,255,255] == blanc
Czyborra Romain
la source
1
Sauf si vous encodez le tout avec ASCII 7 bits (ce que vous pouvez faire puisque le point de code de caractère le plus élevé que vous utilisez est 0x7C/ 124/ |), auquel cas il s'agirait de 338 septets de Haskell . Mais compte tenu de la façon dont la norme de stockage des données à 8 bits par octet est devenue au cours des deux dernières décennies, je pense que le terme «octets» est suffisamment spécifique pour ne pas vaincre le cheval mort.
Slipp D. Thompson
3

SAS - 590 536 521 octets

Ceci utilise la fonctionnalité d' annotation GTL . L'entrée est spécifiée dans une variable macro sur la première ligne. Pour quelques octets supplémentaires, vous pouvez définir le tout en tant que macro. Il reste encore en dessous de Java et de quelques réponses HTML, même si vous devez définir un modèle de graphe null pour pouvoir tout tracer!

J'ai laissé des sauts de ligne pour un minimum de lisibilité, mais je ne compte pas ceux-ci dans le total car cela fonctionne sans eux.

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

Edit: supprimez quelques octets de plus via l’utilisation de vars de macro, les paramètres par défaut et le choix des opérateurs.

Edit 2: s'est débarrassé des do-endblocs pour la if-then-elselogique et cela fonctionne toujours - je ne comprends pas tout à fait comment. De plus, j'ai découvert la euclidfonction!

utilisateur3490
la source
2

SCSS - 415 octets

Prend les entrées au fur $N: 100px;et à mesure <div id="logo"></div>, ne sachant pas si elles doivent compter dans le total, bien que ...

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

Démo sur JSFiddle

Niet the Dark Absol
la source
1

Haskell avec le package JuicyPixels , 306 octets

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

Exemple d'utilisation:

main = writePng "google.png" $ f 1001

Cela pourrait probablement être amélioré. L'idée est de passer une fonction à generateImagecelle qui sélectionne le pixel (couleur vraiment) qui doit aller à la position x, y. Pour cela, nous utilisons un lambda qui ajoute nun paramètre et qui les convertit tous en float en même temps. La #fonction vérifie si nous sommes dans le ring, dans le bar ou dans aucun des deux. Si c'est la bague, nous passons le relais %, si la barre, nous retournons simplement en bleu, sinon en blanc. %vérifie dans quel quadrant nous nous trouvons et retourne la couleur appropriée si elle n'est pas bleue. Le bleu est un cas particulier, car nous devons nous assurer qu'il ne passe pas au rouge. Nous ne renvoyons donc le bleu que s'il se ysitue en dessous de la "barre de mesure", sinon nous restituons le blanc. C'est la vue d'ensemble.

utilisateur1472751
la source
0

Processing.py - 244 octets + 1 octet pour le nombre de chiffres en N

Commençons par le code. Cela peut être collé dans l'environnement de traitement et exécuté (en changeant Npour différentes tailles).

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)

Petite astuce: le cercle qui coupe une partie du logo est dessiné dans la nuance en niveaux de gris de Processing 205, qui est la couleur d'arrière-plan par défaut. L'exporter dans une image n'aurait pas la même apparence. Cela enregistre un appel à background(255).

Explication

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

Exemples

N = 400

N = 400

N = 13 (la taille minimale du traitement est 100x100)

entrez la description de l'image ici

Remarque

Si nous permettons d’éditer manuellement dans plusieurs valeurs pour Nles appels explicites à setupet drawne sont pas nécessaires et il est réduit à 213 octets + 3 octets par chiffre en 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)
PidgeyUsedGust
la source
En soi, ce n'est pas un programme complet
Kritixi Lithos Le
C'est suffisant. J'ai supprimé le programme incomplet et l'ai remplacé par une version complète.
PidgeyUsedGust