“Hacker Amblemi” olarak da bilinen “Hacker Logosu” nu duymuş olabilirsiniz. Bu gibi görünüyor:

Bu, Yaşam Oyunu adı verilen matematiksel bir simülasyondan oluşan bir kalıptır. Planör, hareket eden en basit Yaşam kalıplarıdır ve tüm Yaşam kalıplarının en anında tanınanlarıdır.

Meydan okuma

Zorluk oldukça basittir: Hacker logosunu gösterin. Bu şöyle tanımlanır:

• Kenarlıklı 3x3 ızgara, beyaz arka plan ve gri kılavuz çizgileri.
• GoL planör deseninde düzenlenmiş beş siyah nokta.
• Başka hiçbir şey.

Kurallar

• Siyah noktalar doldurmalıdır % 40 - % 80 bireysel ızgara kutular.
• Amblemi grafik çıktıyla gösterecek, ancak ASCII resmini göstermeyeceksiniz .
• Çıktı en az 30x30 piksel olmalıdır .
• Çıktı yalnızca gri, siyah ve beyaz renklere sahip olmalıdır .
• Izgaradaki her ızgara kutusu aynı boyutta olacaktır. Izgara normal 3x3 kare olacaktır .
• Logoyu internetten veya dosya sisteminizden çekemezsiniz.
• Programınız logoyu boş bir ekranda / pencerede gösterecektir. Sonlandırırsa normal şekilde yapması gerekir.
• "Noktaların" mutlaka "daireler" anlamına gelmediğine dikkat edin. Bir "nokta", ızgara kutusunun ortasında bir yüzeyi olan ortalanmış tek bir geometrik şekildir. Örneğin, bir daire veya kare nokta olarak nitelendirilirken, iki üçgen veya bir dama tahtası olmayacaktır.

Kazanan

Bu kod golf olduğu için, her dilde en kısa cevap kazanır!

Lütfen cevabınıza programınızın çıktısının bir ekran görüntüsünü ekleyin.

Mathematica, 62 bayt

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

Mathematica, 71 bayt

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

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

Yorumlarından öneriler ekleyerek 4 bayt kurtardı.

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

Bu •, 2 bayt uzunluğunda olan ve HTML sözdiziminin zarifliğinden yararlanan UTF-8 karakterini kullanır .

GLSL (parça gölgelendirici), 278 235 256 bayt

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

İşlemde görün: http://glslsandbox.com/e#40717.2

Python 2 ,  169  140 bayt

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)

Gerçek boyut, 61'e 61, 300'den 400'e kadar daha büyük bir tuvalin içine çizilir:

Piksel ızgarasını gösteriliyor:

Noktalar, 19 x 19 beyaz dolum (144.4-288.8) veya her iki kenarlığı da içeren (176.4-352.8) 21 ile 21 arasında% 40 ile% 80 arasında 177 piksel kullanır.

Not: Program, çizim tamamlandığında tuval penceresini sonlandırır ve kapatır, manuel pencerenin kapatılmasını sağlar done().

turtlegrafiksel tanıtımı için geliştirilmiş bir Python paketidir. Bir kalem x,y=0,0300 x 400 piksellik bir tuvalin ortasında başlar (varsayılan olarak), upkalemi kaldırır, kalemi gotohareket ettirir, kalemin shapeşeklini adlandırılmış bir şekle ayarlar ( "square"varsayılan piksel genişliği 21 olan önceden tanımlanmış bir şekildir) ), coloriki parametrenin konturu (varsayılan olarak 1 genişliğinde) ayarlandığı ve doldurduğu rengi ayarlar; Bir bayt kullanarak kaydedilir (r,g,b)yerine tanımlama grubu seçeneği "white"ile [1,1,1]liste çarpma işlemi kullanılarak [1]*3. Sonunda dotverilen genişlikte piksel ve renkte bir nokta çizer. Noktanın varsayılan genişlik değeri nitelendirilemeyecek kadar küçük, 9bu yüzden onu estetik ve niteliksel hale getirdim 15. Noktanın rengi olabilir"black"ancak açılmış olan (r,g,b)demet 0,0,0iki bayt daha kısadır.

