Можливо, ви чули про "логотип хакера", який також називають "емблемою хакера". Це виглядає приблизно так:

Це зразок математичного моделювання під назвою Гра життя. Планер - найпростіший життєвий зразок, який рухається, і найбільш миттєво впізнаваний з усіх моделей життя.

Змагання

Завдання досить проста: Відобразити логотип хакера. Це визначається як:

• Сітка 3х3 з облямівкою, білим тлом та сірими лініями.
• П’ять чорних крапок розташовані за схемою планера GoL.
• Більш нічого.

Правила

• Чорні крапки повинні заповнювати 40% - 80% їх індивідуальних сіток.
• Ви будете відображати емблему з графічним висновком, але без зображення ASCII .
• Вихід повинен бути не менше 30х30 пікселів .
• На виході повинні бути лише кольори сірий, чорний і білий .
• Кожна сітка в сітці буде однакового розміру. Сітка буде звичайною площею 3х3 .
• Ви не можете витягувати логотип з Інтернету чи вашої файлової системи.
• Ваша програма відображатиме логотип на порожньому екрані / вікні. Якщо він припиняється, він повинен робити це нормально.
• Зауважте, що "крапки" не обов'язково означає "кола". "Крапка" - це єдина геометрична форма, по центру посередині коробки з сіткою з однією поверхнею. Наприклад, хоча коло або квадрат будуть кваліфіковані як крапка, два трикутники або шахівниця не будуть.

Переможець

Оскільки це код-гольф , найкоротша відповідь на кожній мові виграє!

Будь ласка, включіть у свою відповідь скріншот результатів програми.

Математика, 62 байти

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

Математика, 71 байт

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

CSS + HTML, 56 + 84 = 140 байт 52 + 84 = 136 байт

Збережено 4 байти, включивши пропозиції з коментарів.

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

Для цього використовується символ UTF-8, •довжиною якого є 2 байти, і використовується користь синтаксису HTML.

GLSL (фрагмент шейдер), 278 235 256 байт

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

Дивіться це в дії: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 байт

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)

Фактичний розмір, 61 на 61, нанесений на значно більшому полотні розміром 300 на 400:

Показано піксельну сітку:

Точки використовують 177 пікселів у межах 40% -80%, якщо врахувати заливку білого кольору 19 на 19 (144,4-288,8) або 21 на 21, включаючи обидві рамки (176,4-352,8).

Примітка: програма завершує і закриває вікно полотна, як тільки малюнок закінчений, щоб дозволити ручному закриттю вікна додати рядок done().

turtleявляє собою пакет Python, розроблений для вступного графічного програмування. Перо починається x,y=0,0з середини полотна розміром 300 на 400 пікселів (за замовчуванням), upпіднімає ручку, gotoпереміщує ручку, shapeвстановлює форму пера на іменовану форму ( "square"це заздалегідь визначена форма з шириною пікселів за шириною 21 ), colorзадає колір, де два параметри встановлюють обведення (за замовчуванням ширина 1) і заповнюють; байт зберігається за допомогою параметра (r,g,b)кортежу для заміни "white"на [1,1,1]використання множення списку [1]*3. Нарешті dotмалює крапку із заданою шириною у пікселях та кольорі. Значення ширини точки за замовчуванням занадто мало, щоб кваліфікувати, 9тому я зробив це естетичним та кваліфікованим 15. Колір точки може бути"black"але розпакований (r,g,b)кортеж 0,0,0коротший на два байти.

Ручка повинна відходити від будь-якої точки в кінці, оскільки в іншому випадку сіра / біла ручка ховає крапку.

Сітки перетинаються з використанням DIV ( /) і Mod ( %) з iпочинаючи з 8( iне започатковано , 9але декрементируется на початку whileциклу) і працює вниз 0, компенсуючи результати 2,1,0з -1,0,1використанням (1-...)і масштабування кожного до розміру сітки , використовуючи коефіцієнт 20 (зауважте, що 20-i/3*20насправді байт менший 20*(1-i/3), те саме стосується %). Це створює порядок [знизу ліворуч, ліворуч по центру, вліво-вліво, знизу-середина, центр-середина, верхній середина, праворуч знизу, право-центр, праворуч згори], і вимагає " hasDot" оцінки [1,0,0,1,0,1,1,1,0], який 302в двійковій системі, так може бути доступні шляхом перевірки i^й потужності двох компонент302з використанням побітового-й, 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 байт

