Tarefa: Emita a bandeira suíça.

Feliz Dia Nacional da Suíça / Schweizer Bundesfeiertag / Fête nationale suisse / Festa nazionale svizzera / Fiasta naziunala svizra!

Detalhes: a bandeira consiste em uma #FFFFFFcruz branca ( ) em um #FF0000fundo vermelho ( ). A cruz consiste em um quadrado 6x6 com braços do tamanho 6x7 colados a cada lado. A cruz está no centro do plano de fundo quadrado de 32x32, com uma distância de 6 unidades para cada lado. ( Fonte )

O tamanho da saída pode ser escolhido pelo participante, mas a imagem deve corresponder exatamente a essas proporções, ou seja, seu tamanho deve ser um múltiplo de 32.

Uma versão mínima seria assim:

SVG (HTML5), 94 83 82 64 bytes

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

Economizou 2 bytes graças a @ThePirateBay. Guardou 1 byte graças a @ATaco. Economizou 18 bytes graças a @CraigAyre, indicando que uma imagem de 32 × 32 era aceitável. Conforme apontado por @Shaggy, isso pressupõe que seu plano de fundo padrão seja branco; adicione 22 bytes para um sinalizador que funcione em qualquer plano de fundo:

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

Código da máquina x86-16 para DOS, 43 bytes

               ; 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

O código acima foi projetado para ser montado como um arquivo COM e executado no DOS. Ele chama os serviços de vídeo ROM BIOS para plotar os pixels individuais da bandeira, formando uma representação 32 × 32 da bandeira Suíça no canto superior esquerdo da tela.

O código pressupõe que o modo de vídeo já esteja definido no modo 0x13, o que também significa que requer uma exibição VGA. Outros modos de vídeo podem ser usados, mas a exigência de VGA fornece duas coisas: (1) pixels quadrados e (2) uma paleta padrão que inclui um verdadeiro 100% vermelho ( 0xFF0000) (o que significa que você não precisa perder bytes alterando a paleta cores). Antes de executar este programa, você precisará, portanto, alternar sua exibição para o modo 0x13; o seguinte código é tudo o que você precisa para fazer isso:

mov  ax, 0x13
int  0x10

O código não faz outras suposições e deve ser executado em qualquer hardware compatível com x86 em um sistema operacional compatível com DOS.

No entanto, o programa termina imediatamente após o desenho da bandeira, de modo que o prompt do DOS será reimpresso normalmente no canto superior esquerdo da tela, cobrindo as poucas linhas superiores da bandeira. Portanto, se você quiser se maravilhar com a saída verdadeira, precisará interromper / pausar o sistema antes que ele seja RETprocessado. Aqui está uma captura de tela da aparência, executando em uma máquina virtual FreeDOS:

Pode ser possível resolver isso ainda mais, escrevendo dados de pixel diretamente no buffer de vídeo, especialmente porque já estou assumindo o modo 0x13. Ainda não tentei isso. INT 0x10já é uma instrução bastante curta, mas se eu puder usar as instruções da string de um byte para gravar dados de pixel diretamente na memória, isso poderá resultar em uma economia significativa de código.

MATL , 29 bytes

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

Experimente no MATL Online!

Explicação

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 bytes

Graças a @Aaron por -64 bytes.
-4 bytes, enviando para o arquivo asem extensão.

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

Uma expressão lamba que pode ser atribuída a um método de interface funcional que gera uma exceção. Cria um arquivo de imagem chamado a(um arquivo de imagem) no diretório que está executando este arquivo.

Código circundante usado para executá-lo: Experimente online!

Ungolfed

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

Resultado

Grade fornecida pela visualização da imagem do IntelliJ IDEA (aparentemente).

Excel VBA, _{86 85} 79 bytes

Código

Função de janela imediata VBE anônima que não recebe entrada e envia a bandeira suíça para o intervalo [A1:F32]do ActiveSheetobjeto. Isso funciona primeiro tornando as células quadradas, depois desenhando a região vermelha e finalmente desenhando na cruz branca.

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

^{Observe que os arranjos que removem a etapa de colorir a "cruz" da bandeira suíça depois de colocar o fundo vermelho são realmente mais longos que a configuração acima, pois exigem pelo menos 16 endereços de célula, que coordenam as 8 regiões distintas do bandeira}

-1 Byte graças a @ Greedo por RowHeight=48mais deColumnWidth=2

-6 Bytes graças a @ Greedo's em -1vezrgbWhite

Resultado

C ++, SFML, 406 399 394 bytes

-2 bytes graças a pdpi
-10 bytes graças a Zacharý

SFML (Simple and Fast Multimedia Library) é uma biblioteca C ++ criada para facilitar o desenvolvimento de videogames e programas multimídia

O código :

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

O sinalizador é exibido em uma janela de 128x128. Seu sistema operacional deve poder exibir uma janela de 128x128 (o meu Win8.1 não pode ser exibido com largura menor)

AVISO : você pode adicionar estas 2 linhas de código:, t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);para que sua CPU não aqueça quando você executar o código. Não os coloquei no código original por razões de golfe.

Braindraw, 227 bytes (Não concorrente) (Atualizado para realmente funcionar)

Versão não destruída (241 bytes)

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

Versão com pouco golfe (227 bytes)

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

Braindraw é uma linguagem de programação de meu próprio projeto. Hoje, às 15h08, eu tenho um intérprete ativo e verifiquei se o programa funciona corretamente. No entanto, o intérprete não existia antes do início da competição, portanto não estou competindo.

Braindraw é o mesmo que Brainf ***, exceto que ele opera em três matrizes bidimensionais, em vez de uma matriz unidimensional. Essas matrizes são chamadas de r, ge eb, e atuam como os canais de cores vermelho, verde e azul. O operador r move o ponteiro para o canal vermelho, etc. etc. Up is ^, down is v.