Kalemin sonunda herhangi bir noktadan uzağa hareket etmesi gerekir, aksi takdirde gri / beyaz kalem noktayı gizler.

Izgara bir div (kullanarak geçtiği /) ve mod ( %arasında) ibaşlayarak 8( ibaşlatılabilecektir edilir 9ancak başında indirildiği whiledöngü) ve aşağı doğru çalışma 0sonuçlarını dengelemek 2,1,0için -1,0,1kullanarak (1-...)kullanılarak ızgara boyutuna kadar her ölçekleme 20 faktörü ( 20-i/3*20gerçekte 20*(1-i/3)aynı olandan daha küçük bir bayt olduğuna dikkat edin %). Bu [alt-sol, orta-sol, üst-sol, alt-orta, orta-orta, üst-orta, alt-sağ, orta-sağ, üst-sağ] sırasını üretir ve " hasDot" değerlendirmesini gerektirir [1,0,0,1,0,1,1,1,0], ki bu 302yüzden kontrol erişilebilinir ikili olarak i^inci iki bileşeninin gücünü302bitsel kullanarak ve 302&2**i.

Applesoft BASIC , 479 476 516 515 483 482 bayt

^{-32 okunamayan değişken isimleri kullanarak: P
-1, çünkü Apple büyülü olmaya karar verdi ve örtük / var olmayan bir GOTO kullanmama izin verdi}

İşte çevreler kullanmayan bir çıktı örneği için kendi programım:

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

Çıktı:

IA-32 makine kodu, 81 80 bayt

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

Görüntüyü, sağlanan arabellekte PGM biçiminde döndüren bir fastcallişlevdir doit. Kullanımı:

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

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

Çıktı:

Çünkü 256x256 çözünürlük kullanılan o serin benim de pikselin endeksi bölme sağlar ecxkoordinatlara içine otomatik olarak yyer chve xiçinde cl. Ayrıca, PGM dosya formatı görüntü başlığında 255 sayısını gerektirir.

İç kareler 54x54'dür (hücrenin bölgeye göre% 41'i).

Kaynak kodu (Visual Studio tarafından derlenebilir):

    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;

Hücre modeli

0 1 0
0 0 1
1 1 1

7 bitlik bir "optimize edilmiş" bitmap ile gösterilebilir.

Bit ifadesi ile endekslenir y * 2 + x, (x,y)hücre konumudur. Bu ifade aynı indeksi 2 hücreye verir. Buradaki bit değerlerinin aynı olması şanslı bir tesadüf.

HTML ve CSS, 155 bayt

HTML’in sözdizimi hataları için gerçekten bağışlayıcı olduğu ortaya çıktı .

_{@Octopus sayesinde 1 byte kaydedildi · @Downgoat ile kaydedilen 1 byte · @StephenS sayesinde 2 byte kaydedildi}

_{@Ryan · @styfle sayesinde 3 bayt kurtarıldı · @Ferrybig sayesinde 4 bayt kurtarıldı}

_{@SteveBennett sayesinde 13 bayt kurtarıldı}

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

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 bayt

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

Bu benim ilk golf kod girişimi, bu yüzden geliştirilebileceğinden eminim. Sınırları belirlememeyi çok isterdim, ama görünüşe göre matplotlib benim yaptığım daireleri çizdiğimi tespit edemedi. Xlim () ve ylim () ayarını yapmadan sadece alttaki iki daireyi gösterir.

Çıktı:

Düzenleme: Kenarlıkların rengi düzeltildi ve onay numaralarını kaldırın. Matplotlib'in çok yoğun bir şekilde ifade edildiğini ve değişen eksen renkleriyle pek arkadaşça olmadığını söylemeliyim.

@DJMcMayhem sayesinde 3 byte kapalı tıraş edildi

Düzenleme: Kenelerimi set_ticks işlevlerinin içinde bir demet olarak ayarlayarak iki bayt çıkardı.

Bash + ImageMagick, 233 226 karakter

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:

Örnek çıktı:

Bash + ImageMagick, 215 karakter

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:

