Es posible que haya oído hablar del "Logotipo de Hacker", también llamado "Emblema de Hacker". Se parece a esto:

Este es un patrón de una simulación matemática llamada Juego de la vida. El planeador es el patrón de vida más simple que se mueve y el más instantáneamente reconocible de todos los patrones de vida.

El reto

El desafío es bastante simple: mostrar el logotipo del hacker. Esto se define como:

• Una cuadrícula de 3x3 con un borde, un fondo blanco y grillas grises.
• Cinco puntos negros dispuestos en el patrón de planeador GoL.
• Nada más.

Las normas

• Los puntos negros deben llenar 40% - 80% de sus cuadros de cuadrícula individuales.
• Mostrará el emblema con salida gráfica pero sin arte ASCII .
• La salida debe ser de al menos 30x30 píxeles .
• La salida solo debe tener los colores gris, blanco y negro .
• Cada cuadro de cuadrícula en la cuadrícula será del mismo tamaño. La cuadrícula será un cuadrado normal de 3x3 .
• No puede extraer el logotipo de Internet o de su sistema de archivos.
• Su programa mostrará el logotipo en una pantalla / ventana vacía. Si termina, debe hacerlo normalmente.
• Tenga en cuenta que "puntos" no significa necesariamente "círculos". Un "punto" es una forma geométrica única centrada en el centro de la cuadrícula con una superficie. Por ejemplo, mientras que un círculo o cuadrado calificará como un punto, dos triángulos o un tablero no lo harán.

El ganador

Como se trata de código de golf , ¡la respuesta más corta en cada idioma gana!

Incluya una captura de pantalla de la salida de su programa en su respuesta.

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

Se guardaron 4 bytes al incorporar sugerencias de los comentarios.

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

Utiliza el carácter UTF-8 •que tiene 2 bytes de longitud y aprovecha la gracia de la sintaxis HTML.

GLSL (sombreador de fragmentos), 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.);}

Véalo en acción: 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)

Tamaño real, 61 por 61, trazado dentro de un lienzo mucho más grande de 300 por 400:

Mostrando la cuadrícula de píxeles:

Los puntos usan 177 píxeles dentro del rango de 40% -80% si se considera el relleno blanco de 19 por 19 (144.4-288.8) o el 21 por 21, incluidos ambos bordes (176.4-352.8).

Nota: el programa finaliza y cierra la ventana del lienzo tan pronto como el dibujo ha finalizado, para permitir el cierre manual de la ventana, agregue la línea done().

turtlees un paquete de Python desarrollado para la programación gráfica introductoria. Un bolígrafo comienza x,y=0,0en el medio de un lienzo de 300 por 400 píxeles (por defecto), uplevanta el bolígrafo, gotomueve el bolígrafo, shapeestablece la forma del bolígrafo en una forma con nombre ( "square"es una forma predefinida con un ancho de píxel predeterminado de 21 ), colorestablece el color, donde dos parámetros establecen el trazo (con un ancho predeterminado de 1) y el relleno; un byte se guarda utilizando la (r,g,b)opción de sustituir tupla "white"con [1,1,1]el uso de la lista de multiplicación [1]*3. Finalmente dotdibuja un punto con el ancho dado en píxeles y color. El valor de ancho predeterminado del punto es demasiado pequeño para calificar, por 9lo que lo convertí en una estética y calificación 15. El color del punto podría ser"black"pero la (r,g,b)tupla desempaquetada de 0,0,0es más corta en dos bytes.

El lápiz debe alejarse de cualquier punto al final, ya que de lo contrario el lápiz gris / blanco oculta el punto.

La rejilla está atravesada usando un div ( /) y mod ( %) de ia partir de 8( ise inicializa a 9pero se decrementa en el comienzo de la whilecircular) y trabajando hacia abajo para 0, compensando los resultados de 2,1,0a -1,0,1usar (1-...)y escalar cada hasta el tamaño de la cuadrícula usando un factor de 20 (tenga en cuenta que en 20-i/3*20realidad es un byte menor que 20*(1-i/3), lo mismo ocurre %). Esto produce el orden [abajo-izquierda, centro-izquierda, arriba-izquierda, abajo-medio, centro-medio, arriba-medio, abajo-derecha, centro-derecha, arriba-derecha], y requiere una " hasDot" evaluación de [1,0,0,1,0,1,1,1,0], que está 302en binario, por lo que se puede acceder inspeccionando la potencia i^th de dos componentes de302con el uso de un bit a bit-y, 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 bytes

