Vous avez peut-être entendu parler du "Logo Hacker", également appelé "Emblème Hacker". Cela ressemble à ceci:

Il s’agit d’un modèle tiré d’une simulation mathématique appelée le jeu de la vie. Le planeur est le modèle de vie le plus simple qui bouge et le plus reconnaissable de tous les modèles de vie.

Le défi

Le défi est simple: affichez le logo du pirate informatique. Ceci est défini comme:

• Une grille 3x3 avec une bordure, un fond blanc et des lignes grises.
• Cinq points noirs disposés dans le motif de planeur GoL.
• Rien d'autre.

Les règles

• Les points noirs doivent remplir 40% - 80% de leurs grilles-boxes individuels.
• Vous allez afficher l'emblème avec une sortie graphique mais pas d'art ASCII .
• La sortie doit être au moins 30x30 pixels .
• La sortie ne doit comporter que les couleurs gris, noir et blanc .
• Chaque case de la grille aura la même taille. La grille sera un carré 3x3 régulier .
• Vous ne pouvez pas extraire le logo d’Internet ou de votre système de fichiers.
• Votre programme affichera le logo sur un écran / une fenêtre vide. S'il se termine, il doit le faire normalement.
• Notez que "points" ne signifie pas nécessairement "cercles". Un "point" est une forme géométrique unique centrée au milieu de la grille avec une surface. Par exemple, alors qu'un cercle ou un carré sera considéré comme un point, deux triangles ou un damier ne le seront pas.

Le gagnant

Comme il s'agit de code-golf , la réponse la plus courte dans chaque langue est gagnante!

Veuillez inclure une capture d'écran de la sortie de votre programme dans votre réponse.

Mathematica, 62 octets

Grid[{{,a=██,},{,,a},{a,a,a}},Frame->All,FrameStyle->Gray]

Mathematica, 71 octets

Grid[{{,l=Graphics@Disk[],},{,,l},{l,l,l}},Frame->All,FrameStyle->Gray]

CSS + HTML, 56 + 84 = 140 octets 52 + 84 = 136 octets

Sauvegardé 4 octets en incorporant les suggestions des commentaires.

