Você pode ter ouvido falar do "Hacker Logo", também chamado de "Hacker Emblem". Se parece com isso:

Este é um padrão de uma simulação matemática chamada Jogo da Vida. O planador é o padrão de vida mais simples que se move e o mais instantaneamente reconhecível de todos os padrões de vida.

O desafio

O desafio é bem simples: exiba o logotipo do hacker. Isso é definido como:

• Uma grade 3x3 com uma borda, um fundo branco e linhas de grade cinza.
• Cinco pontos pretos dispostos no padrão de planador GoL.
• Nada mais.

As regras

• Os pontos pretos devem preencher 40% - 80% de suas caixas de grade individuais.
• Você exibirá o emblema com saída gráfica, mas sem arte ASCII .
• A saída deve ter pelo menos 30x30 pixels .
• A saída deve ter apenas as cores cinza, preto e branco .
• Cada caixa de grade na grade terá o mesmo tamanho. A grade será um quadrado 3x3 regular .
• Você não pode retirar o logotipo da Internet ou do seu sistema de arquivos.
• Seu programa exibirá o logotipo em uma tela / janela vazia. Se terminar, deve fazê-lo normalmente.
• Observe que "pontos" não significa necessariamente "círculos". Um "ponto" é uma única forma geométrica centralizada no meio da caixa de grade com uma superfície. Por exemplo, enquanto um círculo ou quadrado se qualificar como ponto, dois triângulos ou um tabuleiro de xadrez não o serão.

O vencedor

Como se trata de código-golfe , a resposta mais curta em cada idioma vence!

Inclua uma captura de tela da saída do seu programa na sua resposta.

Mathematica, 62 bytes

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

Mathematica, 71 bytes

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

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

Economizou 4 bytes incorporando sugestões dos comentários.

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

Isso usa o caractere UTF-8, •que tem 2 bytes de comprimento e aproveita a graça da sintaxe HTML.

GLSL (fragment shader), 278 235 256 bytes

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

Veja em ação: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 bytes

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)

O tamanho real, 61 por 61, plotado em uma tela muito maior de 300 por 400:

Mostrando a grade de pixels:

Os pontos usam 177 pixels na faixa de 40% a 80%, considerando o preenchimento branco de 19 por 19 (144,4-288,8) ou os 21 por 21, incluindo as duas bordas (176,4-352,8).

Nota: o programa termina e fecha a janela da tela assim que o desenho é concluído, para permitir o fechamento manual da janela acrescentando a linha done().

turtleé um pacote Python desenvolvido para programação gráfica introdutória. Uma caneta começa no x,y=0,0meio de uma tela de 300 por 400 pixels (por padrão), uplevanta a caneta, gotomove a caneta, shapedefine a forma da caneta para uma forma nomeada ( "square"é uma forma predefinida com uma largura de pixel padrão de 21 ), colordefine a cor, onde dois parâmetros definem traçado (com a largura padrão 1) e preenchimento; um byte é salvo usando a (r,g,b)opção tupla para substituir "white"pelo [1,1,1]uso da multiplicação de lista [1]*3. Por fim, dotdesenha um ponto com a largura especificada em pixels e cores. O valor da largura padrão do ponto é muito pequeno para se qualificar, assim como 9eu o tornei estético e qualificado 15. A cor do ponto pode ser"black"mas a (r,g,b)tupla descompactada 0,0,0é menor em dois bytes.

A caneta deve se afastar de qualquer ponto no final, pois, caso contrário, a caneta cinza / branca oculta o ponto.

A grade é atravessada usando um div ( /) e mod ( %) ida partir de 8( ié inicializado para 9, mas é diminuída no início do whileciclo) e trabalhar até 0, compensando os resultados 2,1,0de -1,0,1usar (1-...)e escalar cada um até o tamanho da grade usando um fator 20 (observe que 20-i/3*20na verdade é um byte menor que 20*(1-i/3), o mesmo vale para %). Isso produz a ordem [inferior esquerdo, central esquerdo, superior esquerdo, inferior central, centro médio, superior médio, inferior direito, centro direito, superior direito] e requer uma " hasDot" avaliação de [1,0,0,1,0,1,1,1,0], que é 302em binário assim pode ser acedida através da inspecção do i^th potência de dois componente de302com o uso de um bit a bit - e 302&2**i,.