^{-32 mediante el uso de nombres de variables ilegibles: P
-1 porque Apple decidió ser mágico y me dejó usar un GOTO implícito / inexistente}

Aquí está mi propio programa (muy superable) para un ejemplo de una salida que no 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

Salida:

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

Es una fastcallfunción llamada doitque devuelve la imagen en formato PGM en el búfer suministrado. Uso:

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

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

Salida:

Utilicé una resolución de 256x256 porque es genial , me permite dividir el índice de píxeles ecxautomáticamente en coordenadas yadentro chy xadentro cl. Además, el formato de archivo PGM requiere el número 255 en el encabezado de la imagen.

Los cuadrados internos son 54x54 (41% de la celda por área).

Código fuente (puede ser compilado por 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;

El patrón celular

0 1 0
0 0 1
1 1 1

puede ser representado por un mapa de bits "optimizado" de 7 bits.

Los bits están indexados por la expresión y * 2 + x, donde (x,y)es la ubicación de la celda. Esta expresión da el mismo índice a 2 pares de células. Es una coincidencia afortunada que los valores de bits sean los mismos.

HTML y CSS, 155 bytes

Resulta que HTML realmente perdona los errores de sintaxis.

_{1 byte guardado gracias a @Octopus · 1 byte guardado gracias a @Downgoat · 2 bytes guardados gracias a @StephenS}

_{2 bytes guardados gracias a @Ryan · 3 bytes guardados gracias a @styfle · 4 bytes guardados gracias a @Ferrybig}

_{13 bytes guardados gracias 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()

Este es mi primer intento aquí en el código de golf, así que estoy seguro de que esto se puede mejorar. Me hubiera gustado no establecer los límites, pero parece que matplotlib no puede detectar que tracé círculos donde lo hice. Sin establecer xlim () e ylim () solo muestra los dos círculos inferiores.

Salida:

Editar: se corrigió el color de los bordes y se eliminaron los números de marca. Debo decir que matplotlib está muy densamente redactado, y no es muy amigable con los colores cambiantes del eje.

Afeitado 3 bytes gracias a @DJMcMayhem

Editar: eliminé dos bytes configurando mis ticks como una tupla dentro de las funciones 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:

Salida de muestra:

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:

El propietario de la pregunta aún no ha respondido la pregunta de suavizado y algunas otras soluciones también tienen sombras grises adicionales agregadas por el suavizado, por lo que por ahora esta más corta también parece aceptable.

Salida de muestra:

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

Salida:

Editar: ahora tiene grillas grises.

PNG, 105100 bytes

   (es decir, este archivo de imagen)

Teniendo en cuenta que el HTML y otros lenguajes que no son de programación están permitidos , tenía curiosidad por ver cuánto podía jugar una imagen simple visualizable en el navegador, para servir como una comparación de referencia. El resultado se comprime con las herramientas de código abierto optipng ( -o7 -zm1-9 -strip all) y pngwolf . También experimenté con zopflipng , pero los resultados fueron mayores. Es posible que otras herramientas de compresión de código cerrado puedan reducir un par de bytes más.

Datos de imagen en base64:

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

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

Editar Hice que los puntos toquen la parte superior e inferior de la celda, para causar más repetitividad en el patrón de píxeles y mejorar así la relación de compresión. Pero no se preocupe, un punto todavía solo llena (7 * 9) / (9 * 9) ≈ 78% de su celda.

PNG no estándar, 88 bytes

Como señaló @anatolyg , existe un potencial de golf al eliminar el fragmento IEND (12 bytes). Técnicamente, IEND es requerido por el estándar . Sin embargo, cada fragmento PNG incluye su propio tamaño e información de suma de verificación. Por lo tanto, no es absolutamente necesario tener un marcador final. Y, de hecho, todos los navegadores que probé pueden mostrar la imagen sin problemas.

Desafortunadamente (o afortunadamente), imgur rechaza esta imagen no estándar, por lo que no puedo subirla. Esta es la codificación base64:

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

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

Octava , 127124 bytes

Eliminado 3 bytes gracias a Luis. grides suficiente (en lugar 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

Salidas (después de guardar):

Tenga en cuenta que la salida muestra líneas de cuadrícula grises en la ventana de trazado. Se vuelven negros al guardarlo (por alguna razón).

Bueno, eso fue largo y desordenado! Tuve que pasar por muchas modificaciones para que esto se adhiera a las especificaciones.

Explicación y, con suerte, algo de golf ...

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

Básicamente, estamos usando un procesamiento simple para dibujar un fondo blanco, luego configuramos la transparencia de los rectángulos utilizados para la cuadrícula y dibujamos sus trazos en gris. Continuamos definiendo el rectángulo, configurando el valor de relleno nuevamente para llenar los círculos de negro y definiendo cinco círculos.

Voilà!

Podrías agregar

strokeWidth(2); 

o más para ver mejor el color de los trazos.

(Ese es mi primer Code-Golf, espero haber hecho todo bien).

EDITAR: ¡Gracias a Kritixi Lithos! Se eliminaron las líneas nuevas, se cambió a int f = 25 y se usó -1 en segundo plano (flotante)

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}

Aquí está la salida:

MATL , 74 69 68 64 62 bytes

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

¡Pruébalo en MATL Online! (Toma unos segundos)

Salida del intérprete en línea:

Procesamiento, 134 bytes

Inspirado por @Zep, aquí está mi línea de procesamiento (y también mi primer código de 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);}};

