Być może słyszałeś o „logo hakera”, zwanego także „godłem hakera”. To wygląda tak:

Jest to wzór z matematycznej symulacji zwanej Game of Life. Szybowiec jest najprostszym poruszającym się wzorem Życia i najbardziej natychmiast rozpoznawalnym ze wszystkich wzorów Życia.

Wyzwanie

Wyzwanie jest dość proste: wyświetl logo hakera. Jest to zdefiniowane jako:

• Siatka 3x3 z ramką, białym tłem i szarymi liniami siatki.
• Pięć czarnych kropek ułożonych w wzór szybowca GoL.
• Nic więcej.

Zasady

• Czarne kropki muszą wypełniać 40% - 80% ich poszczególnych pól siatki.
• Wyświetlisz godło z wyjściem graficznym, ale bez grafiki ASCII .
• Dane wyjściowe muszą mieć co najmniej 30 x 30 pikseli .
• Dane wyjściowe muszą mieć tylko kolory szary, czarny i biały .
• Każde pole siatki w siatce będzie tego samego rozmiaru. Siatka będzie regularnym kwadratem 3x3 .
• Nie możesz pobrać logo z Internetu lub systemu plików.
• Twój program wyświetli logo na pustym ekranie / oknie. Jeśli zakończy się, musi to zrobić normalnie.
• Zauważ, że „kropki” niekoniecznie oznaczają „koła”. „Kropka” to pojedynczy kształt geometryczny wyśrodkowany na środku siatki z jedną powierzchnią. Na przykład, podczas gdy okrąg lub kwadrat kwalifikują się jako kropka, dwa trójkąty lub szachownica nie będą.

Zwycięzca

Ponieważ jest to gra w golfa , wygrywa najkrótsza odpowiedź w każdym języku!

Dołącz do odpowiedzi zrzut ekranu z programu.

Mathematica, 62 bajty

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

Mathematica, 71 bajtów

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

CSS + HTML, 56 + 84 = 140 bajtów 52 + 84 = 136 bajtów

Zaoszczędzono 4 bajty, włączając sugestie z komentarzy.

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

Wykorzystuje on znak UTF-8 o •długości 2 bajtów i korzysta z łaskawości składni HTML.

GLSL (shader fragmentów), 278 235 256 bajtów

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

Zobacz to w akcji: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 bajtów

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)

Rzeczywisty rozmiar, 61 na 61, wykreślony na znacznie większym płótnie 300 na 400:

Pokazuje siatkę pikseli:

Kropki używają 177 pikseli w zakresie 40% -80%, niezależnie od tego, czy wypełnia się białe tło 19 na 19 (144,4-288,8), czy 21 na 21, w tym obie krawędzie (176,4-352,8).

Uwaga: program kończy i zamyka okno obszaru roboczego po zakończeniu rysowania, aby umożliwić ręczne zamknięcie okna, dołączając linię done().

turtleto pakiet Pythona opracowany do wstępnego programowania graficznego. Pióro zaczyna się na x,y=0,0środku 300 na 400 pikseli płótna (domyślnie), uppodnosi pióro, gotoprzesuwa pióro, shapeustawia kształt pióra na nazwany kształt ( "square"jest to wstępnie zdefiniowany kształt o domyślnej szerokości piksela 21 ), colorustawia kolor, w którym dwa parametry ustawiają obrys (domyślnie szerokość 1) i wypełnienie; bajt jest zapisywany za pomocą (r,g,b)opcji krotki w celu zastąpienia "white"za [1,1,1]pomocą mnożenia listy [1]*3. Na koniec dotrysuje kropkę o podanej szerokości w pikselach i kolorze. Domyślna wartość szerokości kropki jest zbyt mała, aby ją zakwalifikować, 9dlatego też uczyniłem ją estetyczną i kwalifikującą 15. Kolor kropki może być"black"ale rozpakowana (r,g,b)krotka 0,0,0jest krótsza o dwa bajty.

