Zadanie: wyślij flagę szwajcarską.

Happy Swiss National Day / Schweizer Bundesfeiertag / Fête nationale suisse / Festa nazionale svizzera / Fiasta naziunala svizra!

Szczegóły: Flaga składa się z białego #FFFFFFkrzyża ( ) na czerwonym #FF0000tle ( ). Krzyż składa się z kwadratu 6x6 z ramionami o rozmiarze 6x7 przyklejonymi z każdej strony. Krzyż znajduje się na środku kwadratowego tła o wymiarach 32 x 32, w odległości 6 jednostek z każdej strony. ( Źródło )

Rozmiar wyjściowy może zostać wybrany przez uczestnika, ale obraz musi dokładnie pasować do tych proporcji, co oznacza, że ​​jego rozmiar musi być wielokrotnością 32.

Minimalna wersja wyglądałaby tak:

SVG (HTML5), 94 83 82 64 bajty

<svg><path d=M0,0V32H32V0M6,13h7V6h6v7h7v6H19v6H13V19H6 fill=red

Zaoszczędź 2 bajty dzięki @ThePirateBay. Zaoszczędzono 1 bajt dzięki @ATaco. Zaoszczędzono 18 bajtów dzięki @CraigAyre wskazując, że obraz 32 × 32 jest akceptowalny. Jak wskazał @Shaggy, zakłada to, że twoje domyślne tło jest białe; dodaj 22 bajty dla flagi, która działa na dowolnym tle:

<svg><path d=M0,0V32H32V0 fill=red /><path d=M6,13h7V6h6v7h7v6H19v6H13V19H6 fill=#FFF

x86-16 Kod maszynowy dla DOS, 43 bajty

               ; Draw 32x32 red square
B8 0C 28          mov  ax, 0x0C28   ; AL == color red, AH == set pixel function
B9 00 1F          mov  cx, 31
               DrawBox:
BA 00 1F          mov  dx, 31
               DrawRow:
CD 10             int  0x10
4A                dec  dx
75 FB             jnz  DrawRow
E2 F6             loop DrawBox

               ; Draw the interior white cross
B0 0F             mov  al, 0x0F    ; high byte already set
B1 06             mov  cl, 6       ; high byte already 0
               DrawCross:
B2 0D             mov  dl, 13      ; high byte already 0
               DrawCrossInner:
CD 10             int  0x10        ; plot CX, DX
87 D1             xchg dx, cx
CD 10             int  0x10        ; plot DX, CX
87 D1             xchg dx, cx
42                inc  dx
80 FA 12          cmp  dl, 13+6
75 F2             jne  DrawCrossInner
41                inc  cx
80 F9 19          cmp  cl, 6+(32-6-6)
75 EA             jne  DrawCross

C3                ret

Powyższy kod został zaprojektowany jako plik COM, a następnie uruchomiony w systemie DOS. Wywołuje usługi wideo ROM BIOS, aby wykreślić poszczególne piksele flagi, tworząc reprezentację szwajcarskiej flagi 32 × 32 w lewym górnym rogu ekranu.

Kod zakłada, że ​​tryb wideo jest już ustawiony na tryb 0x13, co oznacza również, że wymaga wyświetlacza VGA. Można użyć innych trybów wideo, ale wymaganie VGA daje dwie rzeczy: (1) kwadratowe piksele i (2) domyślną paletę, która zawiera prawdziwie 100% czerwony ( 0xFF0000) (co oznacza, że ​​nie musisz marnować bajtów na zmianę palety zabarwienie). Dlatego przed uruchomieniem tego programu należy przełączyć wyświetlacz w tryb 0x13; poniższy kod to wszystko, czego potrzebujesz:

mov  ax, 0x13
int  0x10

Kod nie przyjmuje innych założeń i powinien działać na dowolnym sprzęcie kompatybilnym z x86 w systemie operacyjnym kompatybilnym z DOS.