¡Gracias por @Kritixi Lithos por sus brillantes consejos para reducir algunos 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 se encuentra en el bloque "Área de uso privado") es el código de caracteres para un símbolo circular. Ponerlo en una cadena también funcionaría, pero como está codificado como 3 bytes en UTF-8, tendría la misma longitud (y no se mostrará correctamente aquí).

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

Versión completa / formateada:

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

La idea es simple: creamos un objeto gráfico a partir de la imagen y lo usamos para hacer que la imagen sea completamente blanca. Luego recorra cada cuadrado de la imagen dibujando el rectángulo delimitador. Si es una de las ubicaciones para un punto, también lo dibujamos. Por último, guardamos la imagen en un archivo y dejamos que Windows decida cómo abrirla, en mi caso se abre con Windows Photo Viewer.

Usar un Processpara mostrar la imagen y guardarlo en un archivo es mucho más corto que crear formularios de Windows o una aplicación WPF debido a todas las clases diferentes y la pelusa adicional necesaria para crearlos.

Salida:

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

Guardar en archivo; Llamar en el navegador. Si su navegador muestra galimatías,
insértelo header("Content-Type:image-png");antes imagepng($i);.

Los puntos no son muy redondos; eso se debe a las pequeñas proporciones.

Descompostura

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

Creo que eso 0x4c4b40califica como gris aproximado. Si no, agregue cuatro 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()

El Código revisado, basado principalmente en los comentarios de @ user2390246, guardó 77 bytes. Agradezco mucho la ayuda.

Además, desea agregar una llamada a la solución R más corta de @mschilli. Muestra una forma elegante de abordar el problema de los valores predeterminados gráficos R.

Salida

Va a un nombre de archivo "r". La omisión y la extensión me ahorraron cuatro bytes. Pero luego tuve que editar la extensión del archivo nuevamente a "bmp" para que se cargara. Entonces quizás no debería obtener crédito por esos cuatro bytes.

Comentario

Pensé para mí mismo: "Ese gráfico no es más que un gráfico simple con cinco puntos. Debería ser un asunto simple de implementar en un lenguaje con capacidades gráficas de datos robustas. Probémoslo en R." Pero luego tuve que gastar en el orden del 80% de los bytes simplemente trabajando alrededor de los valores predeterminados gráficos de R.

