Potresti aver sentito parlare del "Logo Hacker", chiamato anche "Emblema Hacker". Sembra così:

Questo è uno schema di una simulazione matematica chiamata Game of Life. L'aliante è il modello di vita più semplice che si muove e il più immediatamente riconoscibile di tutti i modelli di vita.

La sfida

La sfida è piuttosto semplice: mostra il logo degli hacker. Questo è definito come:

• Una griglia 3x3 con un bordo, uno sfondo bianco e linee grigie grigie.
• Cinque punti neri disposti nel modello dell'aliante GoL.
• Nient'altro.

Le regole

• I punti neri devono riempire il 40% - 80% delle singole caselle della griglia.
• Visualizzerai l'emblema con un output grafico ma nessuna arte ASCII .
• L'output deve essere di almeno 30x30 pixel .
• L'output deve avere solo i colori grigio, bianco e nero .
• Ogni riquadro della griglia avrà le stesse dimensioni. La griglia sarà un normale quadrato 3x3 .
• Non è possibile estrarre il logo da Internet o dal proprio filesystem.
• Il programma visualizzerà il logo su una schermata / finestra vuota. Se termina, deve farlo normalmente.
• Nota che "punti" non significa necessariamente "cerchi". Un "punto" è una singola forma geometrica centrata al centro della griglia con una superficie. Ad esempio, mentre un cerchio o un quadrato si qualificheranno come punto, due triangoli o una scacchiera no.

Il vincitore

Poiché si tratta di code-golf , vince la risposta più breve in ogni lingua!

Includi uno screenshot dell'output del tuo programma nella tua risposta.

Mathematica, 62 byte

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

Mathematica, 71 byte

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

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

Salvato 4 byte incorporando suggerimenti dai commenti.

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

Questo utilizza il carattere UTF-8 •che è lungo 2 byte e sfrutta la gentilezza della sintassi HTML.

GLSL (framment shader), 278 235 256 byte

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

Guardalo in azione: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 byte

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)

Dimensione reale, 61 per 61, tracciata in una tela molto più grande di 300 per 400:

Mostra la griglia dei pixel:

I punti utilizzano 177 pixel nell'intervallo tra il 40% e l'80%, considerando il riempimento bianco 19 per 19 (144,4-288,8) o il 21 per 21 compresi entrambi i bordi (176,4-352,8).

Nota: il programma termina e chiude la finestra dell'area di disegno non appena il disegno è terminato, per consentire la chiusura manuale della finestra aggiungere la linea done().

turtleè un pacchetto Python sviluppato per la programmazione grafica introduttiva. Una penna inizia x,y=0,0nel mezzo di una tela di 300 x 400 pixel (per impostazione predefinita), upsolleva la penna, gotosposta la penna, shapeimposta la forma della penna su una forma denominata ( "square"è una forma predefinita con una larghezza di pixel predefinita di 21 ), colorimposta il colore, in cui due parametri impostano il tratto (con una larghezza predefinita di 1) e riempiono; un byte viene salvato utilizzando l' (r,g,b)opzione tupla per sostituirla "white"con [1,1,1]la moltiplicazione dell'elenco [1]*3. Infine dotdisegna un punto con la larghezza data in pixel e colore. Il valore di larghezza predefinito del punto è troppo piccolo per essere qualificato, così come l' 9ho reso estetico e qualificante 15. Il colore del punto potrebbe essere"black"ma la (r,g,b)tupla decompressa di 0,0,0è più corta di due byte.

La penna deve allontanarsi da qualsiasi punto all'estremità poiché altrimenti la penna grigia / bianca nasconde il punto.

