Möglicherweise haben Sie vom "Hacker-Logo", auch "Hacker-Emblem" genannt, gehört. Es sieht aus wie das:

Dies ist ein Muster aus einer mathematischen Simulation namens Game of Life. Der Gleiter ist das einfachste Lebensmuster, das sich bewegt, und das am schnellsten erkennbare aller Lebensmuster.

Die Herausforderung

Die Herausforderung ist ganz einfach: Zeigen Sie das Hacker-Logo an. Dies ist definiert als:

• Ein 3x3-Gitter mit einem Rand, einem weißen Hintergrund und grauen Gitterlinien.
• Fünf schwarze Punkte im GoL-Muster.
• Nichts anderes.

Die Regeln

• Die schwarzen Punkte müssen 40% - 80% ihrer einzelnen Gitterfelder ausfüllen .
• Sie werden das Emblem mit grafischer Ausgabe aber ohne ASCII- Grafik anzeigen .
• Die Ausgabe muss mindestens 30x30 Pixel betragen .
• Die Ausgabe darf nur die Farben Grau, Schwarz und Weiß enthalten .
• Jedes Gitterfeld im Gitter hat die gleiche Größe. Das Gitter wird ein reguläres 3x3-Quadrat sein .
• Sie dürfen das Logo nicht aus dem Internet oder Ihrem Dateisystem ziehen.
• Ihr Programm zeigt das Logo auf einem leeren Bildschirm / Fenster an. Wenn es beendet wird, muss es dies normal tun.
• Beachten Sie, dass "Punkte" nicht unbedingt "Kreise" bedeuten. Ein "Punkt" ist eine einzelne geometrische Form, die in der Mitte des Gitterkastens mit einer Oberfläche zentriert ist. Während beispielsweise ein Kreis oder ein Quadrat als Punkt qualifiziert wird, gilt dies für zwei Dreiecke oder ein Schachbrett nicht.

Der Gewinner

Da dies Codegolf ist , gewinnt die kürzeste Antwort in jeder Sprache!

Bitte fügen Sie Ihrer Antwort einen Screenshot der Ausgabe Ihres Programms bei.

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

4 Bytes gespart, indem Vorschläge aus den Kommentaren übernommen wurden.

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

Hierbei wird das UTF-8-Zeichen verwendet, •das 2 Byte lang ist und die Anmut der HTML-Syntax ausnutzt.

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

Sehen Sie es in Aktion: 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)

Tatsächliche Größe, 61 mal 61, gezeichnet auf einer viel größeren Leinwand von 300 mal 400:

Pixelraster anzeigen:

Die Punkte verwenden 177 Pixel im Bereich von 40% bis 80%, unabhängig davon, ob die weiße Füllung 19 x 19 (144,4 bis 288,8) oder die weiße Füllung 21 x 21 mit beiden Rändern (176,4 bis 352,8) berücksichtigt wird.

Hinweis: Das Programm wird beendet und das Canvas-Fenster geschlossen, sobald die Zeichnung abgeschlossen ist, damit das manuelle Schließen des Fensters die Linie anfügt done().

turtleist ein Python-Paket, das für die grafische Einführungsprogrammierung entwickelt wurde. Ein Stift beginnt x,y=0,0in der Mitte einer Leinwand mit 300 x 400 Pixel (Standardeinstellung), uphebt den Stift an, gotobewegt den Stift und shapestellt die Form des Stifts auf eine benannte Form ein ( "square"eine vordefinierte Form mit einer Standardpixelbreite von 21) ), colorlegt die Farbe fest, bei der zwei Parameter Strich (mit der Standardbreite 1) und Füllung festlegen; ein Byte wird unter Verwendung der gespeicherten (r,g,b)Tupel Option ersetzen "white"mit [1,1,1]Verwendung der Liste Multiplikation [1]*3. Zum Schluss wird dotein Punkt mit der angegebenen Breite in Pixel und Farbe gezeichnet. Der Standardwert für die Breite des Punkts ist zu klein, um ihn zu qualifizieren. 9Deshalb habe ich ihn ästhetisch und qualifizierend gestaltet 15. Die Farbe des Punktes könnte sein"black"aber das entpackte (r,g,b)Tupel von 0,0,0ist um zwei Bytes kürzer.