Un poco la herramienta incorrecta para el trabajo ...

No pude encontrar una forma menos detallada de garantizar el tamaño y la relación de aspecto del gráfico que llamando al constructor bmp y luego dev.off (). La combinación representa 25 bytes. Si su sesión R está configurada correctamente, es posible que obtenga un gráfico que se vea más o menos correcto sin gastar esos bytes, pero no es confiable ni consistente.

TI-BASIC, 218 140 137 bytes

Nota: este recuento de bytes está un poco inflado. El programa solo usa 85 tokens, pero eso se guarda en 137 bytes. Además, si está usando una calculadora sin color, podría guardar otros 4 tokens porque no tiene que especificar el color (que es azul de forma predeterminada), pero no sé si sus pantallas son lo suficientemente grandes para este desafío porque no tengo uno.

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 una visualización adecuada, este programa requiere que Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX también debe configurarse correctamente, pero la calculadora lo hace por usted cuando configura cualquier otra variable de ventana. No podía ver cuánto espacio usaban estas variables en la RAM.

Además, la configuración del formato debe ser {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF} pero estos son valores alternados y no consumen espacio adicional dependiendo de la configuración.

R, 119 114 111 bytes

(Gracias a @JayCe por guardarme 3 bytes)

No más corto que la otra solución R , sino un enfoque 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)}

Utiliza un diseño en el que las 4 primeras parcelas son las celdas vacías, y las otras 5 son las que tienen puntos en ellas.

Excel VBA, 180 bytes

Una función de ventana VBE inmediata anónima que no toma entradas y salidas al objeto predeterminado de la hoja de trabajo ( 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

Versión 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

Salida

-6 bytes para usar [{21,32,13,23,33}]más deSplit("21 32 13 23 33")

-2 bytes para usar Mid(s,2)más deRight(s,1)

-3 bytes para usar (s\10)más deLeft(s,1)

Octave 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

o

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 soluciones son 103 bytes.

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

Dibujé la forma completamente usando Quartz para un dispositivo Apple iOS. Desafortunadamente, este no es un lenguaje consciente de tamaño particular, por lo que el resultado es bastante grande, pero es lo más pequeño que puedo obtener.

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

Una versión más legible para cualquiera que esté interesado:

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

Aquí está la salida producida en el simulador de iOS:

Ruby with Shoes, 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 comprobación tomado de RJHunter 's comentario hecho sobre Mark Thomas ' s solución de Rubí .

Salida de muestra:

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>

Gracias al analizador HTML indulgente, xmlns="http://www.w3.org/2000/svg"se puede omitir la declaración, así como las comillas de atributos y la etiqueta de cierre. Esta versión aborda algunos problemas de otras soluciones HTML:

• Se garantiza que un "punto" llene al menos el 40% de su celda (§1)
• No utiliza gráficos externos, por ejemplo, glifos de fuente (§2, §6)
• La cuadrícula es perfectamente cuadrada (§5)

Editar Eliminó 8 bytes explotando el hecho de que las subrutas no necesitan cerrarse para rellenarse .

Editar Según la gramática svg , no es necesario separar los no dígitos con una coma ( .5,.5). También abandoné el relleno explícito, para poder cambiar la dirección de dibujo de una línea de negativa a positiva, guardando un guión. Y por último, ajusté el conteo para no incluir una nueva línea final, perdón por este error de novato.

Editar Aprendiendo de otra respuesta en codegolf, he reemplazado la final 9 />con9> . Esto funciona bien en todos los navegadores probados.

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

Las constantes aparentemente arbitrarias son de mí tratando de hacer que la imagen sea lo más grande posible sin sacrificar bytes.

Con caracteres que no se imprimen, 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()

Reemplacé las listas con literales de bytes, lo que ahorra un montón de caracteres, pero los caracteres que no se imprimen no se pueden mostrar correctamente aquí. Sustituí los caracteres que no se imprimen con sus equivalentes gráficos U + 2400-U + 2421 para fines de visualización.