La griglia viene attraversata con un div ( /) e mod ( %) di ia partire da 8( iviene inizializzato a 9ma viene decrementato all'inizio del whileciclo) e lavorando verso 0, compensando i risultati 2,1,0per -1,0,1usare (1-...)e scaling ciascuno fino alla dimensione griglia utilizzando un fattore 20 (si noti che in 20-i/3*20realtà è un byte inferiore a 20*(1-i/3), lo stesso vale per %). Questo produce l'ordine [in basso a sinistra, al centro-a sinistra, in alto a sinistra, in basso a metà, al centro-centrale, in alto a metà, in basso a destra, al centro-a destra, in alto a destra] e richiede una " hasDot" valutazione di [1,0,0,1,0,1,1,1,0], che è 302in modo binario sia raggiungibile controllando la i^esima potenza di due componenti di302con l'utilizzo di un bit per bit e 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 byte

^{-32 usando nomi di variabili illeggibili: P
-1 perché Apple ha deciso di essere magica e di farmi usare un GOTO implicito / inesistente}

Ecco il mio programma (molto battibile) per un esempio di output che non usa i cerchi:

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

Produzione:

Codice macchina IA-32, 81 80 byte

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

È una fastcallfunzione chiamata doitche restituisce l'immagine in formato PGM nel buffer fornito. Uso:

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

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

Produzione:

Ho usato una risoluzione di 256x256 perché è interessante e mi consente di dividere ecxautomaticamente l'indice del pixel in coordinate yin che xin cl. Inoltre, il formato del file PGM richiede il numero 255 nell'intestazione dell'immagine.

I quadrati interni sono 54x54 (41% della cella per area).

Codice sorgente (può essere compilato da 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;

Il modello cellulare

0 1 0
0 0 1
1 1 1

può essere rappresentato da una bitmap "ottimizzata" di 7 bit.

I bit sono indicizzati dall'espressione y * 2 + x, dove si (x,y)trova la posizione della cella. Questa espressione fornisce lo stesso indice a 2 coppie di celle. È una coincidenza fortunata che i valori dei bit siano gli stessi.

HTML e CSS, 155 byte

Si scopre che l'HTML perdona davvero gli errori di sintassi.

_{1 byte salvato grazie a @Octopus · 1 byte salvato grazie a @Downgoat · 2 byte salvati grazie a @StephenS}

_{2 byte salvati grazie a @Ryan · 3 byte salvati grazie a @styfle · 4 byte salvati grazie a @Ferrybig}

_{13 byte salvati grazie 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 byte)

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 byte

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

Questo è il mio primo tentativo qui a code golf, quindi sono sicuro che questo può essere migliorato. Mi sarebbe piaciuto non stabilire i limiti, ma sembra che matplotlib non riesca a rilevare che ho tracciato dei cerchi dove l'ho fatto. Senza impostare xlim () e ylim () mostra solo i due cerchi inferiori.

Produzione:

Modifica: risolto il colore dei bordi e rimosso i numeri di spunta. Devo dire che matplotlib è formulato in modo molto denso e non troppo amichevole con il cambio dei colori degli assi.

Rimozione di 3 byte grazie a @DJMcMayhem

Modifica: ha tolto due byte impostando i miei tick come una tupla all'interno delle funzioni set_ticks.

Bash + ImageMagick, 233 226 caratteri

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:

Uscita campione:

Bash + ImageMagick, 215 caratteri

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:

Il proprietario della domanda non ha ancora risposto alla domanda sull'antialiasing e alcune altre soluzioni hanno anche sfumature di grigio aggiuntive aggiunte dall'antialiasing, quindi per ora questa più corta sembra accettabile.

Uscita campione:

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

Produzione:

Modifica: ora ha griglie grigie.

PNG, 105 100 byte

   (ovvero questo file immagine)

Considerando che l'HTML e altri linguaggi non di programmazione sono consentiti , ero curioso di vedere quanto potevo giocare a golf con una semplice immagine visualizzabile da browser, per fungere da confronto di base. Il risultato è compresso con gli strumenti open source optipng ( -o7 -zm1-9 -strip all) e pngwolf . Ho anche sperimentato zopflipng , ma i risultati sono stati più grandi. Altri strumenti di compressione a sorgente chiuso potrebbero essere in grado di radere via un altro paio di byte.

Dati immagine in base64:

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

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

Modifica Ho fatto toccare i punti nella parte superiore e inferiore della cella, per causare una maggiore ripetitività nel modello di pixel e quindi migliorare il rapporto di compressione. Ma non preoccuparti, un punto riempie solo (7 * 9) / (9 * 9) ≈ 78% della sua cella.

PNG non standard, 88 byte

Come sottolineato da @anatolyg , esiste un potenziale di golf rimuovendo il blocco IEND (12 byte). Tecnicamente, IEND è richiesto dallo standard . Tuttavia, ogni blocco PNG include le sue dimensioni e le informazioni di checksum. Pertanto, non è assolutamente necessario disporre di un marcatore finale. E infatti, tutti i browser che ho testato possono visualizzare l'immagine senza problemi.

Sfortunatamente (o per fortuna), questa immagine non standard è stata rifiutata da imgur, quindi non posso effettivamente caricarla. Questa è la codifica base64:

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

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

Ottava , 127 124 byte

Rimossi 3 byte grazie a Luis. gridè sufficiente (invece di 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

Uscite (dopo il salvataggio):

Si noti che l'output mostra le linee della griglia grigia nella finestra del diagramma. Diventano neri quando lo salvano (per qualche motivo).

Bene, è stato lungo e disordinato! Ho dovuto subire molte modifiche per renderlo conforme alle specifiche.

Spiegazione e, si spera, un po 'di golf in arrivo ...

Elaborazione, 212 198 byte

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

Fondamentalmente, stiamo usando la semplice elaborazione per disegnare uno sfondo bianco, quindi impostando la trasparenza dei rettangoli utilizzati per la griglia e disegnando i loro tratti in grigio. Continuiamo definendo il rettangolo, impostando nuovamente il valore di riempimento per riempire i cerchi di nero e definendo i cerchi di cinque.

Ecco!

Potresti aggiungere

strokeWidth(2); 

o più per vedere meglio il colore dei tratti.

(Questo è il mio primo Code-Golf, spero di aver fatto tutto bene.)

EDIT: grazie a Kritixi Lithos! Rimosse le nuove righe, modificate in int f = 25 e utilizzate -1 in background (float)

Tikz, 193 175 170 byte

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

Ecco l'output:

MATL , 74 69 68 64 62 byte

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

Provalo su MATL Online! (Ci vogliono alcuni secondi.)

Uscita dall'interprete online:

Elaborazione, 134 byte

Ispirato da @Zep, ecco il mio One-liner di elaborazione (e anche il mio primo codice 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);}};

Grazie per @Kritixi Lithos per i suoi brillanti consigli sulla rasatura di qualche byte!

LaTeX + Tikz, 155 byte

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

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, che si trova nel blocco "Area uso privato") è il codice carattere per un simbolo circolare. Inserirlo in una stringa funzionerebbe anche, ma dal momento che è codificato come 3 byte in UTF-8, avrebbe la stessa lunghezza (e non verrà mostrato correttamente qui).