Der Stift muss sich von einem Punkt am Ende entfernen, da sonst der grau / weiße Stift den Punkt verbirgt.

Das Gitter wird durchquert einen div Verwendung ( /) und mod ( %) der iab 8( iwird initialisiert , 9sondern wird zu Beginn der dekrementiert whileSchleife) und Arbeits unten zu 0, Versetzen die Ergebnisse 2,1,0zu -1,0,1verwenden (1-...)und jeweils bis zu der Rastergröße Skalierung unter Verwendung von ein Faktor von 20 (beachten Sie, dass dies 20-i/3*20tatsächlich ein Byte weniger ist als 20*(1-i/3), dasselbe gilt für %). Dies erzeugt die Reihenfolge [unten links, Mitte links, oben links, unten mittig, Mitte mittig, oben mittig, unten rechts, Mitte rechts, oben rechts] und " hasDot" erfordert eine Bewertung von [1,0,0,1,0,1,1,1,0], das ist 302in binären so durch inspizieren der zugegriffen werden kann i^ten Zweierpotenz Komponente302mit einem bitweisen-und 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 Bytes

^{-32 bei Verwendung nicht lesbarer Variablennamen: P
-1, weil Apple sich für magisch entschieden hat und mich ein implizites / nicht existierendes GOTO verwenden ließ}

Hier ist mein eigenes (sehr schlagbares) Programm für ein Beispiel einer Ausgabe, die keine Kreise verwendet:

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

Ausgabe:

IA-32 Maschinencode, 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

Diese fastcallFunktion doitgibt das Bild im PGM-Format im angegebenen Puffer zurück. Verwendungszweck:

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

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

Ausgabe:

Ich habe eine Auflösung von 256x256 verwendet, weil es cool ist, damit ich den Index des Pixels ecxautomatisch in Koordinaten yin chund xin teilen kann cl. Das PGM-Dateiformat erfordert außerdem die Nummer 255 im Image-Header.

Die inneren Quadrate sind 54 x 54 (41% der Zellfläche).

Quellcode (kann von Visual Studio kompiliert werden):

    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;

Das Zellmuster

0 1 0
0 0 1
1 1 1

kann durch eine "optimierte" Bitmap von 7 Bits dargestellt werden.

Die Bits werden durch den Ausdruck indiziert y * 2 + x, wobei (x,y)der Ort der Zelle ist. Dieser Ausdruck gibt 2 Zellpaaren den gleichen Index. Es ist ein glücklicher Zufall, dass die Bitwerte dort gleich sind.

HTML & CSS, 155 Byte

Es stellte sich heraus, dass HTML Syntaxfehler wirklich verzeiht.

_{1 Byte gespeichert dank @Octopus · 1 Byte gespeichert dank @Downgoat · 2 Byte gespeichert dank @StephenS}

_{2 Bytes gespeichert dank @Ryan · 3 Bytes gespeichert dank @styfle · 4 Bytes gespeichert dank @Ferrybig}

_{Dank @SteveBennett 13 Bytes gespart}

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

Dies ist mein erster Versuch hier, Code Golf zu spielen, daher bin ich sicher, dass dies verbessert werden kann. Am liebsten hätte ich die Grenzen nicht festgelegt, aber es scheint, dass matplotlib nicht erkennen kann, dass ich dort Kreise eingezeichnet habe, wo ich es getan habe. Ohne xlim () und ylim () werden nur die unteren beiden Kreise angezeigt.

Ausgabe:

Bearbeiten: Die Farbe der Ränder wurde korrigiert und die Tick-Nummern entfernt. Ich muss sagen, Matplotlib ist sehr dicht gefasst und nicht zu freundlich, wenn sich die Achsenfarben ändern.

3 Bytes gespart dank @DJMcMayhem

Bearbeiten: Zwei Bytes wurden entfernt, indem meine Häkchen als Tupel innerhalb von set_ticks-Funktionen gesetzt wurden.