Jednak program kończy się natychmiast po narysowaniu flagi, więc monit DOS będzie zwykle drukowany ponownie w lewym górnym rogu ekranu, zakrywając kilka górnych wierszy flagi. Dlatego jeśli chcesz dziwić się prawdziwemu wyjściu, musisz zawiesić / wstrzymać system przed jego RETurnowaniem. Oto zrzut ekranu tego, jak to wygląda, na maszynie wirtualnej FreeDOS:

Możliwe, że będzie można pograć w golfa dalej, zapisując dane pikseli bezpośrednio w buforze wideo, zwłaszcza, że ​​już zakładam tryb 0x13. Jeszcze tego nie próbowałem. INT 0x10jest już dość krótką instrukcją, ale jeśli mogę użyć jednobajtowych instrukcji łańcuchowych do zapisania danych pikseli bezpośrednio do pamięci, to może to spowodować znaczne oszczędności kodu.

MATL , 29 bajtów

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

Wypróbuj w MATL Online!

Wyjaśnienie

2Y6     % Push predefined literal: 3×3 matrix [0 1 0; 1 1 1; 0 1 0]
6t&Y"   % Repeat each entry 6 times in the two dimensions. Gives an 18×18 matrix
OJQh    % Push [0 1j+1]. Used as an index, this means [0 1 ... end+1]. Indexing
        % is 1-based and modular, so 0 is the same as end
t3$)    % Apply that index in the two dimensions. This extends by 1 entry in 
        % each dimension, so that the arms have length 7. Gives a 20×20 matrix
6thYa   % Pad with 6 zeros in the two dimensions. Gives a 32×32 matrix
Q       % Add 1. The matrix now contains values 1 (will become red) and 2 (white)
K7hBo   % Convert array [4 7] to binary. Gives [1 0 0; 1 1 1], to be used as
        % colormap. First row is red, second is white
YG      % Show image using colormap

Java 8, 246 + 42 = 288 bajtów

Dzięki @Aaron za -64 bajty.
-4 bajty przez wyjście do pliku abez rozszerzenia.

import java.awt.*;import java.awt.image.*;
x->{BufferedImage i=new BufferedImage(32,32,1);Graphics g=i.getGraphics();g.setColor(Color.RED);g.fillRect(0,0,32,32);g.setColor(Color.WHITE);g.fillRect(13,6,6,20);g.fillRect(6,13,20,6);javax.imageio.ImageIO.write(i,"png",new java.io.File("a"));}

Wyrażenie Lamba, które można przypisać do funkcjonalnej metody interfejsu, która zgłasza wyjątek. Tworzy plik obrazu o nazwie a(plik obrazu) w katalogu z tym plikiem.

Otaczający kod użyty do uruchomienia: Wypróbuj online!

Bez golfa

x->{
    BufferedImage i=new BufferedImage(32,32,1);
    Graphics g=i.getGraphics();
    g.setColor(Color.RED);
    g.fillRect(0,0,32,32);
    g.setColor(Color.WHITE);
    g.fillRect(13,6,6,20);
    g.fillRect(6,13,20,6);
    javax.imageio.ImageIO.write(i,"png",new java.io.File("a"));
}

Wynik

Siatka zapewniona przez podgląd obrazu IntelliJ IDEA (najwyraźniej).

Excel VBA, _{86 85} 79 bajtów

Kod

Anonymous VBE funkcja natychmiastowego okno, że nie bierze wejścia i wyjścia szwajcarskiej flagi na przedziale [A1:F32]od ActiveSheetobiektu. Działa to najpierw poprzez wyrównanie komórek do kwadratu, a następnie narysowanie czerwonego obszaru, a na koniec narysowanie białego krzyża.

Cells.RowHeight=48:[A1:AF32].Interior.Color=255:[G14:Z19,N7:S26].Interior.Color=-1

^{Zwróć uwagę, że układy, które usuwają etap barwienia „krzyża” flagi szwajcarskiej po umieszczeniu czerwonego tła, są w rzeczywistości dłuższe niż powyższa konfiguracja, ponieważ wymagają co najmniej 16 adresów komórek, które koordynują z 8 odrębnymi regionami flaga}