Soru sahibi henüz yanıtlamayan soruyu yanıtlamadı ve diğer bazı çözümlerde de kenar yumuşatma tarafından eklenen ek gri gölgeler var, bu nedenle şimdilik bu kısa olanı da kabul edilebilir görünüyor.

Örnek çıktı:

Ruby, 144 166 164 148 144 bayt

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

Çıktı:

Düzenleme: Şimdi gri kılavuz çizgileri var.

PNG, 105 100 bayt

   (yani bu görüntü dosyası)

HTML'ye ve diğer programlama dışı dillere izin verildiğini göz önünde bulundurarak, basit bir tarayıcıda görüntülenen görüntüyü ne kadar çok golf oynayabileceğimi, temel bir karşılaştırma olarak kullanabileceğimi merak ediyordum. Sonuç açık kaynak araçları optipng ( -o7 -zm1-9 -strip all) ve pngwolf ile sıkıştırılır . Ayrıca zopflipng ile denedim ama sonuçlar daha büyüktü. Diğer kapalı kaynaklı sıkıştırma araçları birkaç baytı daha tıraş edebilir.

Base64'teki resim verileri:

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

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

Düzenleme Piksel düzeninde daha fazla tekrarlanabilirliğe neden olmak ve böylece sıkıştırma oranını arttırmak için noktaların hücrenin üstüne ve altına dokunmasını sağladım. Ancak endişelenmeyin, bir nokta hala sadece (7 * 9) / (9 * 9) ≈ hücresinin% 78'ini doldurur.

Standart olmayan PNG, 88 bayt

@Anatolyg tarafından işaret edildiği gibi , IEND yığınını (12 bayt) kaldırarak bir miktar golf potansiyeli var. Teknik olarak, IEND standart tarafından istenmektedir . Ancak, her PNG öbeği kendi boyut ve sağlama toplamı bilgilerini içerir. Bu nedenle, bir son işaretçisine sahip olmak kesinlikle gerekli değildir. Gerçekten de, test ettiğim tüm tarayıcılar görüntüyü sorunsuz görüntüleyebilir.

Ne yazık ki (ya da neyse ki), bu standart olmayan resim imgur tarafından reddedilmiştir, bu yüzden aslında yükleyemiyorum. Bu base64 kodlamasıdır:

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

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

Octave , 127 124 bayt