Bash + ImageMagick, 233 226 Zeichen

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:

Beispielausgabe:

Bash + ImageMagick, 215 Zeichen

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:

Der Eigentümer der Frage hat die Antialiasing-Frage noch nicht beantwortet. Bei einigen anderen Lösungen werden durch das Antialiasing zusätzliche Graustufen hinzugefügt. Daher sieht diese kürzere Frage vorerst auch akzeptabel aus.

Beispielausgabe:

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

Ausgabe:

Bearbeiten: Hat jetzt graue Gitterlinien.

PNG, 105 100 Bytes

   (dh diese Bilddatei)

Angesichts der Tatsache, dass HTML und andere Nicht-Programmiersprachen zulässig sind , war ich neugierig, wie viel ich für ein einfaches, vom Browser anzeigbares Bild ausgeben kann, um es als Vergleichsbasis zu verwenden. Das Ergebnis wird mit den Open-Source-Tools optipng ( -o7 -zm1-9 -strip all) und pngwolf komprimiert . Ich habe auch mit Zopflipng experimentiert , aber die Ergebnisse waren größer. Andere Closed-Source-Komprimierungstools können möglicherweise ein paar Bytes mehr einsparen.

Bilddaten in base64:

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

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

Bearbeiten Ich ließ die Punkte die Zelle oben und unten berühren, um mehr Wiederholungen im Pixelmuster zu bewirken und damit das Kompressionsverhältnis zu verbessern. Aber keine Sorge, ein Punkt füllt immer noch (7 * 9) / (9 * 9) ≈ 78% seiner Zelle aus.

Nicht-Standard-PNG, 88 Bytes

Wie von @anatolyg hervorgehoben , besteht ein gewisses Golfpotential , wenn der IEND-Block (12 Byte) entfernt wird. Technisch ist IEND vom Standard vorgeschrieben . Jeder PNG-Block enthält jedoch seine eigene Größe und Prüfsummeninformationen. Es ist daher nicht unbedingt erforderlich, einen Endmarker zu haben. Tatsächlich können alle von mir getesteten Browser das Bild ohne Probleme anzeigen.

Leider (oder zum Glück) wird dieses nicht standardmäßige Bild von imgur abgelehnt, so dass ich es nicht hochladen kann. Dies ist die Base64-Codierung:

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

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

Oktave , 127 124 Bytes

3 Bytes dank Luis entfernt. gridist ausreichend (statt 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

Ausgaben (nach dem Speichern):

Beachten Sie, dass in der Ausgabe graue Gitterlinien im Plotfenster angezeigt werden. Sie werden beim Speichern schwarz (aus irgendeinem Grund).

Nun, das war lang und chaotisch! Musste eine Menge Modifikationen durchlaufen , damit dies den Spezifikationen entspricht.

Erklärung und hoffentlich etwas Golfspiel ...

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

Grundsätzlich verwenden wir die einfache Verarbeitung, um einen weißen Hintergrund zu zeichnen, dann die Transparenz der für das Raster verwendeten Rechtecke festzulegen und ihre Striche in Grau zu zeichnen. Wir definieren das Rechteck, setzen den Füllwert erneut, um die Kreise schwarz zu füllen, und definieren fünf Kreise.

Voilà!

Sie könnten hinzufügen

strokeWidth(2); 

oder mehr, um die Farbe der Striche besser zu sehen.

(Das ist mein erster Code-Golf, ich hoffe ich habe alles richtig gemacht.)

EDIT: Danke an Kritixi Lithos! Die Zeilenumbrüche wurden entfernt, in int f = 25 geändert und -1 im Hintergrund verwendet (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}

Hier ist die Ausgabe:

MATL , 74 69 68 64 62 Bytes

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

Probieren Sie es bei MATL Online! (Es dauert einige Sekunden.)

Ausgabe vom Online-Dolmetscher:

Verarbeitung, 134 Bytes

Inspiriert von @Zep, hier ist mein Processing One-Liner (und auch mein erster 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);}};