C #, 333 byte

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

Versione completa / formattata:

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'idea è semplice, creiamo un oggetto grafico dall'immagine e lo usiamo per rendere l'immagine tutta bianca. Quindi scorrere su ogni quadrato dell'immagine disegnando il rettangolo di delimitazione. Se è una delle posizioni per un punto, disegniamo anche quello. Infine salviamo l'immagine su file e lasciamo che Windows decida come aprirla, nel mio caso si apre con Windows Photo Viewer.

L'uso di a Processper mostrare l'immagine e il salvataggio su file è molto più breve della creazione di un'app Windows o di un'app WPF a causa di tutte le diverse classi e della lanugine aggiuntiva necessaria per crearle.

Produzione:

PHP, 221 + 2 byte

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

Salva su file; chiama nel browser. Se il tuo browser visualizza in modo incomprensibile,
inseriscilo header("Content-Type:image-png");prima imagepng($i);.

I punti non sono molto rotondi; ciò è dovuto alle piccole proporzioni.

abbattersi

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

Penso che si 0x4c4b40qualifichi come grigio approssimativo. In caso contrario, aggiungere quattro byte.

R 313 236 byte

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

Il codice rivisto, basato principalmente sui commenti di @ user2390246, ha salvato 77 byte. Apprezzo molto l'aiuto.

Inoltre, vuoi aggiungere un call-out alla soluzione R più breve di @mschilli. Mostra un modo elegante di affrontare il problema delle impostazioni predefinite grafiche di R.

Produzione

Va a un nome di file "r". L'omissione e l'estensione mi hanno salvato quattro byte. Ma poi ho dovuto modificare l'estensione del file in "bmp" per farlo caricare. Quindi forse non dovrei ottenere credito per quei quattro byte.

Commento

Ho pensato tra me e me: "Quella grafica non è altro che un semplice grafico con cinque punti. Dovrebbe essere una cosa semplice da implementare in un linguaggio con solide capacità di grafica dei dati. Proviamo in R." Ma poi ho dovuto spendere nell'ordine dell'80% dei byte solo aggirando i valori predefiniti grafici di R.