Luis sayesinde 3 bayt kaldırıldı. gridyeterlidir (yerine 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

Çıkışlar (kaydedildikten sonra):

Çıkışın arsa penceresinde gri ızgara çizgileri gösterdiğine dikkat edin. Kaydederken siyaha dönüyorlar (nedense).

Bu uzun ve dağınıktı! Bu özelliklere uyması için birçok değişiklik yapmamız gerekti.

Açıklama ve umarım bazı golf geliyor ...

İşlem, 212 198 bayt

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

Temel olarak, beyaz bir Arkaplan çizmek için basit İşlemler kullanıyoruz, daha sonra ızgara için kullanılan dikdörtgenlerin saydamlığını ayarlıyor ve konturlarını gri çiziyoruz. Dikdörtgeni tanımlayarak, siyahları doldurmak için dolgu değerini tekrar ayarlayarak ve beşleri daireler tanımlayarak devam ediyoruz.

Voila

Ekleyebilirsin

strokeWidth(2); 

vuruşların rengini daha iyi görmek için

(Bu benim ilk Kod Golf'üm, umarım her şeyi doğru yapmışımdır.)

EDIT: Kritixi Lithos sayesinde! Yeni satırlar kaldırıldı, int f = 25 olarak değiştirildi ve arka planda -1 kullanıldı (kayan nokta)

Tikz, 193 175 170 bayt

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

İşte çıktı:

MATL , 74 69 68 64 62 bayt

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

MATL Online'da deneyin ! (Birkaç saniye sürer.)

Çevrimiçi tercümandan çıktı:

İşlem, 134 bayt

@Zep'ten ilham alan, işte benim tek kodlu işlemim (ve ayrıca ilk kod golfüm):

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'a birkaç byte'ı tıraş etmedeki mükemmel ipucuları için teşekkürler!

LaTeX + Tikz, 155 bayt

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

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 ("Özel Kullanım Alanı" bloğunda bulunan U + E2E1), bir daire sembolünün karakter kodudur. Bir dizgeye koymak da işe yarar, ancak UTF-8'de 3 bayt olarak kodlandığından, aynı uzunlukta olur (ve burada doğru şekilde görünmez).

C #, 333 bayt

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

Tam / Biçimli sürüm:

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

Fikir basit, görüntüden bir grafik nesnesi oluşturuyoruz ve görüntüyü tamamen beyaz yapmak için kullanıyoruz. Ardından sınırlayıcı dikdörtgeni çizen görüntünün her karesi üzerinde döngü yapın. Eğer bir noktanın konumlarından biriyse onu da çizeriz. Son olarak görüntüyü dosyaya kaydederiz ve pencerelerin nasıl açılacağına karar vermesine izin veririz, benim durumumda Windows Fotoğraf Görüntüleyicisi ile açılır.

ProcessGörüntüyü göstermek ve dosyaya kaydetmek için a kullanmak , tüm farklı sınıflar ve bunları oluşturmak için gereken ekstra kabartmalar nedeniyle, Windows formları veya WPF uygulaması oluşturmaktan çok daha kısadır.

Çıktı:

PHP, 221 + 2 bayt

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

Dosyaya kaydet; tarayıcıda arayın. Tarayıcınız anlamsız görünüyorsa, önce
takın .header("Content-Type:image-png");imagepng($i);

Noktalar çok yuvarlak değil; bunun nedeni küçük oranlar.

Yıkmak

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

Bunun 0x4c4b40yaklaşık gri olarak nitelendirildiğini düşünüyorum . Değilse, dört bayt ekleyin.

R 313 236 bayt

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

Daha fazla @ user2390246 adlı kullanıcının yorumlarına dayanarak revize edilmiş Kod, 77 byte tasarruf etti. Yardımın için çok teşekkür ederim.

Ayrıca, kısa R çözümüne @mschilli tarafından bir çağrı eklemek istiyorum. R grafik temerrüt problemine hitap etmenin zarif bir yolunu gösterir.

Çıktı

"R" adındaki bir dosyaya gider. Atlama ve uzatma bana dört bayt kazandırdı. Ancak daha sonra, yüklenmesini sağlamak için dosya uzantısını "bmp" olarak düzenlemek zorunda kaldım. Belki de bu dört bayt için kredi alamam.

yorum

Kendi kendime düşündüm, "Bu grafik beş noktadan oluşan basit bir grafikten başka bir şey değildir. Sağlam veri grafik yeteneklerine sahip bir dilde uygulamak için basit bir mesele olmalı. Hadi bunu R'de deneyelim." Ancak daha sonra R'nin grafik varsayılanları etrafında çalışan baytların% 80'ini sipariş etmek zorunda kaldım.

Tür iş için yanlış bir araç ....

Grafiğin boyutunu ve en boy oranını garanti etmenin daha az ayrıntılı bir yolunu bulamadım. Kombinasyon 25 baytlık hesap oluşturur. R oturumunuz doğru ayarlanmışsa, bu baytları harcamadan az çok doğru görünen bir grafik elde edebilirsiniz, ancak güvenilir veya tutarlı değildir.

TI-BASIC, 218 140 137 bayt

Not: Bu bayt sayısı biraz şişirilmiş. Program yalnızca 85 belirteç kullanır, ancak 137 bayt olarak kaydedilmiştir. Ayrıca, renkli olmayan bir hesap makinesi kullanıyorsanız, 4 belirteç daha kaydedebilirsiniz, çünkü rengi belirtmeniz gerekmez (varsayılan olarak mavi olan), ancak ekranlarının yeterince büyük olup olmadığını bilmiyorum. Bu meydan okuma, çünkü benim birine sahip değilim.

prgmHACKER (138 bayt, 86 belirteç):

{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

Düzgün görüntülemek için, bu program Xmin = Ymin = 0, Xmax = Ymax = 3, Xscl = Yscl = 1 olmasını gerektirir. DX'in de uygun şekilde ayarlanması gerekir, ancak başka bir pencere değişkenini ayarladığınızda hesap makinesi sizin için yapar. Bu değişkenlerin RAM'de ne kadar alan kullandığını göremedim.

Ayrıca, format ayarları {RectGC, CoordOff, GridLine, GridColor: MEDGRAY, Axes: OFF, ExprOff, BorderColor: 1, Arkaplan: OFF} olmalıdır ancak bunlar değiştirilmiş değerlerdir ve ayara bağlı olarak fazladan boşluk kullanmazlar.

R, 119 114 111 bayt

( Beni 3 bayttan kurtardığı için @JayCe'ye Thans )

Diğer R çözümünden daha kısa değil , tamamen farklı bir yaklaşım:

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

İlk 4 grafiğin boş hücreler, diğerlerinde ise 5 köşeli noktalar olan bir düzen kullanır.

Excel VBA, 180 bayt

Girdi almayan ve varsayılan çalışma sayfası nesnesine ( Sheet1) çıkan bir anonim VBE Acil pencere işlevi .

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

Yorumlanan Sürüm

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

Çıktı

-6 bit kullanmak [{21,32,13,23,33}]içinSplit("21 32 13 23 33")

Mid(s,2)Üzerinden kullanmak için -2 baytRight(s,1)

(s\10)Üzerinden kullanmak için -3 baytLeft(s,1)

Octave 107 94 103 bayt

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

veya

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

her iki çözüm de 103 bayttır.

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

Şekli bir Apple iOS cihazı için tamamen Quartz kullanarak çizdim. Maalesef bu, özellikle dikkatli bir dil değil, bu yüzden sonuç oldukça büyük, ama bu alabildiğim kadar küçük.

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

İlgilenen herkes için daha okunaklı bir sürüm:

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

İOS Simulator'da üretilen çıktı:

Ayakkabılı Yakut, 118 karakter

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 ödünç Kontrolden RJHunter 'ın comment yapılan Mark Thomas s' Yakut çözümü .

Örnek çıktı:

SVG + HTML, 146 138 135 133 bayt

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

Yumuşak HTML ayrıştırıcı sayesinde, xmlns="http://www.w3.org/2000/svg"bildirimin yanı sıra öznitelik tırnaklarını ve kapanış etiketini de ihmal edebilirsiniz. Bu sürüm diğer HTML çözümlerinin bazı konularını ele almaktadır:

• Hücresinin en az% 40'ını dolduracak bir "nokta" garantilidir (§1)
• Dış grafikleri kullanmaz, örneğin font glifleri (§2, §6)
• Izgara mükemmel kare (§5)

Düzenle Alt yolların doldurulması için kapatılması gerekmediği gerçeğinden yararlanarak 8 bayt kapalı Tıraş .

Düzenleme göre svg dilbilgisi , bir virgül ile dışı basamak ayırmak için gerekli değildir ( .5,.5). Ayrıca, açık dolguyu da terk ettim, böylece bir çizginin çizme yönünü negatiften pozitifine değiştirerek bir çizgi kaydedebilirim. Ve son olarak, bu çaylak hatası için özür dilerim sayımı sonunda yeni bir satır içermeyecek şekilde ayarladım.

Edit Codegolf'ta başka bir cevaptan Öğrenme , final 9 />ile yer değiştirdim 9>. Bu, test edilen tüm tarayıcılarda iyi çalışır.

Python 3 + PyGame, 238 Bayt

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

Görünüşe göre keyfi sabitler benden, baytlardan ödün vermeden görüntüyü mümkün olduğunca büyük yapmaya çalışıyorum.

Yazdırılmayan karakterlerle, 229 Bayt

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

Listeleri bir sürü karakter kaydeden bayt değişmezleriyle değiştirdim, ancak yazdırılmayan karakterler burada düzgün bir şekilde görüntülenemiyor. Baskısız karakterleri, grafiksel eşdeğerleri U + 2400-U + 2421 ile görüntüleme amaçlı olarak değiştirdim.