-1 bajtów dzięki @ Greedo's za RowHeight=48ponadColumnWidth=2

-6 Bajtów dzięki za @ Greedo's -1zamiastrgbWhite

Wynik

C ++, SFML, 406 399 394 bajtów

-2 bajty dzięki pdpi
-10 bajtów dzięki Zacharý

SFML (Simple and Fast Multimedia Library) to biblioteka C ++ napisana w celu ułatwienia rozwoju gier wideo i programów multimedialnych

Kod :

#include<SFML\Graphics.hpp>
using namespace sf;int main(){for(RenderWindow t(VideoMode(128,128),"");t.isOpen();){t.clear();RectangleShape r({128.f,128.f});r.setFillColor(Color::Red);t.draw(r);r.setFillColor(Color::White);r.setPosition({24.f,52.f});r.setSize({80.f,24.f});t.draw(r);r.rotate(90);r.setPosition({76.f,24.f});t.draw(r);t.display();for(Event e;t.pollEvent(e);)if(!e.type)t.close();}}

Flaga zostanie wyświetlona w oknie 128 x 128. Twój system operacyjny musi mieć możliwość wyświetlania okna 128 x 128 (mój Win8.1 nie może wyświetlać przy mniejszej szerokości)

OSTRZEŻENIE : możesz dodać te 2 wiersze kodu: t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);aby procesor nie nagrzewał się po uruchomieniu kodu. Nie umieściłem ich w oryginalnym kodzie z powodów golfowych.

Braindraw, 227 bajtów (niekonkurencyjny) (zaktualizowano, aby faktycznie działał)

Wersja bez golfa (241 bajtów)

r<<^++++++++[-^++++v]^[->>[>]>++++++++[-<++++>]<[<]<]>>[[-vv[v]-[^]^]>]vv<[<]>>>>>>>>>>>>>>vvvvvvg<<^^++++++[->>[>]>+++++[-<++++>]<[<]<]>>[[-vv[v]b-g-[^]^]>]<vv[<]><<<<<<<vvvvvvv<<^^++++++[-vv[v]++++++++++++++[^]^]vv[[->>[>]b[+]-g[+]-[<]<]v]

Wersja lekko golfowa (227 bajtów)

r<<^++++++++[-^++++v]^[->>[>]>++++++++[-<++++>]<[<]<]>>[[-vv[v]-[^]^]>]vv<[<]g>>>>>>>>>>>>vvvv++++++[->>[>]>+++++[-<++++>]<[<]<]>>[[-vv[v]b-g-[^]^]>]<vv[<]<<<<<<vvvvv<<++++++[-vv[v]++++++++++++++[^]^]vv[[->>[>]b[+]-g[+]-[<]<]v]

Braindraw to język programowania mojego własnego projektu. Dzisiaj o 15:08 mam działającego tłumacza i sprawdziłem, czy program działa poprawnie. Jednak tłumacz nie istniał przed rozpoczęciem tego konkursu, więc nie konkuruję.

Braindraw jest taki sam jak Brainf ***, tyle że działa na trzech dwuwymiarowych tablicach, a nie na jednej jednowymiarowej macierzy. Te tablice nazywane są r, gib, i działają jak kanały koloru zielonego i niebieskiego czerwonego. Operator r przesuwa wskaźnik na czerwony kanał itp. W górę to ^, w dół to v.

TI-BASIC (tylko TI-84 Plus C (S) E), 58 bajtów