Kinda lo strumento sbagliato per il lavoro ....

Non sono riuscito a trovare un modo meno prolisso per garantire le dimensioni e le proporzioni del grafico che chiamando il costruttore bmp e poi dev.off (). La combinazione rappresenta 25 byte. Se la tua sessione R è impostata correttamente, potresti ottenere un grafico che sembra più o meno corretto senza spendere quei byte, ma non è affidabile o coerente.

TI-BASIC, 218 140 137 byte

Nota: questo conteggio dei byte è un po 'gonfiato. Il programma utilizza solo 85 token, ma è stato salvato in 137 byte. Inoltre, se stai usando una calcolatrice non a colori, potresti salvare altri 4 token perché non devi specificare il colore (che è blu per impostazione predefinita), ma non so se i loro schermi sono abbastanza grandi per questa sfida perché non ne possiedo una.

prgmHACKER (138 byte, 86 token):

{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

Per una corretta visualizzazione, questo programma richiede che Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX deve anche essere impostato correttamente, ma la calcolatrice lo fa per te quando si imposta un'altra variabile della finestra. Non riuscivo a vedere quanto spazio utilizzavano queste variabili nella RAM.

Inoltre, le impostazioni del formato dovrebbero essere {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF} ma questi sono valori attivati ​​e non consumano spazio extra a seconda dell'impostazione.

R, 119 114 111 byte

(Grazie a @JayCe per avermi salvato 3 byte)

Non più breve dell'altra soluzione R , ma un approccio completamente diverso:

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

Utilizza un layout in cui i primi 4 grafici sono le celle vuote e gli altri 5 quelli con punti.

Excel VBA, 180 byte

Una funzione finestra VBE immediata anonima che non accetta input e output sull'oggetto foglio di lavoro predefinito ( 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

Versione commentata

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

Produzione

-6 byte per l'utilizzo di [{21,32,13,23,33}]overSplit("21 32 13 23 33")

-2 byte per l'utilizzo di Mid(s,2)overRight(s,1)

-3 byte per l'utilizzo di (s\10)overLeft(s,1)

Ottava 107 94 103 byte

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

entrambe le soluzioni sono 103 byte.

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

Ho disegnato la forma interamente usando Quartz per un dispositivo Apple iOS. Sfortunatamente questo non è un linguaggio attento alle dimensioni, quindi il risultato è piuttosto grande, ma questo è il più piccolo possibile.

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 versione più leggibile per chiunque sia interessato:

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

Ecco l'output prodotto nel simulatore iOS:

Rubino con scarpe, 118 caratteri

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 checking preso in prestito da RJHunter 's commento fatto su Mark Thomas ' s soluzione di Ruby .

Uscita campione:

SVG + HTML, 146 138 135 133 byte

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

Grazie al parser HTML clemente, la xmlns="http://www.w3.org/2000/svg"dichiarazione può essere omessa, così come le virgolette degli attributi e il tag di chiusura. Questa versione risolve alcuni problemi di altre soluzioni HTML:

• Un "punto" è garantito per riempire almeno il 40% della sua cella (§1)
• Non utilizza grafica esterna, ad es. Glifi dei caratteri (§2, §6)
• La griglia è perfettamente quadrata (§5)

Modifica Rasato di 8 byte sfruttando il fatto che non è necessario chiudere i percorsi secondari per essere riempiti .

Modifica Secondo la grammatica svg , non è necessario separare le non cifre con una virgola ( .5,.5). Ho anche abbandonato il riempimento esplicito, in modo da poter cambiare la direzione di disegno di una linea da negativa a positiva, salvando un trattino. E, infine, ho modificato il conteggio per non includere una nuova riga finale, mi dispiace per questo errore da principiante.

Modifica Imparando da un'altra risposta su codegolf, ho sostituito il finale 9 />con 9>. Funziona bene in tutti i browser testati.

Python 3 + PyGame, 238 byte

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

Le costanti apparentemente arbitrarie provengono da me cercando di ingrandire l'immagine il più grande possibile senza sacrificare i byte.

Con caratteri non stampabili, 229 byte

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

Ho sostituito le liste con valori letterali in byte, il che salva un sacco di caratteri, ma i caratteri non stampabili non possono essere visualizzati correttamente qui. Ho sostituito i caratteri non stampabili con i loro equivalenti grafici U + 2400-U + 2421 a scopo di visualizzazione.