Vielen Dank für @Kritixi Lithos für seine brillanten Tipps, um ein paar Bytes zu sparen!

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 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 im Block "Private Use Area") ist der Zeichencode für ein Kreissymbol. Das Einfügen in einen String würde ebenfalls funktionieren, aber da es in UTF-8 als 3 Byte codiert ist, würde es dieselbe Länge haben (und hier nicht korrekt angezeigt werden).

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

Voll / Formatierte Version:

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

Die Idee ist einfach. Wir erstellen ein Grafikobjekt aus dem Bild und verwenden es, um das Bild komplett weiß zu machen. Bewegen Sie sich dann über jedes Quadrat des Bildes und zeichnen Sie das Begrenzungsrechteck. Wenn es eine der Stellen für einen Punkt ist, zeichnen wir das auch. Zuletzt speichern wir das Bild in einer Datei und lassen Windows entscheiden, wie es geöffnet wird. In meinem Fall wird es mit Windows Photo Viewer geöffnet.

Die Verwendung von a Processzum Anzeigen des Bildes und Speichern in einer Datei ist viel kürzer als das Erstellen von Windows Forms oder einer WPF-App, da all die verschiedenen Klassen und der zusätzliche Flaum für die Erstellung erforderlich sind.

Ausgabe:

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

Speichern unter; im browser anrufen. Sollte Ihr Browser Kauderwelsch anzeigen,
fügen Sie header("Content-Type:image-png");vor imagepng($i);.

Die Punkte sind nicht sehr rund; das liegt an den kleinen Anteilen.

Nervenzusammenbruch

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

Ich denke das 0x4c4b40qualifiziert sich als ungefähres Grau. Wenn nicht, fügen Sie vier Bytes hinzu.

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

Der überarbeitete Code basiert hauptsächlich auf Kommentaren von @ user2390246, die 77 Byte gespeichert haben. Vielen Dank für die Hilfe.

Außerdem möchten Sie der kürzeren R-Lösung von @mschilli einen Hinweis hinzufügen. Es zeigt eine elegante Möglichkeit, das Problem der grafischen Standardeinstellungen von R zu lösen.

Ausgabe

Geht zu einem Dateinamen "r". Das Weglassen und die Erweiterung haben mir vier Bytes gespart. Aber dann musste ich die Dateierweiterung wieder auf "bmp" ändern, damit sie hochgeladen werden konnte. Vielleicht sollte ich diese vier Bytes nicht gutschreiben lassen.

Kommentar

Ich dachte mir: "Diese Grafik ist nichts anderes als eine einfache Grafik mit fünf Punkten. Sollte in einer Sprache mit robusten Datengrafikfunktionen einfach zu implementieren sein. Probieren wir es in R aus." Aber dann musste ich in der Größenordnung von 80% der Bytes ausgeben, um die grafischen Standardeinstellungen von R zu umgehen.

Irgendwie das falsche Werkzeug für den Job ....

Ich konnte keine weniger ausführliche Methode finden, um die Größe und das Seitenverhältnis der Grafik zu gewährleisten, als den bmp-Konstruktor und dann dev.off () aufzurufen. Die Kombination macht 25 Bytes aus. Wenn Ihre R-Sitzung richtig eingerichtet ist, erhalten Sie möglicherweise eine Grafik, die mehr oder weniger korrekt aussieht, ohne diese Bytes auszugeben, die jedoch nicht zuverlässig oder konsistent ist.

TI-BASIC, 218 140 137 Bytes

Hinweis: Diese Byteanzahl ist etwas erhöht. Das Programm verwendet nur 85 Token, aber das ist in 137 Bytes gespeichert. Wenn Sie einen Taschenrechner ohne Farbe verwenden, können Sie weitere 4 Token speichern, da Sie die Farbe nicht angeben müssen (standardmäßig blau), aber ich weiß nicht, ob die Bildschirme groß genug sind Diese Herausforderung, weil ich keine besitze.