Pióro musi oddalić się od kropki na końcu, ponieważ w przeciwnym razie szary / biały długopis ukrywa kropkę.

Siatka jest przesuwany za pomocą div ( /) i mod ( %I) izaczynając od 8( izostaje zainicjowany na 9ale jest zmniejszana na początku whilepętli) i działa aż do 0, potrącenie wyniki 2,1,0dla -1,0,1użyciu (1-...)i skalowanie każdy się do rozmiaru siatki przy użyciu współczynnik 20 (uwaga, że ​​w 20-i/3*20rzeczywistości jest to bajt mniej niż 20*(1-i/3), to samo dotyczy %). To tworzy kolejność [lewy dolny, środkowy lewy, lewy górny, dolny środkowy, środkowy środkowy, górny środkowy, dolny prawy, środkowy prawy, górny prawy] i wymaga hasDotoceny „ ” [1,0,0,1,0,1,1,1,0], która jest 302w formacie binarnym więc może mieć dostęp poprzez kontrolę i^th mocy dwóch komponent302z użyciem bitowym i, 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 bajtów

^{-32 poprzez użycie nieczytelnych nazw zmiennych: P
-1, ponieważ Apple zdecydowało się być magiczne i pozwól mi użyć ukrytego / nieistniejącego GOTO}

Oto mój własny (bardzo dający się pokonać) program na przykład wyniku, który nie używa okręgów:

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

Wynik:

Kod maszynowy IA-32, 81 80 bajtów

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

Jest to fastcallfunkcja o nazwie, doitktóra zwraca obraz w formacie PGM w dostarczonym buforze. Stosowanie:

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

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

Wynik:

Kiedyś rozdzielczości 256x256 bo fajnie to pozwala mi podzielić indeks piksela w ecxautomatycznie na współrzędne yw chi xw cl. Ponadto format pliku PGM wymaga liczby 255 w nagłówku obrazu.

Wewnętrzne kwadraty mają wymiary 54 x 54 (41% komórek według obszaru).