:For(A,0,31
:For(B,0,31
:Pxl-On(A,B,RED
:End
:End
:For(A,6,25
:For(B,13,18
:Pxl-Off(A,B
:Pxl-Off(B,A
:End
:End

Mathematica, 83 bajty

R=Rectangle;Graphics[{Red,{0,0}~R~{32,32},White,{6,13}~R~{26,19},{13,6}~R~{19,26}}]

następny jest tylko z @ ASCII (myślałem, że to żart, ale działa!)

Mathematica, 23 bajty

"CH"~CountryData~"Flag"

-10 bajtów od @Jonathan Frech

HTML + CSS, 15 + 117 bajtów = 132 bajty

Korzystanie z opakowania Flexbox z inset box-shadow.

b{display:flex;box-shadow:red 0 0 0 6px inset;padding:2px;width:28px;flex-wrap:wrap}a{border:solid red 4px;margin:3px

<b><a><a><a><a>

HTML + CSS, 18 + 139 137 122 bajtów = 140 bajtów

Poprzednia odpowiedź przy użyciu borderi pośrednie opakowanie Flexbox z przeczeniem margin.

i,b,a{display:inline-flex}i{border:solid red 6px}b{margin:-4px;width:28px;flex-wrap:wrap}a{border:solid red 4px;margin:3px

<i><b><a><a><a><a>

GraphicsMagick (?), 96 bajtów

gm convert -size 32x32 xc:red -fill #fff -draw "rectangle 13,6 18,25 rectangle 6,13 25,18" 1.bmp

Nie jestem pewien, jak grać w golfa z GM (czy należy to uważać za język?). Nie jestem również pewien, jak liczyć bajty tutaj ...

Po zainstalowaniu GM wpisz podany kod w Windows cmd, otrzymasz obrazek z nazwą 1.bmp. Możesz chcieć zmienić podwójny cytat na pojedynczy cytat, jeśli używasz bash (powinno działać, ale nie testowałem tego).

Dzięki Digital Trauma. użyj tylko jednego -drawzapisu 8 bajtów

JavaScript + HTML, 99 + 13 = 112 bajtów

Zapisano 2 bajty dzięki user2428118
Zapisano 2 bajty dzięki Matheus Avellar

JSFiddle

with(c.getContext`2d`)fillStyle='red',fillRect(0,0,32,32),clearRect(6,13,20,6),clearRect(13,6,6,20)

<canvas id=c>

Czysty JavaScript, 194 129 bajtów

JSFiddle

with(document.write`<canvas id=c>`,c.getContext`2d`)fillStyle='red',fillRect(0,0,32,32),clearRect(6,13,20,6),clearRect(13,6,6,20)

JavaScript (ES6) w HTML4 (?), 178 176 bajtów

document.write('<table cellspacing=0>'+[...Array(32)].map((_,y,p)=>p.map((_,x)=>`<td bgcolor=${x>5&&x<26&&y>12&&y<19||y>5&&y<26&&x>12&&x<19?'#fff':'red'}>`).join``).join`<tr>`)

Tak! Nie potrzebujemy <canvas>ani <svg>nawet <img>!

Dzięki Justin Mariner oszczędzasz 2 bajty.

Löve2D , 139 138 bajtów

l=love g=l.graphics c=g.setColor r=g.rectangle f="fill"w=255 l.draw=loadstring"c(w,0,0)r(f,0,0,32,32)c(w,w,w)r(f,13,6,6,20)r(f,6,13,20,6)"

Oszczędność jednego bajtu dzięki ThePirateBay

Bez golfa

function love.draw()
    love.graphics.setColor(255,0,0)
    love.graphics.rectangle("fill",0,0,32,32)
    love.graphics.setColor(255,255,255)
    love.graphics.rectangle("fill",13,6,6,20)
    love.graphics.rectangle("fill",6,13,20,6)
end

Python 3 , 190 bajtów

Zapisz dane wyjściowe jako image.xpmi otwórz w swoim ulubionym edytorze tekstu.

r=range;print('! XPM2\n32 32 2 1\nr c #FF0000\nw c #FFFFFF\n');d=[bytearray(b'r'*32)for _ in r(32)]
for i in r(20):
 for j in r(6):d[i+6][j+13]=d[j+13][i+6]=119
print(b'\n'.join(d).decode())

Wypróbuj online!

Wynik:

! XPM2
32 32 2 1
r c #FF0000
w c #FFFFFF

rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrwwwwwwwwwwwwwwwwwwwwrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrwwwwwwrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr

Perl 5 , 184 bajty

176 bajtów kod + 8 dla -Mutf8 -p.

Nie jestem do końca pewien, czy jest to wymagane, opiera się na dostarczaniu pustych danych wejściowych zgodnie z tym meta postem , który nie działa na TIO, więc dostarcza nową linię (która nie jest używana). Dane wyjściowe są wysyłane do terminala i wyglądają tak:

Proporcje powinny być skalowane w oparciu o przestrzeń jednego znaku będącą dwoma pionowymi „pikselami”.

%a=qw(R 101 W 107 A 101;97 B 91;107);$_=R.($a="32 
"x3).($b="13 W6 R13 
"x3)."6 A7▄W6 A7▄"."R6 
6 W20 "x2 ."R6 
6 B7▄W6 B7▄R6 
$b$a";s/\d+(.)/$1x$&/ge;s/\pL/[$a{$&}m/g

Wypróbuj online!

Możesz wyświetlić podgląd wyników, kopiując z TIO i wklejając tutaj (pokazuje znaki sterujące po najechaniu kursorem na element) .

GFA BASIC (Atari ST), 62 bajty

Ręcznie edytowany wpis w formacie .LST. Wszystkie linie kończą się CR, w tym ostatnia.

DEFFILL2
PBOX0,0,31,31
DEFFILL0
PBOX13,6,18,25
PBOX6,13,25,18

Rozszerzony i skomentowany:

DEFFILL 2         ! set fill color: default system color #2 is red (&H700)
PBOX 0,0,31,31    ! draw the red square
DEFFILL 0         ! set fill color: default system color #0 is white (&H777)
PBOX 13,6,18,25   ! draw a vertical white rectangle
PBOX 6,13,25,18   ! draw a horizontal white rectangle

Wynik

Dane wyjściowe to 32x32.

Uwaga: To rzeczywiście używa koloru „białego”, chociaż na emulatorze wygląda szaro (a także na prawdziwym, chyba że zmienisz jasność dość wysoko).

R 171 140 bajtów.

x = rep(c(6,13,19,26,19,13),e=2)
l=c(0,32)
par(bg="red",mar=0*1:4)
plot(0,0,'n',l,l,xaxs="i",yaxs="i")
polygon(x,c(x,x)[4:15],c="white",b=0)

(nieco) niespokojny:

x <- rep(c(6,13,19,26,19,13),each=2)
y <- c(x,x)[4:15] # index by 3 positions
par(bg="red",mar=c(0,0,0,0)) # prepare the plot space
plot(0,type='n', xaxs="i",yaxs="i",xlim=c(0,32),ylim=c(0,32))
polygon(x,y,col="white",border=0)

Dzięki @gregor za zapisanie niektórych bajtów

Uruchom!

Oktawa, 105 bajtów 73 bajty

_{Uwaga: dodano wiersze dla jasności, nieuwzględnione w liczbie bajtów}

x(32,32,3)=0;
x(:,:,1)=1;
x(7:26,14:19,:)=1;
x(14:19,7:26,:)=1;
imshow(x*255)

EDYCJA: dzięki flawr za zaoszczędzenie sporo bajtów!

Oto wynik na octave-online.net, dzięki sanchises

GIF, 97 bajtów

GIF87a    ð  ÿ  ÿÿÿ,         @„©Ëí£œ´Ú;ƒÞXmÞ!ŸŠcyŒj¨,àZê<Cô
:8nïtï‹é‚BJ1tì$1ËKSvb=_ÔªõŠe  ;

Tani i ciężki bajtowo, ale warto.

EDYCJA: Niektóre znaki nie są w powyższym kodzie, oto skrót do zrzutu heksowego GIF.

EDYCJA: skompresowany do 97 bajtów za pomocą narzędzia online.

HTML + JavaScript (ES6), 13 + 112 = 125 bajtów

C=c.getContext`2d`
C[s='fillStyle']='red'
C[r='fillRect'](0,0,32,32)
C[s]='#fff'
C[r](6,13,20,6)
C[r](13,6,6,20)

<canvas id=c>

HTML + JavaScript (ES6), 13 + 114 = 127 bajtów

with(c.getContext`2d`)fillStyle='red',fillRect(0,0,32,32),fillStyle='#fff',fillRect(6,13,20,6),fillRect(13,6,6,20)

<canvas id=c>

C # 265/266 209 bajtów

 using System;using c=System.Console;class P{static void Main(){for(int i=0,j;i<32;i++){for(j=0;j<32;j++){if((6<i&&i<26&&j>13&&j<19)||(6<j&&j<26&&i>13&&i<19))c.BackgroundColor=ConsoleColor.White;else c.BackgroundColor=ConsoleColor.Red;c.Write(" ");}c.WriteLine();}}}     

Napisałem znaki „spacji” w konsoli podczas zmiany koloru tła. Ale jeśli uważasz, że jest on zbyt wysoki i liczysz pojedynczy znak jako 8 x 16 pikseli, po prostu podwajasz wartości w pobliżu „j” w ten sposób (+ 1 bajt i +, c.ReadKey();więc się zatrzymuje):

  using System;using c=System.Console;class P{static void Main(){for(int i=0,j;i<32;i++){for(j=0;j<64;j++){if((6<i&&i<26&&j>26&&j<38)||(12<j&&j<52&&i>13&&i<19))c.BackgroundColor=ConsoleColor.White;else c.BackgroundColor=ConsoleColor.Red;c.Write(" ");}c.WriteLine();} c.ReadKey(); }}     

56 bajtów zapisanych dzięki TheLethalCoder

 namespace System{using static Console;class P{static void Main(){for(int i=0,j;i<32;i++,WriteLine())for(j=0;j<32;Write(""))BackgroundColor=(ConsoleColor)((6<i&i<26&j>13&j<19)|(j++<26&i>13&i<19&6<j​)?15:12);}}}

Tikz, 145 143 bajtów

\documentclass[tikz]{standalone}\begin{document}\tikz{\def~{)rectangle(}\fill[red](,~33,33);\fill[white](7,14~27,20)(14,7~20,27)}\end{document}

Tutaj jest „bez golfa”

\documentclass[tikz]{standalone}
\begin{document}
\tikz{
\def~{)rectangle(}
  \fill[red](,~33,33);
  \fill[white](7,14~27,20)(14,7~20,27)
}\end{document}

Tutaj jest trochę bardziej golfa

\documentclass[tikz]{standalone}
\begin{document}
\tikz{
  \fill[red](1,1)rectangle(33,33);
  \fill[white](7,14)rectangle(27,20)(14,7)rectangle(20,27)
}\end{document}

To sprawia, że ​​3 prostokąty to duży czerwony i dwa mniejsze białe na plus.

Oto jak to wygląda. Tak naprawdę nie wygląda inaczej niż inne.

R, 109 bajtów

par(mar=0*1:4,bg=2,xaxs="i",yaxs="i")
frame()
rect(a<-c(6,13)/32,rev(a),b<-c(26,19)/32,rev(b),c="white",b=NA)

Używa, frameaby uniknąć wstępnego ustawienia wykresu, ale domyślny region wydruku jest w przedziale [0,1] zamiast [0,32]. Wykorzystuje również fakt, że rectjest wektoryzowany. Domyślny rozmiar okna kreślenia to 7 cali x 7 cali. Wytwarza następujące:

R, 125 bajtów

png()
par(mar=0*1:4,bg=2,xaxs="i",yaxs="i")
frame()
rect(a<-c(6,13)/32,rev(a),b<-c(26,19)/32,rev(b),c="white",b=NA)
dev.off()

Domyślna wartość pngto kwadrat 480 x 480 pikseli. Dane wyjściowe to następujący plik png:

R, 112 bajtów

par(bg=2,mar=0*1:4)
plot(0:32,0:32,'n',xaxs="i",yaxs="i")
rect(c(6,13),c(13,6),c(26,19),c(19,26),c="white",b=NA)

Chociaż, aby zagwarantować współczynnik proporcji, potrzebujemy 5 dodatkowych bajtów w sumie 117:

par(bg=2,mar=0*1:4)
plot(0:32,0:32,'n',xaxs="i",yaxs="i",as=1)
rect(c(6,13),c(13,6),c(26,19),c(19,26),c="white",b=NA)

Z dużą inspiracją z odpowiedzi Alexa Axthelma i dzięki Rift za zaoszczędzenie jeszcze kilku bajtów.

Postscriptum, 301 286 187 bajtów

/m{moveto}def
/s{setrgbcolor}def
/r{rlineto}def
/c{closepath fill}def
1 0 0 s
0 0 m
0 320 r
320 0 r
0 -320 r
c
1 1 1 s
130 60 m
60 0 r
0 200 r
-60 0 r
c
60 130 m
0 60 r
200 0 r
0 -60 r c

Dzięki anonimowemu redaktorowi, który zaproponował redukcję 99 bajtów!

Czerwony , 79 bajtów

Kod:

view[base 32x32 red draw[fill-pen white pen off box 6x13 26x19 box 13x6 19x26]]

Wynik:

Wyjaśnienie:

view [              ; activate view engine
base 32x32 red      ; draw a 32 by 32 red box as base
 draw [             ; draw on top of the base
  fill-pen white    ; fill color is white
  pen off           ; turn off outline, alternatively could use white
  box 6x13 26x19    ; draw a horizontal rectangle, specified as 2 corners XxY
  box 13x6 19x26    ; draw vertical rectangle
]]

Mapa bitowa, 160 bajtów

Oto mapa bitowa z 1-bitową głębią kolorów, z 24-bitową definicją kolorów. Ostatnie sześć bajtów drugiej linii to paleta, a za nią tablica pikseli. Co cztery bajty zawiera cały rząd pikseli.

42 4D A0 00 00 00 00 00 00 00 20 00 00 00 0C 00
00 00 20 00 20 00 01 00 01 00 00 00 FF FF FF FF
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 07 E0 00 00 07 E0 00
00 07 E0 00 00 07 E0 00 00 07 E0 00 00 07 E0 00
00 07 E0 00 03 FF FF C0 03 FF FF C0 03 FF FF C0
03 FF FF C0 03 FF FF C0 03 FF FF C0 00 07 E0 00
00 07 E0 00 00 07 E0 00 00 07 E0 00 00 07 E0 00
00 07 E0 00 00 07 E0 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

Próbowałem skrócić końcowe zera, ale przeglądarki obrazów wymagają, aby dla całej kanwy zdefiniowano wystarczającą liczbę pikseli.

Python 2, 92 91 89 bajtów

r,w=' \0\0',' '*3
A,B=192*r,(13*r+6*w+13*r)*7
print"P6 "+"32 "*3+A+B+(6*r+20*w+6*r)*6+B+A

Wyjście jako binarne ppm, użycie:

python golf_swiss.py > swiss.ppm

Zwiększenie głębi kolorów pozwoliło mi wykorzystać przestrzeń dla maksymalnej wartości

Tcl / Tk, 94

Jeśli to działa na interaktywnej powłoki, można skrócić canvasdo cani griddogri

gri [can .c -bg red -w 32 -he 32]
lmap R {{8 15 28 21} {15 8 21 28}} {.c cr r $R -f #FFF -w 0}

Jeśli to działa na interaktywnej powłoki, można skrócić canvasdocan

grid [can .c -bg red -w 32 -he 32]
.c cr r 8 15 28 21 -f #FFF -w 0
.c cr r 15 8 21 28 -f #FFF -w 0

pack [canvas .c -bg red -w 32 -he 32]
.c cr r 8 15 28 21 -f #FFF -w 0
.c cr r 15 8 21 28 -f #FFF -w 0