prgmHACKER (138 Bytes, 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

Für eine ordnungsgemäße Anzeige setzt dieses Programm voraus, dass Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1 ist. DX muss ebenfalls ordnungsgemäß festgelegt werden, der Rechner erledigt dies jedoch für Sie, wenn Sie eine andere Fenstervariable festlegen. Ich konnte nicht sehen, wie viel Speicherplatz diese Variablen im RAM verwendeten.

Darüber hinaus sollten die Formateinstellungen {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Achsen: OFF, ExprOff, BorderColor: 1, Background: OFF} lauten. Diese Werte sind jedoch umgeschaltet und belegen je nach Einstellung keinen zusätzlichen Platz.

R, 119 114 111 Bytes

(Danke an @JayCe , dass du mir 3 Bytes gespart hast)

Nicht kürzer als die andere R-Lösung , aber ein völlig anderer Ansatz:

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

Verwendet ein Layout, in dem die 4 ersten Diagramme die leeren Zellen sind und die 5 anderen die mit Punkten.

Excel VBA, 180 Byte

Eine anonyme VBE-Direktfensterfunktion, die keine Ein- und Ausgaben für das Standardarbeitsblattobjekt ( Sheet1) vornimmt .

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

Kommentierte Version

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

Ausgabe

-6 Bytes für die Verwendung von [{21,32,13,23,33}]überSplit("21 32 13 23 33")

-2 Bytes für die Verwendung von Mid(s,2)überRight(s,1)

-3 Bytes für die Verwendung von (s\10)überLeft(s,1)

Oktave 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

oder

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

Beide Lösungen sind 103 Bytes.

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

Ich habe die Form komplett mit Quartz für ein Apple iOS-Gerät gezeichnet. Leider ist dies keine besonders große Sprache, daher ist das Ergebnis ziemlich groß, aber so klein, wie ich es bekommen kann.

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

Eine lesbarere Version für alle Interessierten:

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

Hier ist die Ausgabe, die im iOS-Simulator erstellt wurde:

Ruby with Shoes, 118 Zeichen

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 Prüfung entlehnt RJHunter 's Kommentar gemacht auf Mark Thomas ' s Ruby - Lösung .

Beispielausgabe:

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>

Dank des nachgiebigen HTML-Parsers können die xmlns="http://www.w3.org/2000/svg"Deklaration, Attribut-Anführungszeichen und das schließende Tag weggelassen werden. Diese Version behebt einige Probleme anderer HTML-Lösungen:

• Ein "Punkt" füllt garantiert mindestens 40% seiner Zelle aus (§1)
• Es werden keine externen Grafiken verwendet, z. B. Schriftzeichen (§2, §6)
• Das Raster ist perfekt quadratisch (§5)

Bearbeiten Sie 8 Bytes weniger, indem Sie die Tatsache ausnutzen, dass Unterpfade nicht geschlossen werden müssen, um gefüllt zu werden .

Bearbeiten Nach der SVG-Grammatik ist es nicht erforderlich, Nicht-Ziffern mit einem Komma ( .5,.5) zu trennen . Ich habe auch die explizite Füllung aufgegeben, damit ich die Zeichenrichtung einer Linie von negativ nach positiv ändern und einen Strich sparen kann. Und zum Schluss habe ich die Anzahl so angepasst, dass keine nachgestellte Zeile eingefügt wird. Tut mir leid für diesen Anfängerfehler.

Bearbeiten von Lern einer anderen Antwort auf codegolf, ich habe die endgültige Fassung 9 />mit 9>. Dies funktioniert problemlos in allen getesteten Browsern.

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

Die scheinbar willkürlichen Konstanten versuchen von mir, das Bild so groß wie möglich zu machen, ohne Bytes zu opfern.

Mit nicht druckbaren Zeichen, 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()

Ich habe die Listen durch Byte-Literale ersetzt, wodurch eine Reihe von Zeichen gespeichert werden, aber die nicht druckbaren Zeichen können hier nicht richtig angezeigt werden. Ich habe die nicht druckbaren Zeichen zu Anzeigezwecken durch ihre grafischen Entsprechungen U + 2400-U + 2421 ersetzt.