Kod źródłowy (może zostać skompilowany przez 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;

Wzór komórki

0 1 0
0 0 1
1 1 1

może być reprezentowany przez „zoptymalizowaną” bitmapę 7 bitów.

Bity są indeksowane według wyrażenia y * 2 + x, gdzie (x,y)jest lokalizacja komórki. To wyrażenie daje ten sam indeks 2 parom komórek. To szczęśliwy zbieg okoliczności, że wartości bitów są takie same.

HTML i CSS, 155 bajtów

Okazuje się, że HTML naprawdę wybacza błędy składniowe.

_{1 bajt zapisany dzięki @Octopus · 1 bajt zapisany dzięki @Downgoat · 2 bajty zapisane dzięki @StephenS}

_{2 bajty zapisane dzięki @Ryan · 3 bajty zapisane dzięki @styfle · 4 bajty zapisane dzięki @Ferrybig}

_{13 bajtów zapisanych dzięki @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 bajtów)

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 bajtów

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

To moja pierwsza próba gry w golfa, więc jestem pewien, że można to poprawić. Chciałbym nie ustalać limitów, ale wygląda na to, że matplotlib nie może wykryć, że narysowałem koła tam, gdzie to zrobiłem. Bez ustawienia xlim () i ylim () pokazuje tylko dwa dolne okręgi.

Wynik:

Edycja: Naprawiono kolor obramowań i usunięto cyfry zaznaczenia. Muszę powiedzieć, że matplotlib jest bardzo gęsto sformułowany i niezbyt przyjazny ze zmieniającymi się kolorami osi.

Wygolono 3 bajty dzięki @DJMcMayhem

Edycja: Oderwał dwa bajty ustawiając moje tiki jako krotkę wewnątrz funkcji set_ticks.

Bash + ImageMagick, 233 226 znaków

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:

Przykładowe dane wyjściowe:

Bash + ImageMagick, 215 znaków

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:

Właściciel pytania nie odpowiedział jeszcze na pytanie antyaliasingu, a niektóre inne rozwiązania mają również dodatkowe odcienie szarości dodane przez antyaliasing, więc na razie ten krótszy wydaje się również do przyjęcia.

Przykładowe dane wyjściowe:

Rubin, 144 166 164 148 144 144 bajtów

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

Wynik:

Edycja: teraz ma szare linie siatki.

PNG, 105 100 bajtów

   (tzn. ten plik obrazu)

Biorąc pod uwagę, że HTML i inne języki nieprogramowe są dozwolone , byłem ciekawy, jak bardzo mogę grać w golfa w zwykły obraz, który można wyświetlić w przeglądarce, aby służyć jako podstawowe porównanie. Wynik jest kompresowany za pomocą narzędzi open-source optipng ( -o7 -zm1-9 -strip all) i pngwolf . Eksperymentowałem również z zopflipng , ale wyniki były większe. Inne narzędzia do kompresji o zamkniętym źródle mogą być w stanie zgolić jeszcze kilka bajtów.

Dane obrazu w base64:

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

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

Edytuj Zmusiłem kropki do dotykania górnej i dolnej części komórki, aby zwiększyć powtarzalność wzoru pikseli, a tym samym poprawić współczynnik kompresji. Ale nie martw się, kropka wciąż wypełnia tylko (7 * 9) / (9 * 9) ≈ 78% jej komórki.

Niestandardowy PNG, 88 bajtów

Jak wskazał @anatolyg , istnieje pewien potencjał golfowy poprzez usunięcie fragmentu IEND (12 bajtów). Technicznie IEND jest wymagany przez standard . Jednak każdy fragment PNG zawiera swój własny rozmiar i informacje o sumie kontrolnej. Dlatego nie ma absolutnie konieczności posiadania znacznika końcowego. I rzeczywiście, wszystkie testowane przeze mnie przeglądarki mogą wyświetlać obraz bez problemu.

Niestety (lub na szczęście) ten niestandardowy obraz został odrzucony przez imgur, więc nie mogę go załadować. To jest kodowanie base64:

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

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

Oktawa , 127 124 bajtów

Usunięto 3 bajty dzięki Luisowi. gridjest wystarczający (zamiast 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

Wyjścia (po zapisaniu):

Zauważ, że dane wyjściowe pokazują szare linie siatki w oknie wydruku. Podczas zapisywania zmieniają kolor na czarny (z jakiegoś powodu).

To było długie i nieporządne! Musiałem przejść wiele modyfikacji, aby dostosować się do specyfikacji.

Wyjaśnienie i mam nadzieję, że zbliża się gra w golfa ...

Przetwarzanie, 212 198 bajtów

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

Zasadniczo używamy prostego przetwarzania, aby narysować białe tło, a następnie ustawiamy przezroczystość prostokątów używanych w siatce i rysujemy ich obrysy na szaro. Kontynuujemy, definiując prostokąt, ustawiając ponownie wartość wypełnienia, aby wypełnić czarne koła i definiując pięć kół.

Voilà!

Możesz dodać

strokeWidth(2); 

lub więcej, aby lepiej zobaczyć kolor pociągnięć.

(To mój pierwszy Code-Golf, mam nadzieję, że wszystko zrobiłem dobrze.)

EDYCJA: Dzięki Kritixi Lithos! Usunięto znaki nowej linii, zmieniono na int f = 25 i zastosowano -1 w tle (liczba zmiennoprzecinkowa)

Tikz, 193 175 170 bajtów

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

Oto wynik:

MATL , 74 69 68 64 62 bajtów

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

Wypróbuj w MATL Online! (To zajmuje kilka sekund.)

Dane wyjściowe z tłumacza online:

Przetwarzanie, 134 bajty

Zainspirowany przez @Zep, oto mój Processing one-liner (a także mój pierwszy kod golfowy):

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

Dzięki za @Kritixi Lithos za jego genialne wskazówki na temat golenia o kilka bajtów!

LaTeX + Tikz, 155 bajtów

\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 bajtów

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, który znajduje się w bloku „Obszar prywatnego użytku”) to kod znaku symbolu okręgu. Umieszczenie go w łańcuchu też by działało, ale ponieważ koduje się go w UTF-8 jako 3 bajty, miałby on tę samą długość (i nie wyświetla się tutaj poprawnie).

C #, 333 bajty

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

Wersja pełna / sformatowana:

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

Pomysł jest prosty, tworzymy obiekt graficzny z obrazu i używamy go, aby obraz był cały biały. Następnie przesuń pętlę nad każdym kwadratem obrazu, rysując obwiedni prostokąt. Jeśli jest to jedna z lokalizacji kropki, również ją rysujemy. Na koniec zapisujemy obraz do pliku i pozwalamy systemowi Windows decydować o tym, jak go otworzyć, w moim przypadku otwiera się za pomocą Windows Photo Viewer.

Użycie a Processdo wyświetlenia obrazu i zapisanie go do pliku jest o wiele krótsze niż utworzenie formularzy Windows lub aplikacji WPF ze względu na wszystkie różne klasy i dodatkowy puch potrzebny do ich utworzenia.

Wynik:

PHP, 221 + 2 bajty

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

Zapisz do pliku; zadzwoń w przeglądarce. Jeśli przeglądarka wyświetla bełkot,
włóż header("Content-Type:image-png");wcześniej imagepng($i);.

Kropki nie są bardzo okrągłe; wynika to z małych proporcji.

awaria

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

Myślę, że to 0x4c4b40kwalifikuje się jako przybliżony szary. Jeśli nie, dodaj cztery bajty.

R 313 236 bajtów

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

Zmieniony kod, oparty głównie na komentarzach @ user2390246, zapisał 77 bajtów. Bardzo doceniam pomoc.

Ponadto chcę dodać odwołanie do krótszego rozwiązania R autorstwa @mschilli. Pokazuje elegancki sposób rozwiązania problemu domyślnych wartości graficznych R.

Wynik

Przechodzi do nazwy pliku „r”. Pominięcie i rozszerzenie pozwoliły mi zaoszczędzić cztery bajty. Ale potem musiałem edytować rozszerzenie pliku z powrotem na „bmp”, aby je załadować. Więc może nie powinienem dostać kredytu za te cztery bajty.

Komentarz

Pomyślałem sobie: „Ta grafika to nic innego jak prosty wykres z pięcioma kropkami. Powinna być prostą sprawą do zaimplementowania w języku z solidnymi możliwościami grafiki. Spróbujmy w R.” Ale potem musiałem wydać na rząd 80% bajtów po prostu pracujących wokół domyślnych ustawień graficznych R.

Trochę niewłaściwe narzędzie do pracy ....

Nie mogłem znaleźć mniej pełnego sposobu zagwarantowania rozmiaru i proporcji grafiki niż przez wywołanie konstruktora bmp, a następnie dev.off (). Kombinacja obejmuje 25 bajtów. Jeśli twoja sesja R jest poprawnie skonfigurowana, możesz uzyskać grafikę, która wygląda mniej więcej poprawnie bez wydawania tych bajtów, ale nie jest niezawodna ani spójna.

TI-BASIC, 218 140 137 bajtów

Uwaga: ta liczba bajtów jest nieco zawyżona. Program używa tylko 85 tokenów, ale jest to zapisane w 137 bajtach. Ponadto, jeśli używasz kalkulatora bez koloru, możesz zapisać kolejne 4 tokeny, ponieważ nie musisz określać koloru (domyślnie jest to niebieski), ale nie wiem, czy ich ekrany są wystarczająco duże, aby to wyzwanie, ponieważ nie mam jednego.

prgmHACKER (138 bajtów, 86 tokenów):

{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

Aby poprawnie wyświetlić, ten program wymaga, aby Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX również musi być odpowiednio ustawiony, ale kalkulator robi to za Ciebie, gdy ustawisz dowolną inną zmienną okna. Nie widziałem, ile miejsca te zmienne wykorzystały w pamięci RAM.

Ponadto ustawieniami formatu powinny być {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF}, ale są to przełączane wartości i nie zajmują dodatkowego miejsca w zależności od ustawienia.

R, 119 114 111 bajtów

( Dzięki @JayCe za uratowanie mi 3 bajtów)

Nie krótszy niż inne rozwiązanie R , ale zupełnie inne podejście:

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

Wykorzystuje układ, w którym 4 pierwsze wykresy to puste komórki, a 5 innych to te z kropkami.

Excel VBA, 180 bajtów

Anonimowa funkcja okna natychmiastowego VBE, która nie przyjmuje danych wejściowych i wyjściowych do domyślnego obiektu arkusza ( 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

Skomentowana wersja

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

Wynik

-6 bajtów dla użycia [{21,32,13,23,33}]ponadSplit("21 32 13 23 33")

-2 bajty dla użycia Mid(s,2)ponadRight(s,1)

-3 bajty za użycie (s\10)overLeft(s,1)

Oktawa 107 94 103 bajtów

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

lub

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

oba rozwiązania mają 103 bajty.

Apple Swift (iOS - CoreGraphics / QuartzCore) - 832 bajtów

Narysowałem ten kształt całkowicie za pomocą Quartz na urządzenie Apple iOS. Niestety, nie jest to język szczególnie uważny, więc wynik jest dość duży, ale jest tak mały, jak tylko mogę.

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

Bardziej czytelna wersja dla wszystkich zainteresowanych:

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

Oto dane wyjściowe wyprodukowane w symulatorze iOS:

Rubin z butami, 118 znaków

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 sprawdzanie zapożyczone z RJHunter 's komentarzu wykonane na Mark Thomas ' s rozwiązania Ruby .

Przykładowe dane wyjściowe:

SVG + HTML, 146 138 135 133 bajtów

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

Dzięki łagodnemu parserowi HTML xmlns="http://www.w3.org/2000/svg"deklarację można pominąć, a także cytaty atrybutów i tag zamykający. Ta wersja rozwiązuje niektóre problemy innych rozwiązań HTML:

• „Kropka” gwarantuje wypełnienie co najmniej 40% swojej komórki (§1)
• Nie wykorzystuje grafiki zewnętrznej, np. Glifów czcionek (§2, §6)
• Siatka jest idealnie kwadratowa (§5)

Edycja Ogolono 8 bajtów, wykorzystując fakt, że podścieżki nie muszą być zamykane, aby je wypełnić .

Edycja Zgodnie z gramatyką svg nie jest konieczne oddzielanie cyfr od przecinków ( .5,.5). Porzuciłem również wyraźne wypełnienie, aby zmienić kierunek rysowania jednej linii z ujemnej na pozytywną, oszczędzając kreskę. Na koniec dostosowałem liczbę, aby nie zawierała nowej linii, przepraszam za ten błąd debiutanta.

Edycja Uczenie się od innej odpowiedzi na codegolf, jakie otrzymuje końcowy 9 />z 9>. Działa to dobrze we wszystkich testowanych przeglądarkach.

Python 3 + PyGame, 238 bajtów

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

Pozornie arbitralne stałe są ode mnie próbujące uczynić obraz tak dużym, jak to możliwe, bez poświęcania bajtów.

Ze znakami niedrukowalnymi, 229 bajtów

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

Wymieniłem listy literałami bajtowymi, co oszczędza wiele znaków, ale znaki niedrukowalne nie mogą być tutaj poprawnie wyświetlane. Do celów wyświetlania zastąpiłem znaki niedrukowalne ich graficznymi odpowiednikami U + 2400-U + 2421.