TI-BASIC (apenas TI-84 Plus C (S) E)), 58 bytes

: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 bytes

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

o próximo é de @ ASCII-only (eu pensei que era uma piada, mas funciona!)

Mathematica, 23 bytes

"CH"~CountryData~"Flag"

-10 bytes de @Jonathan Frech

HTML + CSS, 15 + 117 bytes = 132 bytes

Usando um wrapper flexbox com um 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 bytes = 140 bytes

Resposta anterior usando bordere um invólucro flexbox intermediário com negativo 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 bytes

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

Não sabe ao certo como jogar golfe com a GM (isso deve ser considerado um idioma?). Também não sei como contar bytes aqui ...

Com o GM instalado, digite o código fornecido no windows cmd, você obterá uma imagem com o nome 1.bmp. Você pode alterar aspas duplas para aspas simples se estiver usando o bash (deve funcionar, mas eu não testei isso).

Obrigado ao Digital Trauma. use apenas um -drawsalvar 8 bytes

JavaScript + HTML, 99 + 13 = 112 bytes

Guardado 2 bytes graças a user2428118
Guardado 2 bytes graças a 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>

JavaScript puro, 194 129 bytes

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) em HTML4 (?), 178 176 bytes

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

Sim! Nós não precisamos <canvas>nem <svg>nem mesmo <img>!

Graças a Justin Mariner, economize 2 bytes.

Löve2D , 139 138 Bytes

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

Guardado um byte graças a ThePirateBay

Ungolfed

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 bytes

Salve a saída como image.xpme abra com seu editor de texto favorito.

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

Experimente online!

Resultado:

! 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 bytes

Código de 176 bytes + 8 para -Mutf8 -p.

Não tenho certeza absoluta de que isso seja necessário, pois depende da entrada vazia, conforme esta meta post , que não funciona no TIO, portanto fornece uma nova linha (que não é usada). A saída é para o terminal e fica assim:

As proporções devem ser dimensionadas com base no espaço de um caractere, sendo dois 'pixels' verticais.

%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

Experimente online!

Você pode visualizar a saída copiando do TIO e colando aqui (isso mostra os caracteres de controle quando o mouse fica sobre o elemento) .

GFA BASIC (Atari ST), 62 bytes

Uma listagem editada manualmente no formato .LST. Todas as linhas terminam com CR, incluindo a última.

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

Expandido e comentado:

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

Resultado

A saída é 32x32.

NB: De fato, está usando a cor 'branca', embora pareça cinza no emulador (e também na coisa real, a menos que você aumente o brilho).

R, 171 140 bytes.

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)

(um pouco) não destruído:

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)

Obrigado a @gregor por salvar alguns bytes

Executá-lo!

Oitava, 105 bytes 73 bytes

_{Nota: feeds de linha adicionados para maior clareza, não incluídos na contagem de bytes}

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

EDIT: graças ao flawr por economizar bastante bytes!

Aqui está o resultado em octave-online.net, graças a sanchises

GIF, 97 bytes

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

Barato e pesado em bytes, mas vale a pena.

EDIT: alguns caracteres não estão no código acima, aqui está uma pasta para o hexdump do GIF.

EDIT: compactado até 97 bytes com a ferramenta online.

HTML + JavaScript (ES6), 13 + 112 = 125 bytes

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 bytes

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 bytes

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

Eu escrevi caracteres "espaço" no console enquanto mudava a cor de fundo. Mas se você acha que é muito alto e conta apenas um caractere como 8 x 16 pixels, basta dobrar os valores próximos a "j" assim (+ 1 byte e + c.ReadKey();para que pare):

  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 bytes economizados graças ao 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 bytes

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

Aqui está "não destruído"

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

Aqui é um pouco mais destruído

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

Isso torna três retângulos um grande vermelho e dois menores brancos para o plus.

Aqui está o que parece. Realmente não parece diferente dos outros.

R, 109 bytes

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)

Utilizado framepara evitar a predefinição de uma plotagem, mas a região de plotagem padrão está no intervalo [0,1] em vez de [0,32]. Também usa o fato de que recté vetorizado. O tamanho padrão da janela de plotagem é 7in x 7in. Emite o seguinte:

R, 125 bytes

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

O padrão para pngé um quadrado de 480x480 pixels. Saída é o seguinte arquivo png:

R, 112 bytes

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)

No entanto, para garantir a proporção, precisamos de mais 5 bytes, para um total de 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)

Com muita inspiração da resposta de Alex Axthelm , e obrigado a Rift por salvar mais alguns bytes.

Postscript, 301 286 187 bytes

/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

Obrigado ao editor anônimo que sugeriu uma redução de 99 bytes!

Vermelho , 79 bytes

Código:

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

Resultado:

Explicação:

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

Bitmap, 160 bytes

Aqui está um bitmap com profundidade de cor de 1 bit, usando uma definição de cores de 24 bits. Os últimos seis bytes da segunda linha são a paleta e a seguir, a matriz de pixels. A cada quatro bytes contém uma linha inteira de pixels.

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

Tentei truncar os zeros à direita, mas os visualizadores de imagens exigem que haja pixels suficientes definidos para a tela inteira.

Python 2, 92 91 89 bytes

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

Saída em ppm binário, uso:

python golf_swiss.py > swiss.ppm

Aumentar a profundidade da cor me permitiu usar o espaço para obter o valor máximo

Tcl / Tk, 94

Se for executado no shell interativo, é possível abreviar canvaspara cane gridparagri

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}

Se for executado no shell interativo, pode-se abreviar canvasparacan

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