td{border:1px solid#888;line-height:.4;font-size:3em

<table cellspacing=0><tr><td><td>•<td><tr><td><td><td>•<tr><td>•<td>•<td>•

Ceci utilise le caractère UTF-8 •qui fait 2 octets et tire parti de la grâce de la syntaxe HTML.

GLSL (fragment shader), 278 235 256 octets

precision highp float;void main(){vec2 a=gl_FragCoord.xy/20.-.2;ivec2 b=ivec2(a);a-=vec2(b)+.5;if(b.x>2||b.y>2)discard;gl_FragColor=a.x<-.5||a.y<-.5||a.x>.3||a.y>.3?vec4(.5,.5,.5,1.):length(a+.1)<.4&&(b.x+b.y-3)*b.y==0?vec4(0.,0.,0.,1.):vec4(1.,1.,1.,1.);}

Voyez-le en action: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 octets

from turtle import*
up()
shape("square")
color("gray",[1]*3)
i=9
while i:
 i-=1;goto(20-i/3*20,20-i%3*20);stamp()
 if 302&2**i:dot(15,0,0,0)

La taille réelle, 61 par 61, est tracée dans une toile beaucoup plus grande de 300 par 400:

Affichage de la grille de pixels:

Les points utilisent 177 pixels dans la plage de 40% à 80%, que l’on considère le remplissage blanc de 19 sur 19 (144,4 à 288,8) ou le fond de 21 sur 21 incluant les deux bords (176,4 à 352,8).

Remarque: le programme termine et ferme la fenêtre de dessin dès que le dessin est terminé, pour permettre la fermeture manuelle de la fenêtre et l'ajout de la ligne done().

turtleest un paquet Python développé pour la programmation graphique d'introduction. Un stylo commence au x,y=0,0milieu d'une toile de 300 x 400 pixels (par défaut), uplève le stylo, gotodéplace le stylo, shapedéfinit la forme du stylo sur une forme nommée ( "square"correspond à une forme prédéfinie avec une largeur de pixel par défaut de 21 ), colordéfinit la couleur, où deux paramètres définissent le trait (avec par défaut une largeur de 1) et le remplissage; un octet est enregistré à l’aide de l’ (r,g,b)option tuple à remplacer "white"par [1,1,1]la multiplication de liste [1]*3. Enfin dotdessine un point avec la largeur donnée en pixels et en couleur. La valeur de largeur par défaut du point est trop petite pour être qualifiée, de 9sorte que j'en ai fait une esthétique et une qualification 15. La couleur du point pourrait être"black"mais le (r,g,b)tuple non compressé de 0,0,0est plus court de deux octets.

Le stylo doit s’éloigner de tout point à la fin, sinon le stylo gris / blanc le cache.

La grille est parcourue en utilisant div ( /) et mod ( %) de idébutant à 8( iest initialisée à 9mais est décrémentée au début de la whileboucle) et en descendant à 0, en décalant les résultats de 2,1,0en -1,0,1utilisant (1-...)et en les redimensionnant à la taille de la grille en utilisant un facteur de 20 (notez qu'il 20-i/3*20s'agit en fait d'un octet inférieur à 20*(1-i/3), il en va de même %). Cela produit l’ordre [en bas à gauche, centre à gauche, haut à gauche, bas au centre, centre-milieu, haut-milieu, haut à droite, centre-droite, haut-droit], et nécessite une " hasDot" évaluation de [1,0,0,1,0,1,1,1,0], qui est 302dans la binaire peut être consultée par l' inspection de la i^ième puissance de deux composantes de302avec l'aide d'un bitwise et 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 octets

^{-32 en utilisant des noms de variables illisibles: P
-1 parce qu'Apple a décidé d'être magique et m'a laissé utiliser un GOTO implicite / inexistant}

Voici mon propre programme (très satisfaisant) pour un exemple de sortie n'utilisant pas de cercles:

1GR:POKE49234,0:COLOR=15:FORI=0TO39:VLIN0,47ATI:NEXT:COLOR=5:S=21:W=S:H=27:X=INT((40-W)/2):Y=INT((48-H)/2):D=INT(W/3):DX=D:C=Y+H:G=X+W:FORI=0TO3:VLINY,C ATX+I*D:NEXT:D=INT(H/3):FORI=0TO3:HLINX,G ATY+I*D:NEXT:YH=INT(D/2):Z=Y+H-YH:XH=INT(DX/2):COLOR=0:FORI=0TO2:B=Z:A=X+XH+I*DX:GOSUB5:NEXT:B=B-D:GOSUB5:B=B-D:A=A-DX:GOSUB5:K=PEEK(-16384):IFK<128THEN2:K=PEEK(-16368):TEXT:HOME:END 
5VLINB+2,B-3ATA:VLINB+2,B-3ATA-1:VLINB+2,B-3ATA+1:VLINB+2,B-3ATA+2:VLINB,B-1ATA-1:VLINB,B-1ATA+2:RETURN

Sortie:

Code machine IA-32, 81 à 80 octets

Hexdump:

60 8b f9 b8 50 35 20 20 ab b8 32 35 36 20 ab ab
ab fe 4f fe 33 c9 66 49 51 8a c1 d4 55 50 8a c5
d4 55 5b b2 80 84 c0 74 1f 84 db 74 1b b2 ff 2c
10 3c 35 77 13 93 2c 10 3c 35 77 0c 8d 0c 58 8a
cd b0 e4 d2 e0 79 01 42 92 aa 59 e2 cb aa 61 c3

C'est une fastcallfonction appelée doitqui renvoie l'image au format PGM dans le tampon fourni. Usage:

char buf[256 * 256 + 256];
doit(buf);

FILE* f = fopen("k.pgm", "wb");
fwrite(buf, 1, sizeof buf, f);
fclose(f);

Sortie:

J'ai utilisé une résolution de 256 x 256 car c'est cool, cela me permet de scinder ecxautomatiquement l'index du pixel en coordonnées ydans chet xdans cl. De plus, le format de fichier PGM nécessite le nombre 255 dans l'en-tête de l'image.

Les carrés intérieurs mesurent 54 x 54 (41% de la cellule par zone).

Code source (peut être compilé par Visual Studio):

    pushad;                 // save all registers
    mov edi, ecx;           // edi is now the pointer to output
    mov eax, '  5P';        // PGM file header
    stosd;                  // store it
    mov eax, ' 652';        // the number 256 and a space
    stosd;                  // store the width
    stosd;                  // store the height
    stosd;                  // store maximum brightness
    dec byte ptr [edi-2];   // fix maximum brightness to 255

    xor ecx, ecx;           // initialize the counter of pixels
    dec cx;                 // to 65535
myloop:
    push ecx;

    mov al, cl;             // al = cl = x coordinate in the image
    _emit 0xd4;             // divide by 85
    _emit 85;               // ah = x cell number, al = x coordinate in cell
    push eax;
    mov al, ch;             // al = ch = y coordinate in the image
    _emit 0xd4;             // divide by 85
    _emit 85;               // ah = y cell number, al = y coordinate in cell
    pop ebx;                // bh = x cell number, bl = x coordinate in cell

    mov dl, 0x80;           // gray pixel value
    test al, al             // is cell boundary (y)?
    je output1;
    test bl, bl;            // is cell boundary (x)?
    je output1;

    mov dl, 255;            // white pixel value
    sub al, 16;
    cmp al, 53;
    ja output1;             // if outside the inner square, output white
    xchg eax, ebx;          // exchange the registers to shorten following code
    sub al, 16;
    cmp al, 53;
    ja output1;             // if outside the inner square, output white

    lea ecx, [ebx * 2 + eax]; // cell index = y * 2 + x
    mov cl, ch;
    mov al, 0xe4;           // load the bitmap for the glider pattern
    shl al, cl;             // shift the needed but into SF
    jns output1;            // the bit was 0? - output white
    inc edx;                // the bit was 1? - change to black

output1:
    xchg eax, edx;
    stosb;                  // output the byte

    pop ecx;
    loop myloop;
    stosb;                  // output an additional gray pixel
    popad;
    ret;

Le modèle de cellule

0 1 0
0 0 1
1 1 1

peut être représenté par un bitmap "optimisé" de 7 bits.

Les bits sont indexés par l'expression y * 2 + x, où (x,y)est l'emplacement de la cellule. Cette expression donne le même indice à 2 paires de cellules. C'est une chance si les valeurs de bits sont les mêmes.

HTML et CSS, 155 octets

Il s'avère que HTML oublie vraiment les erreurs de syntaxe.

_{1 octet sauvegardé grâce à @Octopus · 1 octet sauvegardé grâce à @Downgoat · 2 octets sauvegardé grâce à @StephenS}

_{2 octets enregistrés grâce à @Ryan · 3 octets enregistrés grâce à @styfle · 4 octets enregistrés grâce à @Ferrybig}

_{13 octets sauvegardés grâce à @SteveBennett}

p{height:33px;width:33px;border-radius:50%;background:#000;margin:0

<table cellspacing=0 border=1><td><td><p><td><tr><td><td><td><p><tr><td><p><td><p><td><p

R ( 130 119 113 octets)

plot(c(2,4,6,4,6),c(2,2,2,6,4),an=F,ax=F,xli=(l=c(1,7)),yli=l,xaxs="i",yaxs="i",pch=16,cex=19);grid(3,lt=1);box()

Python 2.7, 214 311 309 octets

from matplotlib.pyplot import*
f,x=subplots()
j=(0,0),(1,0),(2,0),(1,2),(2,1)
for i in j:x.add_artist(Circle((i),.4,color='k'))     
x.tick_params(labelbottom='off',labelleft='off')
for o in x.spines.values():o.set_edgecolor('gray')
for s in 'xy':exec"x.set_"+s+"ticks((.5,1.5,2.5));"+s+"lim(-.5,2.5);"
grid()

Ceci est ma première tentative ici à code golf, donc je suis sûr que cela peut être amélioré. J'aurais aimé ne pas établir les limites, mais il semble que matplotlib ne puisse pas détecter que j'ai tracé les cercles où je l'ai fait. Sans définir xlim () et ylim (), seuls les deux cercles du bas sont affichés.

Sortie:

Edit: Correction de la couleur des bordures et suppression des numéros de ticks. Je dois dire que matplotlib est libellé de manière très dense et qu’il n’est pas trop convivial avec les couleurs changeantes des axes.

Rasé 3 octets grâce à @DJMcMayhem

Edit: J'ai enlevé deux octets en définissant mes ticks comme un tuple dans les fonctions set_ticks.

Bash + ImageMagick, 233 226 caractères

convert xc: +antialias -resize 31 -draw "stroke gray fill none ${r=rectangle} 0,0 10,30$r 20,0 30,30$r 0,0 30,10$r 0,20 30,30stroke #000 fill #000 ${c=circle} 15,5 15,8$c 25,15 25,18$c 5,25 5,28$c 15,25 15,28$c 25,25 25,28" x:

Exemple de sortie:

Bash + ImageMagick, 215 caractères

convert xc: -resize 31 -draw "stroke gray fill none ${r=rectangle} 0,0 10,30$r 20,0 30,30$r 0,0 30,10$r 0,20 30,30stroke #000 fill #000 ${c=circle} 15,5 15,8$c 25,15 25,18$c 5,25 5,28$c 15,25 15,28$c 25,25 25,28" x:

Le propriétaire de la question n'a pas encore répondu à la question sur l' anti-aliasing et certaines autres solutions ont également des nuances de gris supplémentaires ajoutées par l'anti-aliasing.

Exemple de sortie:

Ruby, 144 166 164 148 144 octets

require'ruby2d'
set background:'grey'
c=482;g=2,13,24;d=0
g.map{|y|g.map{|x|Square.new(x,y,9);Square.new(x+2,y+2,5,"black")if c[d]>0;d+=1}}
show

Sortie:

Edit: a maintenant des lignes grises.

PNG, 105 à 100 octets

   (ie ce fichier image)

Considérant que le langage HTML et d’autres langages ne faisant pas partie de la programmation sont autorisés , j’étais curieux de voir à quel point je pouvais jouer au golf avec une image simple pouvant être affichée sur le navigateur, afin de servir de comparaison de base. Le résultat est compressé avec les outils open source optipng ( -o7 -zm1-9 -strip all) et pngwolf . J'ai aussi expérimenté le zopflipng , mais les résultats étaient plus grands. D'autres outils de compression à source fermée pourraient peut-être supprimer quelques octets supplémentaires.

Données d'image en base64:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTgAAAABJRU5ErkJggg==

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
    fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
    4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTgAAAABJRU5ErkJggg==">

Modifier je fait les points se touchent la partie supérieure de la cellule et en bas, pour provoquer plus répétitivité dans le motif de pixels et d' améliorer ainsi le taux de compression. Mais ne vous inquiétez pas, un point ne remplit toujours que (7 * 9) / (9 * 9) 78% de sa cellule.

PNG non standard, 88 octets

Comme l'a souligné @anatolyg , il existe un potentiel de golf en supprimant le bloc IEND (12 octets). Techniquement, IEND est requis par la norme . Cependant, chaque bloc PNG inclut ses propres informations de taille et de somme de contrôle. Il n'est donc pas absolument nécessaire d'avoir un marqueur de fin. Et en effet, tous les navigateurs que j'ai testés peuvent afficher l'image sans problème.

Malheureusement (ou heureusement), cette image non standard est rejetée par imgur, je ne peux donc pas la télécharger. C'est l'encodage base64:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTg==

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAA
fCAAAAAA6xUnlAAAAK0lEQVR42mM4gB8wHPgPAwf+M0DAf4TYqDwp
4Ydp0qg8ofBDqMXKGpXHDwDDq0qBspApTg==">

Octave , 127 124 octets

Suppression de 3 octets grâce à Luis. gridest suffisant (au lieu de grid on).

spy([0,1,0;0,0,1;1,1,1],'.k',300),set(gca,'XTick',.5:4,'XTickLabel','','YTick',.5:4,'YTickLabel',''),axis(.5+[0,3,0,3]),grid

Sorties (après sauvegarde):

Notez que la sortie affiche des lignes de grille grises dans la fenêtre de tracé. Ils deviennent noirs lors de la sauvegarde (pour une raison quelconque).

Eh bien, c'était long et désordonné! Il a fallu passer par de nombreuses modifications pour que cela respecte les spécifications.

Explication et, espérons-le, du golf à venir ...

Traitement, 212 198 octets

background(-1);noFill();stroke(99);rect(0,0,99,99);rect(0,33,99,33);rect(33,0,33,99);fill(0);int f=25;ellipse(15,83,f,f);ellipse(50,83,f,f);ellipse(83,83,f,f);ellipse(83,50,f,f);ellipse(50,15,f,f);

Fondamentalement, nous utilisons un traitement simple pour dessiner un fond blanc, puis définissons la transparence des rectangles utilisés pour la grille et dessinons leurs traits en gris. Nous continuons en définissant le rectangle, en définissant à nouveau la valeur de remplissage pour remplir les cercles en noir et en définissant cinq cercles.

Voilà!

Tu pourrais ajouter

strokeWidth(2); 

ou plus pour mieux voir la couleur des traits.

(C'est mon premier code-golf, j'espère avoir tout fait correctement.)

EDIT: Merci à Kritixi Lithos! Suppression des sauts de ligne, modification en int f = 25 et utilisation de -1 en arrière-plan (float)

Tikz, 193 175 170 octets

\documentclass[tikz]{standalone}\begin{document}\tikz{\def\a{)rectangle(}\def~{)circle(1)(}\draw(4,6\a2,0)(0,\a6,6)(0,2\a6,4);\fill(1,1~3,1~5,1~5,3~3,5~,)}\end{document}

Voici la sortie:

MATL , 74 69 68 64 62 octets

4:6B&f,.5+w]'k.'5Y08W5$XG7lZG1$3ZG1tZG4:"@th1Kh'k'3$XG1Mbw3$XG

Essayez-le sur MATL Online! (Cela prend quelques secondes.)

Sortie de l'interprète en ligne:

Traitement, 134 octets

Inspiré par @Zep, voici mon traitement one-liner Processing (ainsi que mon premier code golf):

stroke(127);for(int i=0;i<9;i++){int x=i%3*30;int y=i/3*30;fill(255);rect(x+5,y+5,30,30);if(i==1||i>4){fill(0);ellipse(x+20,y+20,23,23);}};

Merci pour @Kritixi Lithos pour ses brillants conseils sur la réduction de quelques octets!

LaTeX + Tikz, 155 octets

\documentclass[tikz]{standalone}\begin{document}\tikz{\draw(0,0)grid(3,3);\foreach\x/\y in{0/0,1/0,2/0,2/1,1/2}\fill(\x+.5,\y+.5)circle(.5);}\end{document}

SmileBASIC, 125 octets

GCLS-1GCOLOR #GRAY
GBOX.,8,30,38GBOX 10,8,20,38GBOX.,18,30,28G.,1G 1,2G-1,3G.,3G 1,3DEF G X,Y
GPUTCHR X*10+12,Y*10,58081,.END

58081 (U + E2E1, qui est dans le bloc "Zone d'utilisation privée") est le code de caractère d'un symbole de cercle. Le placer dans une chaîne fonctionnerait aussi, mais comme il est codé sur 3 octets en UTF-8, il aurait la même longueur (et ne s'afficherait pas correctement ici).

C #, 333 octets

using System.Drawing;_=>{var b=new Bitmap(31,31);var g=Graphics.FromImage(b);g.FillRectangle(Brushes.White,0,0,31,31);for(int x=0,y;x<3;++x)for(y=0;y<3;++y){g.DrawRectangle(Pens.Gray,x*10,y*10,10,10);if(x==1&y<1|x>1&y==1|y>1)g.FillEllipse(Brushes.Black,x*10+1,y*10+1,8,8);}b.Save("t.png");System.Diagnostics.Process.Start("t.png");};

Version complète / formatée:

using System.Drawing;
Action<int> a = _ =>
{
    var b = new Bitmap(31, 31);
    var g = Graphics.FromImage(b);

    g.FillRectangle(Brushes.White, 0, 0, 31, 31);

    for (int x = 0, y; x < 3; ++x)
        for (y = 0; y < 3; ++y)
        {
            g.DrawRectangle(Pens.Gray, x * 10, y * 10, 10, 10);
            if (x == 1 & y < 1 | x > 1 & y == 1 | y > 1)
                g.FillEllipse(Brushes.Black, x * 10 + 1, y * 10 + 1, 8, 8);
        }

    b.Save("t.png");
    System.Diagnostics.Process.Start("t.png");
};

L'idée est simple, nous créons un objet graphique à partir de l'image et l'utilisons pour rendre l'image tout blanche. Passez ensuite en boucle sur chaque carré de l’image en traçant le rectangle de délimitation. Si c'est l'un des emplacements pour un point, nous le dessinons aussi. Enfin, nous enregistrons l’image dans un fichier et laissons Windows décider de son ouverture. Dans mon cas, elle s’ouvre avec Windows Photo Viewer.

L'utilisation de a Processpour afficher l'image et enregistrer dans un fichier est beaucoup plus courte que la création d'un formulaire Windows ou d'une application WPF en raison de la diversité des classes et des fonctions supplémentaires nécessaires à leur création.

Sortie:

PHP, 221 + 2 octets

<?imagefill($i=imagecreatetruecolor(31,31),0,0,~0);function q($i,$x,$y,$f){imagerectangle($i,$x*=10,$y*=10,$x+10,$y+10,5e6);$f?:imagefilledellipse($i,$x+5,$y+5,8,8,0);}for($p=16;$p--;)q($i,$p&3,$p>>2,53>>$p&1);imagepng($i);

Enregistrer dans un fichier; appeler dans le navigateur. Si votre navigateur affiche du charabia,
insérez-le header("Content-Type:image-png");avant imagepng($i);.

Les points ne sont pas très ronds; c'est dû aux petites proportions.

panne

function q($i,$x,$y,$f){        # function to draw quadrant:
    imagerectangle($i,$x*=10,$y*=10,$x+10,$y+10,5e6);   # draw lines in 0x4c4b40
    $f?:imagefilledellipse($i,$x+5,$y+5,8,8,0);         # if bit not set, draw dot
}

imagefill($i=
    imagecreatetruecolor(31,31) # create image
    ,0,0,~0);                   # fill with 0xffffff (white)
for($p=16;$p--;)q($i,           # loop through positions, call function
    $p&3,                           # $x=lower two bits
    $p>>2,                          # $y=upper two bits
    53>>$p&1                        # $f=one bit from %0000 0000 0011 0101
);                                      # (reversed inverted bit mask for dots)
imagepng($i);                   # output image

Je pense que cela peut être 0x4c4b40qualifié de gris approximatif. Sinon, ajoutez quatre octets.

R 313 236 octets

l=c(1,7)
bmp('r',400,400)
plot(x=c(4,6,2,4,6),c(6,4,2,2,2),cex=14,pch=19,xlim=l,ylim=l,xlab='',ylab='',xaxs='i',yaxs='i',axes=F)
a=function(s,...){axis(s,labels=F,tck=1, col="gray",lwd=9,...)}
a(1,xaxp=c(l,3))
a(2,yaxp=c(l,3))
dev.off()

Code révisé, basé principalement sur les commentaires de @ user2390246 enregistré 77 octets. Beaucoup apprécier l'aide.

En outre, souhaitez ajouter un appel à la solution plus courte de R par @mschilli. Cela montre une manière élégante de résoudre le problème des valeurs graphiques par défaut de R.

Sortie

Va à un nom de fichier "r". Omettre et extension m'a sauvé quatre octets. Mais ensuite, j'ai dû modifier l'extension du fichier en "bmp" pour le télécharger. Alors peut-être que je ne devrais pas obtenir de crédit pour ces quatre octets.

Commentaire

Je me suis dit: "Ce graphique n'est qu'un simple graphique avec cinq points. Devrait être une tâche simple à implémenter dans un langage doté de puissantes capacités graphiques pour les données. Essayons-le dans R." Mais ensuite, je devais dépenser environ 80% des octets, en contournant juste les valeurs par défaut graphiques de R.

Un peu le mauvais outil pour le travail ....

Je ne pouvais pas trouver une façon moins verbeuse de garantir la taille et le format du graphique qu'en appelant le constructeur bmp puis dev.off (). La combinaison représente 25 octets. Si votre session R est correctement configurée, vous obtiendrez peut-être un graphique plus ou moins correct sans dépenser ces octets, mais ce n’est ni fiable ni cohérent.

TI-BASIC, 218 140 137 octets

Remarque: ce nombre d'octets est un peu gonflé. Le programme utilise seulement 85 jetons, mais cela est enregistré dans 137 octets. De plus, si vous utilisez une calculatrice non-couleur, vous pouvez enregistrer 4 autres jetons, car vous n'avez pas à spécifier la couleur (qui est bleue par défaut), mais je ne sais pas si leurs écrans sont suffisamment grands pour ce défi parce que je n'en possède pas.

prgmHACKER (138 octets, 86 jetons):

{0,1,2,1,2}→L1
{0,0,0,2,1}→L2
.3→R
For(I,0,5
L₁(I)+.5→A
L₂(I)+.5→B
For(N,0,R,dX
√(R²-N²
Line(A+N,B-Ans,A+N,B+Ans,BLACK
Line(A-N,B-Ans,A-N,B+Ans,BLACK
End
End

Pour un affichage correct, ce programme nécessite que Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX doit également être correctement défini, mais la calculatrice le fait pour vous lorsque vous définissez une autre variable de fenêtre. Je ne pouvais pas voir combien d'espace ces variables utilisaient dans la RAM.

De plus, les paramètres de format doivent être {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF}, mais ils sont des valeurs basculées et ne consomment aucun espace supplémentaire en fonction du réglage.

R, 119 114 111 octets

( Merci à @JayCe de m'avoir sauvé 3 octets)

Pas plus courte que l' autre solution R , mais une approche complètement différente:

layout(matrix(c(1,9,2:8),3,,T))
par(mar=0*1:4)
for(i in 1:9){frame();if(i>4)points(.5,.5,,19,cex=29);box(fg=8)}

Utilise une mise en page dans laquelle les 4 premières parcelles sont les cellules vides et les 5 autres, celles avec des points.

Excel VBA, 180 octets

Fonction de fenêtre VBE Immediate anonyme qui ne prend aucune entrée et est renvoyée vers l'objet de feuille de calcul par défaut ( Sheet1).

Cells.RowHeight=48:Cells.Interior.Color=-1:[B2:D4].Borders.Color=7434613:For Each s In[{21,32,13,23,33}]:Sheet1.Shapes.AddShape(9,48*(s\10)+4,Mid(s,2)*48+4,40,40).ShapeStyle=8:Next

Version commentée

Cells.RowHeight=48                      ''  Make the Cells square
Cells.Interior.Color=-1                 ''  Remove the default grid
[B2:D4].Borders.Color=7434613           ''  Create the 3x3 gray grid at range `B2:D4`
For Each s In [{21,32,13,23,33}]        ''  Assign and iterate over a list of where
                                        ''  to place the dots; This list is a range that 
                                        ''  is coerced into a numeric array

    Sheet1.Shapes.AddShape(         _   ''  Add a shape to the Sheet1 object
                9,                  _   ''  An Oval (msoShapeOval)
                48*(s\10)+4,        _   ''  At the calculated value from the left
                Mid(s,2)*48+4,      _   ''  At the calculated value from the top
                40,                 _   ''  that is 40 units wide
                40                  _   ''  and is 40 units tall
                ).ShapeStyle=8          ''  and is black filled with a black outline

Next                                    ''  repeat to end of list

Sortie

-6 octets pour utiliser [{21,32,13,23,33}]plusSplit("21 32 13 23 33")

-2 octets pour utiliser Mid(s,2)plusRight(s,1)

-3 octets pour utiliser (s\10)plusLeft(s,1)

Octave 107 94 103 octets

scatter([1:3,3,2],[1,1,1:3],1e5,zeros(5,3),'.');axis off;a=[1,7]/2;for i=.5:3.5;line(a,i);line(i,a);end

ou

plot([1:3,3,2],[1,1,1:3],'k.','markersize',250);axis off;a=[1,7]/2;for i=.5:3.5;line(a,i);line(i,a);end

les deux solutions sont 103 octets.

Apple Swift (iOS - CoreGraphics / QuartzCore) - 832 octets

J'ai entièrement dessiné la forme à l'aide de Quartz pour un appareil Apple iOS. Malheureusement, ce n'est pas un langage particulièrement soucieux de la taille, donc le résultat est assez volumineux, mais c'est aussi petit que je peux l'obtenir.

UIGraphicsBeginImageContext(CGSize(width:60,height:60));let c=UIGraphicsGetCurrentContext()!;UIColor.lightGray.setStroke();c.addRect(CGRect(x:0,y:0,width:60,height:60));c.move(to: CGPoint(x:20,y:0));c.addLine(to: CGPoint(x:20,y:60));c.move(to: CGPoint(x:40,y:0));c.addLine(to: CGPoint(x:40,y:60));c.move(to: CGPoint(x:0,y:20));c.addLine(to: CGPoint(x:60,y:20));c.move(to: CGPoint(x:0,y:40));c.addLine(to: CGPoint(x:60, y:40));c.strokePath();UIColor.black.setFill();c.addEllipse(in:CGRect(x:22,y:2,width:16,height:16));c.addEllipse(in:CGRect(x:42,y:22,width:16,height:16));c.addEllipse(in:CGRect(x:2,y:42,width:16,height:16));c.addEllipse(in:CGRect(x:22,y:42,width:16,height:16));c.addEllipse(in:CGRect(x:42,y:42,width:16,height:16));c.fillPath();let i=UIGraphicsGetImageFromCurrentImageContext();sub.addSubview(UIImageView(image:i))

Une version plus lisible pour quiconque est intéressé:

    UIGraphicsBeginImageContext(CGSize(width: 60, height: 60))
    let c = UIGraphicsGetCurrentContext()!

    UIColor.lightGray.setStroke()
    c.addRect(CGRect(x: 0, y: 0, width: 60, height: 60))
    c.move(to: CGPoint(x: 20, y: 0))
    c.addLine(to: CGPoint(x: 20, y: 60))
    c.move(to: CGPoint(x: 40, y: 0))
    c.addLine(to: CGPoint(x: 40, y: 60))
    c.move(to: CGPoint(x: 0, y: 20))
    c.addLine(to: CGPoint(x: 60, y: 20))
    c.move(to: CGPoint(x: 0, y: 40))
    c.addLine(to: CGPoint(x: 60, y: 40))
    c.strokePath()

    UIColor.black.setFill()
    c.addEllipse(in: CGRect(x: 22, y: 2, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 42, y: 22, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 2, y: 42, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 22, y: 42, width: 16, height: 16))
    c.addEllipse(in: CGRect(x: 42, y: 42, width: 16, height: 16))
    c.fillPath()

    let i = UIGraphicsGetImageFromCurrentImageContext()
    sub.addSubview(UIImageView(image: i))

Voici la sortie produite dans le simulateur iOS:

Rubis avec chaussures, 118 personnages

Shoes.app{9.times{|i|
stroke gray
fill white
rect x=i%3*w=10,y=i/3*w,w,w
stroke fill black
oval x+2,y+2,7if 482[i]>0}}

Bit emprunté à la vérification RJHunter est un commentaire fait sur Mark Thomas 's solution Ruby .

Exemple de sortie:

SVG + HTML, 146 138 135 133 octets

<svg>
<path fill=none stroke=#ccc d=m.5.5h30v30h-30zh10v30h10v-30zv10h30v10h-30 />
<path d=m11,1h9v9m1,1h9v9m-29,1h9v9m1-9h9v9m1-9h9v9>

Grâce à l'analyseur HTML indulgent, la xmlns="http://www.w3.org/2000/svg"déclaration peut être omise, ainsi que les guillemets d'attributs et la balise de fermeture. Cette version résout certains problèmes d’autres solutions HTML:

• Un "point" est garanti pour remplir au moins 40% de sa cellule (§1)
• Il n’utilise pas de graphiques externes, p.ex. des glyphes de polices (§2, §6)
• La grille est parfaitement carrée (§5)

Éditer Supprimez 8 octets en exploitant le fait que les sous-chemins n’ont pas besoin d’être fermés pour être remplis .

Modifier Selon la grammaire svg , il n'est pas nécessaire de séparer les non-chiffres par une virgule ( .5,.5). J'ai également abandonné le remplissage explicite, afin de pouvoir changer la direction du tracé d'une ligne de négative à positive, en enregistrant un tiret. Et enfin, j'ai ajusté le nombre pour ne pas inclure de fin de ligne, désolé pour cette erreur de recrue.

Modifier Apprentissage à partir d’ une autre réponse sur codegolf, j’ai remplacé le final 9 />par 9>. Cela fonctionne très bien dans tous les navigateurs testés.

Python 3 + PyGame, 238 octets

from pygame import*
d=display
s=d.set_mode([55]*2)
s.fill([255]*3)
f=lambda*a:draw.line(s,[128]*3,*a)
for x in[0,18,36,54]:
 f((x,0),(x,55));f((0,x),(55,x))
for x,y in zip([3,5,1,3,5],[1,3,5,5,5]):draw.circle(s,[0]*3,(x*9,y*9),7)
d.flip()

Les constantes apparemment arbitraires viennent de ma part lorsque j'essaie de rendre l'image la plus grande possible sans sacrifier les octets.

Avec des caractères non imprimables, 229 octets

from pygame import*
d=display
s=d.set_mode([55]*2)
s.fill([255]*3)
f=lambda*a:draw.line(s,[128]*3,*a)
for x in b'\0␒$6':
 f((x,0),(x,55));f((0,x),(55,x))
for x,y in zip(b'␃␅␁␃␅',b'␁␃␅␅␅'):draw.circle(s,[0]*3,(x*9,y*9),7)
d.flip()

J'ai remplacé les listes par des littéraux en octets, ce qui enregistre de nombreux caractères, mais les caractères non imprimables ne peuvent pas être affichés correctement ici. J'ai substitué les caractères non imprimables par leurs équivalents graphiques U + 2400-U + 2421 à des fins d'affichage.