^{-32, використовуючи нечитабельні назви змінних: P
-1, тому що Apple вирішила бути магічною і дозволила мені використовувати неявну / неіснуючу GOTO}

Ось моя власна (дуже видатна) програма для прикладу виводу, який не використовує кола:

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

Вихід:

Машинний код IA-32, 81 80 байт

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

Це fastcallфункція, яка називається, doitщо повертає зображення у форматі PGM у наданому буфері. Використання:

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

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

Вихід:

Я використовував роздільну здатність 256x256, тому що це круто, він дозволяє мені автоматично розділити індекс пікселя ecxна координати yв chі xв cl. Крім того, у форматі файлу PGM потрібне число 255 у заголовку зображення.

Внутрішні квадрати - 54х54 (41% клітини за площею).

Вихідний код (може бути скомпільований 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;

Клітинна картина

0 1 0
0 0 1
1 1 1

може бути представлена ​​"оптимізованою" растровою карти з 7 біт.

Біти індексуються виразом y * 2 + x, де (x,y)розташування комірки. Цей вираз дає однаковий показник для 2 пар клітин. Щасливий збіг обставин, що значення бітів там однакові.

HTML і CSS, 155 байт

Виявляється, HTML справді прощає про синтаксичні помилки.

_{1 байт збережено завдяки @Octopus · 1 байт збережено завдяки @Downgoat · 2 байти збережено завдяки @StephenS}

_{2 байти збережено завдяки @Ryan · 3 байти збережено завдяки @styfle · 4 байти збережено завдяки @Ferrybig}

_{13 байт збережено завдяки @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 байт)

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 байт

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

Це моя перша спроба коду гольфу, тому я впевнений, що це можна покращити. Мені б хотілося, щоб не встановлювали межі, але, схоже, matplotlib не може виявити, що я побудував кола, де я це робив. Без встановлення xlim () та ylim () він показує лише два нижні кола.

Вихід:

Редагувати: виправлено колір меж і вилучено цифри галочок. Треба сказати, що matplotlib дуже густо сформульований і не надто дружній із зміною кольорів осі.

Поголив 3 байти завдяки @DJMcMayhem

Редагувати: Зняв два байти, встановивши мої кліщі як кортеж всередині функцій set_ticks.

Bash + ImageMagick, 233 226 символів

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:

Вибірка зразка:

Bash + ImageMagick, 215 символів

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:

Власник запитання ще не відповів на запитання про згладжування та деякі інші рішення також мають додаткові сірі відтінки, додані анти-згладжуванням, тому наразі це коротше виглядає також прийнятним.

Вибірка зразка:

Рубі, 144 166 164 148 144 байт

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

Вихід:

Редагувати: тепер є сірі лінії ліній.

PNG, 105 100 байт

   (тобто цей файл зображення)

Враховуючи, що дозволено використання HTML та інших мов непрограмування , мені було цікаво побачити, наскільки я можу прослухати звичайне зображення, що відображається у браузері, щоб послужити базовим порівнянням. Результат стискається за допомогою інструментів з відкритим кодом optipng ( -o7 -zm1-9 -strip all) та pngwolf . Я також експериментував із зопфліпгом , але результати були більшими. Інші інструменти стиснення із закритим кодом можуть змогти відголити ще пару байтів.

Дані зображення в base64:

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

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

Редагування Я змусив точки торкатися комірки зверху та знизу, щоб викликати більше повторюваності у піксельній схемі та, таким чином, покращити коефіцієнт стиснення. Але не хвилюйтеся, крапка все ще заповнює лише (7 * 9) / (9 * 9) ≈ 78% її комірки.

Нестандартний PNG, 88 байт

Як вказував @anatolyg , є певний потенціал для гольфу, видаляючи шматок IEND (12 байт). Технічно IEND вимагається стандартом . Однак кожен фрагмент PNG містить свій власний розмір та інформацію про контрольну суму. Тому абсолютно не потрібно мати кінцевий маркер. І справді, всі перевірені браузерами можуть без проблем відображати зображення.

На жаль (або на щастя), це нестандартне зображення відхилено imgur, тому я не можу його фактично завантажити. Це кодування base64:

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

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

Октава , 127 124 байти

Видалено 3 байти завдяки Луїсу. gridдостатньо (замість 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

Виходи (після збереження):

Зауважте, що на виході відображаються сірі лінії сітки у вікні сюжету. Вони стають чорними при збереженні (чомусь).

Ну, це було довго і безладно! Довелося пройти безліч модифікацій, щоб зробити це дотриманням специфікацій.

Пояснення та, сподіваємось, гольф, що підійде ...

Обробка, 212 198 байт

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

В основному ми використовуємо просту обробку, щоб намалювати білий фон, потім встановивши прозорість прямокутників, які використовуються для сітки, та намалювавши їх штрихи сірим кольором. Продовжуємо, визначаючи прямокутник, знову встановлюючи значення заливки для заповнення кіл чорним кольором та визначаючи круги п'яти.

Вуаля!

Ви можете додати

strokeWidth(2); 

або більше, щоб краще бачити колір штрихів.

(Це мій перший Code-Golf, я сподіваюся, що я все зробив правильно.)

EDIT: Спасибі Kritixi Lithos! Видалено нові рядки, змінено на int f = 25 та використано -1 у фоновому режимі (float)

Тікз, 193 175 170 байт

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

Ось вихід:

MATL , 74 69 68 64 62 байт

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

Спробуйте в MATL Online! (Це займає кілька секунд.)

Вихід від онлайн-перекладача:

Обробка, 134 байти

Натхненний @Zep, ось мій однорядний обробник (а також мій гольф першого коду):

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

Дякуємо @Kritixi Lithos за його блискучі поради щодо гоління кількох байтів!

LaTeX + Tikz, 155 байт

\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 байт

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, що знаходиться в блоці "Область приватного користування") - код символу для символу кола. Якщо розмістити його в рядку, теж буде працювати, але оскільки він кодується як 3 байти в UTF-8, він буде однакової довжини (і не відображатиметься тут правильно).

C #, 333 байти

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

Повна / відформатована версія:

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

Ідея проста: ми створюємо графічний об’єкт із зображення і використовуємо його, щоб зробити зображення білим. Потім переведіть петлю на кожен квадрат зображення, малюючи обмежуючий прямокутник. Якщо це одна з місць точки, ми також малюємо це. Нарешті, ми зберігаємо зображення у файлі і даємо Windows вирішити, як його відкрити, у моєму випадку воно відкривається за допомогою програми перегляду фотографій Windows.

Використання Processдля показу зображення та збереження у файлі набагато коротше, ніж створення віконних форм або WPF-програми через всі різні класи та додатковий пух, необхідний для їх створення.

Вихід:

PHP, 221 + 2 байти

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

Зберегти у файл; дзвінок у браузері. Якщо ваш веб-переглядач відображає обман,
вставте header("Content-Type:image-png");раніше imagepng($i);.

Точки не дуже круглі; це пов'язано з невеликими пропорціями.

зламатися

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

Я думаю, що це 0x4c4b40кваліфікується як приблизна сіра. Якщо ні, додайте чотири байти.

R 313 236 байт

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

Перероблений код, заснований в основному на коментарях від @ user2390246, зберігав 77 байт. Багато вдячний за допомогу.

Також хочемо додати виклик до коротшого рішення R від @mschilli. Він показує елегантний спосіб вирішення проблеми R графічних значень за замовчуванням.

Вихід

Переходить до імен файлів "r". Опущення та розширення врятувало мене чотири байти. Але тоді мені довелося відредагувати розширення файлу назад на "bmp", щоб завантажити його. Тож, можливо, я не повинен отримати кредит за ці чотири байти.

Коментар

Я подумав собі: "Ця графіка - це не що інше, як простий графік з п'ятьма точками. Має бути простою справою реалізувати мову мовою з надійними можливостями графіки даних. Давайте спробуємо це в Р." Але тоді мені довелося витратити близько 80% байтів, просто працюючи навколо графічних значень R за замовчуванням.

Якийсь неправильний інструмент для роботи ....

Я не міг знайти менш детальний спосіб гарантувати розмір і розмір графіки, ніж зателефонувавши до конструктора bmp, а потім до dev.off (). Комбінація становить 25 байт. Якщо ваш сеанс R налаштований правильно, ви можете отримати графіку, яка виглядає більш-менш коректно, не витрачаючи цих байтів, але це не є надійним або послідовним.

TI-BASIC, 218 140 137 байт

Примітка: цей кількість байтів трохи завищена. Програма використовує лише 85 лексем, але це збережено в 137 байтах. Крім того, якщо ви використовуєте небарвний калькулятор, ви можете зберегти ще 4 жетони, оскільки вам не потрібно вказувати колір (який за замовчуванням синій), але я не знаю, чи їх екрани достатньо великі для це завдання, оскільки я не маю жодного.

prgmHACKER (138 байт, 86 лексем):

{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

Для правильного відображення ця програма вимагає, щоб Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1. dX також потрібно правильно встановити, але калькулятор робить це для вас, коли ви встановлюєте будь-яку іншу змінну вікна. Я не міг побачити, скільки простору використовували ці змінні в оперативній пам'яті.

Крім того, параметри формату повинні бути {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Background: OFF}, але це змінені значення і не потребують додаткового місця в залежності від налаштування.

R, 119 114 111 байт

(Танс на @JayCe, щоб зберегти мені 3 байти)

Не коротше, ніж інше рішення R , але зовсім інший підхід:

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

Використовується макет, в якому 4 перші ділянки - це порожні комірки, а 5 інших - пункти з ними.

Excel VBA, 180 байт

Анонімна функція негайного вікна VBE, яка не приймає вводу та виводить об'єкт робочого листа за замовчуванням ( 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

Коментована версія

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

Вихід

-6 байт для використання [{21,32,13,23,33}]надSplit("21 32 13 23 33")

-2 байти для використання Mid(s,2)понадRight(s,1)

-3 байти для використання (s\10)понадLeft(s,1)

Октава 107 94 103 байт

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

або

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

обидва рішення - 103 байти.

Apple Swift (iOS - CoreGraphics / QuartzCore) - 832 байт

Я малював форму повністю за допомогою Quartz для пристрою Apple iOS. На жаль, це не особливий розмір мови, тому результат досить великий, але це настільки мало, як я можу його отримати.

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

Більш прочитана версія для всіх, хто цікавиться:

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

Ось вихід, отриманий в iOS Simulator:

Рубі з взуттям, 118 символів

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

Біт перевірка запозичені з RJHunter «s коментар зробив на Mark Thomas » s рішення Рубі .

Вибірка зразка:

SVG + HTML, 146 138 135 133 байт

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

Завдяки поблажливому партеру HTML, xmlns="http://www.w3.org/2000/svg"декларацію можна опустити, а також цитати атрибутів та тег завершення. Ця версія стосується деяких питань інших HTML-рішень:

• "Крапка" гарантовано заповнить щонайменше 40% своєї комірки (§1)
• Він не використовує зовнішню графіку, наприклад шрифтові гліфи (§2, §6)
• Сітка ідеально квадратна (§ 5)

Редагуйте Поголені 8 байтів, використовуючи той факт, що субпасти не потрібно закривати, щоб їх заповнити .

Редагувати Відповідно до граматики svg , не потрібно розлучати нецифрові знаки комою ( .5,.5). Я також відмовився від явного заповнення, щоб я міг змінити напрямок малювання однієї лінії з негативної на позитивну, зберігаючи тире. І нарешті, я налаштував підрахунок, щоб не містити зворотного нового рядка, вибачте за цю помилку-новачка.

Редагувати Навчаючись з іншої відповіді про codegolf, я замінив фінал 9 />на 9>. Це чудово працює у всіх перевірених браузерах.

Python 3 + PyGame, 238 байт

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

Здається, довільні константи від мене намагаються зробити зображення максимально великим, не жертвуючи байтами.

З символами, що не друкуються, 229 байт

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

Я замінив списки літеральними байтами, що зберігає купу символів, але символи, що не друкуються, не можуть бути відображені належним чином. Я замінив символи, що не друкуються, їх графічними еквівалентами U + 2400-U + 2421 для цілей відображення.