Applesoft BASIC , 479 476 516 515 483 482 bytes

^{-32 usando nomes de variáveis ​​ilegíveis: P
-1 porque a Apple decidiu ser mágica e deixe-me usar um GOTO implícito / inexistente}

Aqui está o meu próprio programa (muito atualizável) para um exemplo de saída que não usa círculos:

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

Resultado:

Código de máquina IA-32, 81 80 bytes

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

É uma fastcallfunção chamada doitque retorna a imagem no formato PGM no buffer fornecido. Uso:

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

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

Resultado:

Usei a resolução 256x256 porque é legal, pois permite dividir o índice do pixel ecxautomaticamente em coordenadas ydentro che xdentro cl. Além disso, o formato de arquivo PGM requer o número 255 no cabeçalho da imagem.

Os quadrados internos são 54x54 (41% da célula por área).

Código fonte (pode ser compilado pelo 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;

O padrão celular

0 1 0
0 0 1
1 1 1

pode ser representado por um bitmap "otimizado" de 7 bits.

Os bits são indexados pela expressão y * 2 + x, onde (x,y)é o local da célula. Essa expressão fornece o mesmo índice para 2 pares de células. É uma coincidência de sorte que os valores de bits sejam os mesmos.

HTML e CSS, 155 bytes

Acontece que o HTML realmente perdoa os erros de sintaxe.

_{1 byte salvo graças a @Octopus · 1 byte salvo graças a @Downgoat · 2 bytes salvos graças a @StephenS}

_{2 bytes salvos graças a @Ryan · 3 bytes salvos graças a @styfle · 4 bytes salvos graças a @Ferrybig}

_{13 bytes salvos graças a @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 bytes)

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 bytes

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

Esta é minha primeira tentativa aqui no código golf, por isso tenho certeza de que isso pode ser melhorado. Eu gostaria de não estabelecer os limites, mas parece que o matplotlib não consegue detectar que plotei círculos onde fiz. Sem definir xlim () e ylim (), ele mostra apenas os dois círculos inferiores.

Resultado:

Editar: corrigiu a cor das bordas e removeu os números dos carrapatos. Devo dizer que o matplotlib é muito denso e não muito amigável com a alteração das cores dos eixos.

Raspou 3 bytes graças a @DJMcMayhem

Edit: Retirou dois bytes, definindo meus ticks como uma tupla dentro das funções set_ticks.

Bash + ImageMagick, 233 226 caracteres

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:

Saída de amostra:

Bash + ImageMagick, 215 caracteres

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:

O proprietário da pergunta ainda não respondeu à pergunta de anti-aliasing e algumas outras soluções também têm tons de cinza adicionais adicionados pelo anti-aliasing; portanto, por enquanto, essa mais curta também parece aceitável.

Saída de amostra:

Ruby, 144 166 164 148 144 bytes

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

Resultado:

Edit: Agora tem linhas de grade cinza.

PNG, 105 100 bytes

   (ou seja, este arquivo de imagem)

Considerando que HTML e outras linguagens que não são de programação são permitidas , fiquei curioso para ver o quanto eu poderia jogar uma imagem simples exibida pelo navegador para servir como uma comparação de linha de base. O resultado é compactado com as ferramentas de código aberto optipng ( -o7 -zm1-9 -strip all) e pngwolf . Eu também experimentei o zopflipng , mas os resultados foram maiores. Outras ferramentas de compactação de código fechado podem ser capazes de economizar mais alguns bytes.

Dados da imagem em base64:

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

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

Editar Fiz os pontos tocarem a parte superior e inferior da célula, para causar mais repetitividade no padrão de pixels e, assim, melhorar a taxa de compressão. Mas não se preocupe, um ponto ainda preenche (7 * 9) / (9 * 9) ~ 78% de sua célula.

PNG não padrão, 88 bytes

Como apontado por @anatolyg , existe algum potencial de golfe removendo o bloco IEND (12 bytes). Tecnicamente, o IEND é exigido pelo padrão . No entanto, cada pedaço PNG inclui seu próprio tamanho e informações de soma de verificação. Portanto, não é absolutamente necessário ter um marcador final. E, de fato, todos os navegadores que testei podem exibir a imagem sem problemas.

Infelizmente (ou felizmente), essa imagem fora do padrão é rejeitada pelo imgur, então não posso carregá-la. Esta é a codificação base64:

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

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

Oitava , 127 124 bytes

Removidos 3 bytes graças a Luis. gridé suficiente (em vez 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

Saídas (após salvar):

Observe que a saída mostra linhas de grade cinza na janela de plotagem. Eles ficam pretos ao salvá-lo (por algum motivo).

Bem, isso foi longo e confuso! Tive que passar por muitas modificações para fazer com que isso aderisse às especificações.

Explicação e espero que algum golfe esteja chegando ...

Processando, 212 198 bytes

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

Basicamente, estamos usando o Processamento simples para desenhar um plano de fundo branco, definindo a transparência dos retângulos usados ​​para a grade e desenhando seus traços em cinza. Continuamos definindo o retângulo, definindo o valor de preenchimento novamente para preencher os círculos em preto e definindo cinco círculos.

Voilà!

Você poderia adicionar

strokeWidth(2); 

ou mais para ver melhor a cor dos traços.

(Esse é o meu primeiro Code-Golf, espero que tenha feito tudo certo.)

EDIT: Obrigado a Kritixi Lithos! Removidas as novas linhas, alteradas para int f = 25 e usadas -1 em segundo plano (float)

Tikz, 193 175 170 bytes

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

Aqui está a saída:

MATL , 74 69 68 64 62 bytes

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

Experimente no MATL Online! (Demora alguns segundos.)

Saída do intérprete online:

Processando, 134 bytes

Inspirado pelo @Zep, aqui está o meu one-liner de processamento (e também o meu primeiro código de golfe):

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

Obrigado por @Kritixi Lithos por suas dicas brilhantes sobre como poupar alguns bytes!

LaTeX + Tikz, 155 bytes

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

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, que está no bloco "Área de uso particular") é o código de caractere para um símbolo de círculo. Colocá-lo em uma string também funcionaria, mas como é codificado como 3 bytes em UTF-8, ele teria o mesmo comprimento (e não aparecerá corretamente aqui).

C #, 333 bytes

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

Versão completa / formatada:

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

A idéia é simples: criamos um objeto gráfico a partir da imagem e usamos isso para deixar a imagem toda branca. Em seguida, faça um loop sobre cada quadrado da imagem desenhando o retângulo delimitador. Se é um dos locais para um ponto, também o desenhamos. Por fim, salvamos a imagem em um arquivo e deixamos que o Windows decida como abri-la. No meu caso, ela é aberta com o Windows Photo Viewer.

Usar a Processpara mostrar a imagem e salvar no arquivo é muito mais curto do que criar formulários do Windows ou aplicativo WPF, devido a todas as diferentes classes e cotas extras necessárias para criá-las.

Resultado:

PHP, 221 + 2 bytes

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

Salvar em arquivo; chamar no navegador. Se o seu navegador exibir sem sentido,
insira header("Content-Type:image-png");antes imagepng($i);.

Os pontos não são muito redondos; isso é devido às pequenas proporções.

demolir

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

Eu acho que se 0x4c4b40qualifica como cinza aproximado. Caso contrário, adicione quatro bytes.

R 313 236 bytes

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

O Código revisado, baseado principalmente nos comentários de @ user2390246, salvou 77 bytes. Aprecio muito a ajuda.

Além disso, deseja adicionar uma chamada à solução R mais curta por @mschilli. Ele mostra uma maneira elegante de abordar o problema dos padrões gráficos do R.

Resultado

Vai para um nome de arquivo "r". Omitir e extensão me salvou quatro bytes. Mas então eu tive que editar a extensão do arquivo de volta para "bmp" para fazer o upload. Então talvez eu não deva receber crédito por esses quatro bytes.

Comentário

Pensei comigo mesmo: "Esse gráfico não passa de um gráfico simples com cinco pontos. Deve ser uma questão simples de implementar em uma linguagem com recursos robustos de gráficos de dados. Vamos tentar em R." Mas então eu tive que gastar na ordem de 80% dos bytes apenas trabalhando em torno dos padrões gráficos de R.

Meio que a ferramenta errada para o trabalho ....

Não consegui encontrar uma maneira menos detalhada de garantir o tamanho e a proporção do gráfico do que chamar o construtor bmp e depois dev.off (). A combinação representa 25 bytes. Se sua sessão R estiver configurada corretamente, você poderá obter um gráfico mais ou menos correto sem gastar esses bytes, mas não é confiável ou consistente.

TI-BASIC, 218 140 137 bytes

Nota: essa contagem de bytes é um pouco inflada. O programa usa apenas 85 tokens, mas isso é salvo em 137 bytes. Além disso, se você estiver usando uma calculadora que não seja de cores, poderá salvar outros 4 tokens, porque não precisa especificar a cor (que é azul por padrão), mas não sei se as telas deles são grandes o suficiente para esse desafio porque eu não possuo um.

prgmHACKER (138 bytes, 86 tokens):

{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

Para uma exibição adequada, este programa requer que Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. O dX também precise ser definido corretamente, mas a calculadora fará isso quando você definir qualquer outra variável da janela. Eu não conseguia ver quanto espaço essas variáveis ​​usavam na RAM.

Além disso, as configurações de formato devem ser {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Eixos: OFF, ExprOff, BorderColor: 1, Background: OFF}, mas esses são valores alternados e não consomem espaço extra, dependendo da configuração.

R, 119 114 111 bytes

( Agradecimentos a @JayCe por me salvar 3 bytes)

Não é mais curto que a outra solução R , mas uma abordagem completamente diferente:

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

Usa um layout no qual as 4 primeiras plotagens são as células vazias e as 5 outras são aquelas com pontos.

Excel VBA, 180 bytes

Uma função de janela Imediata VBE anônima que não recebe nenhuma entrada e sai para o objeto de planilha padrão ( 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

Versão Comentada

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

Resultado

-6 bytes para usar [{21,32,13,23,33}]sobreSplit("21 32 13 23 33")

-2 bytes para usar Mid(s,2)sobreRight(s,1)

-3 bytes para usar (s\10)sobreLeft(s,1)

Oitava 107 94 103 bytes

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

ambas as soluções são 103 bytes.

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

Desenhei a forma inteiramente usando o Quartz para um dispositivo Apple iOS. Infelizmente, essa não é uma linguagem atenta ao tamanho, de modo que o resultado é bastante grande, mas é o menor possível.

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

Uma versão mais legível para qualquer pessoa interessada:

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

Aqui está a saída produzida no iOS Simulator:

Rubi com sapatos, 118 caracteres

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 verificação emprestado de RJHunter 's comentário feito sobre Mark Thomas ' s solução rubi .

Saída de amostra:

SVG + HTML, 146 138 135 133 bytes

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

Graças ao analisador de HTML branda, a xmlns="http://www.w3.org/2000/svg"declaração pode ser omitida, além de aspas de atributo e a tag de fechamento. Esta versão aborda alguns problemas de outras soluções HTML:

• Um "ponto" é garantido para preencher pelo menos 40% de sua célula (§1)
• Não utiliza gráficos externos, por exemplo, glifos de fontes (§2, §6)
• A grade é perfeitamente quadrada (§5)

Editar Raspado em 8 bytes, explorando o fato de que os subcaminhos não precisam ser fechados para serem preenchidos .

Editar De acordo com a gramática svg , não é necessário separar os não dígitos com uma vírgula ( .5,.5). Também abandonei o preenchimento explícito, para poder alterar a direção do desenho de uma linha de negativa para positiva, salvando um traço. Por fim, ajustei a contagem para não incluir uma nova linha à direita, desculpe por esse erro de novato.

Editar Aprendendo com outra resposta sobre codegolf, substituí a final 9 />por 9>. Isso funciona bem em todos os navegadores testados.

Python 3 + PyGame, 238 bytes

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

As constantes aparentemente arbitrárias são minhas tentando fazer a imagem o maior possível, sem sacrificar bytes.

Com caracteres não imprimíveis, 229 bytes

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

Substituí as listas por literais de bytes, o que economiza vários caracteres, mas os caracteres não imprimíveis não podem ser exibidos corretamente aqui. Substituí os caracteres não imprimíveis pelos seus equivalentes gráficos U + 2400-U + 2421 para fins de exibição.