Tarea: Mostrar la bandera suiza.

Feliz Día Nacional de Suiza / Schweizer Bundesfeiertag / Fête nationale suisse / Festa nazionale svizzera / Fiasta naziunala svizra!

Detalles: La bandera consiste en una #FFFFFFcruz blanca ( ) sobre un #FF0000fondo rojo ( ). La cruz consiste en un cuadrado de 6x6 con brazos de tamaño 6x7 pegados a cada lado. La cruz está en el centro del fondo cuadrado de 32x32 y tiene una distancia de 6 unidades a cada lado. ( Fuente )

El participante puede elegir el tamaño de salida, pero la imagen debe coincidir exactamente con estas proporciones, esto significa que su tamaño debe ser un múltiplo de 32.

Una versión mínima se vería así:

SVG (HTML5), 94 83 82 64 bytes

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

Guardado 2 bytes gracias a @ThePirateBay. Guardado 1 byte gracias a @ATaco. Ahorró 18 bytes gracias a @CraigAyre que señaló que una imagen de 32 × 32 era aceptable. Como señaló @Shaggy, esto supone que su fondo predeterminado es blanco; agregue 22 bytes para una bandera que funcione en cualquier fondo:

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

Código de 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

El código anterior está diseñado para ensamblarse como un archivo COM y luego ejecutarse bajo DOS. Invoca los servicios de video ROM BIOS para trazar los píxeles individuales de la bandera, formando una representación de 32 × 32 de la bandera suiza en la esquina superior izquierda de la pantalla.

El código supone que el modo de video ya está configurado en modo 0x13, lo que también significa que requiere una pantalla VGA. Se podrían usar otros modos de video, pero requerir VGA le da dos cosas: (1) píxeles cuadrados y (2) una paleta predeterminada que incluye un verdadero rojo 100% ( 0xFF0000) (lo que significa que no tiene que perder bytes cambiando la paleta colores). Antes de ejecutar este programa, deberá cambiar su pantalla al modo 0x13; el siguiente código es todo lo que necesitas para hacer eso:

mov  ax, 0x13
int  0x10

El código no hace otras suposiciones y debe ejecutarse en cualquier hardware compatible con x86 en un sistema operativo compatible con DOS.

Sin embargo, el programa finaliza inmediatamente después de dibujar la bandera, por lo que la solicitud de DOS normalmente se volverá a imprimir en la esquina superior izquierda de la pantalla, cubriendo las pocas líneas superiores de la bandera. Por lo tanto, si desea maravillarse con la salida real, debe colgar / pausar el sistema antes de que se RETactive. Aquí hay una captura de pantalla de cómo se ve, ejecutándose en una máquina virtual FreeDOS:

Es posible que esto se reduzca aún más al escribir datos de píxeles directamente en el búfer de video, especialmente porque ya estoy asumiendo el modo 0x13. Aún no lo he intentado. INT 0x10ya es una instrucción bastante corta, pero si puedo usar las instrucciones de cadena de un byte para escribir datos de píxeles directamente en la memoria, eso podría generar un importante ahorro de código.

MATL , 29 bytes

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

¡Pruébalo en MATL Online!

Explicación

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

Gracias a @Aaron por -64 bytes.
-4 bytes enviando al archivo asin extensión.

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

Una expresión lamba que se puede asignar a un método de interfaz funcional que arroja una excepción. Crea un archivo de imagen llamado a(un archivo de imagen) en el directorio que ejecuta este archivo.

Código circundante utilizado para ejecutarlo: ¡ Pruébelo en línea!

Sin golf

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

Rejilla proporcionada por la vista previa de la imagen IntelliJ IDEA (aparentemente).

Excel VBA, _{86 85} 79 Bytes

Código

Función de ventana inmediata anónima VBE que no toma entrada y emite la bandera suiza en el rango [A1:F32]del ActiveSheetobjeto. Esto funciona haciendo primero las celdas cuadradas, luego dibujando la región roja y finalmente dibujando en la cruz blanca.

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

^{Tenga en cuenta que los arreglos que eliminan el paso de colorear la "cruz" de la bandera suiza después de poner el fondo rojo son en realidad más largos que la configuración anterior, ya que requieren al menos 16 direcciones de celda, que se coordinan con las 8 regiones distintas de la bandera}

-1 Byte gracias a @ Greedo's por RowHeight=48más deColumnWidth=2

-6 Bytes gracias a @ Greedo's por su -1lugarrgbWhite

Salida

C ++, SFML, 406 399 394 bytes

-2 bytes gracias a pdpi
-10 bytes gracias a Zacharý

SFML (Simple and Fast Multimedia Library) es una biblioteca C ++ escrita para facilitar el desarrollo de videojuegos y programas multimedia.

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

La bandera se muestra en una ventana de 128x128. Su sistema operativo debe poder mostrar una ventana de 128x128 (mi Win8.1 no se puede mostrar con un ancho más pequeño)

ADVERTENCIA : es posible que desee agregar estas 2 líneas de código: t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);para que su CPU no se caliente cuando ejecuta el código. No los puse en el código original por razones de golf.

Braindraw, 227 bytes (no competidor) (actualizado para que funcione)

Versión sin golf (241 bytes)

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

Versión ligeramente golfizada (227 bytes)

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

Braindraw es un lenguaje de programación de mi propio diseño. A partir de las 3:08 pm de hoy, tengo un intérprete en funcionamiento y he comprobado que el programa se ejecuta correctamente. Sin embargo, el intérprete no existía antes de que comenzara esta competencia, por lo que no estoy compitiendo.

Braindraw es lo mismo que Brainf ***, excepto que opera en tres matrices bidimensionales, en lugar de una matriz unidimensional. Estas matrices se denominan r, g y b, y actúan como los canales de color rojo, verde y azul. El operador r mueve el puntero al canal rojo, etc. etc. Arriba es ^, abajo es v.

TI-BASIC (TI-84 Plus C (S) E solamente), 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}}]

el siguiente es solo de @ ASCII (¡pensé que era una broma pero funciona!)

Mathematica, 23 bytes

"CH"~CountryData~"Flag"

-10 bytes de @Jonathan Frech

HTML + CSS, 15 + 117 bytes = 132 bytes

Usando una envoltura flexbox con un 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

Respuesta anterior usando bordery un contenedor flexbox intermedio con 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

No estoy seguro de cómo jugar golf con GM (¿debería considerarse esto como un idioma?). Tampoco estoy seguro de cómo contar bytes aquí ...

Con GM instalado, escriba el código dado en Windows cmd, obtendrá una imagen con nombre 1.bmp. Es posible que desee cambiar la comilla doble a comilla simple si está usando bash (debería funcionar, pero no lo había probado).

Gracias a Digital Trauma. use solo un -drawguardado de 8 bytes

JavaScript + HTML, 99 + 13 = 112 bytes

Guardado 2 bytes gracias a user2428118
Guardado 2 bytes gracias 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) en 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>`)

¡Si! No necesitamos <canvas>ni <svg>ni siquiera <img>!

Gracias a Justin Mariner, ahorre 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 un byte gracias a ThePirateBay

Sin golf

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

Guarde la salida como image.xpmy ábrala con su 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())

Pruébalo en línea!

Salida:

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

No estoy completamente seguro de que esto sea tan necesario, se basa en la entrada vacía que se proporciona según esta meta publicación , que no funciona en TIO, por lo que proporciona una nueva línea (que no se usa). La salida es a la terminal y se ve así:

Las proporciones deben ser a escala basadas en un espacio de caracteres que son dos 'píxeles' verticales.

%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

Pruébalo en línea!

Puede obtener una vista previa de la salida copiando desde TIO y pegando aquí (esto muestra los caracteres de control cuando se cierne sobre el elemento) .

GFA BASIC (Atari ST), 62 bytes

Una lista editada manualmente en formato .LST. Todas las líneas terminan con CR, incluida la última.

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

Ampliado y 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

Salida

La salida es 32x32.

NB: De hecho, está usando el color 'blanco', aunque tiene un aspecto gris en el emulador (y también en el real, a menos que aumente el brillo bastante).

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)

(un poco) no golfista:

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)

Gracias a @gregor por guardar algunos bytes

¡Ejecutarlo!

Octava, 105 bytes 73 bytes

_{Nota: se agregaron avances de línea para mayor claridad, no incluidos en el recuento 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)

EDITAR: ¡gracias a flawr por guardar bastantes bytes!

Aquí está el resultado en octave-online.net, gracias a sanchises

GIF, 97 bytes

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

Barato y pesado en bytes, pero vale la pena.

EDITAR: Algunos caracteres no están en el código de arriba, aquí hay un pastebin para el hexdump del GIF.

EDITAR: comprimido a 97 bytes con la herramienta en línea.

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

Escribí caracteres de "espacio" en la consola mientras cambiaba el Color de fondo. Pero si cree que es demasiado alto y cuenta un solo carácter como 8 x 16 píxeles, simplemente dobla los valores cerca de "j" de esta manera (+ 1 byte y + c.ReadKey();para que se detenga):

  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 guardados gracias a 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}

Aquí está "sin golf"

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

Aquí está ungolfed un poco más

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

Esto hace que 3 rectángulos sean uno rojo grande y dos blancos más pequeños para el plus.

Así es como se ve. Realmente no se ve diferente a los demás.

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)

Se usa framepara evitar preestablecer un gráfico, pero la región de trazado predeterminada está en el intervalo [0,1] en lugar de [0,32]. También utiliza el hecho de que rectestá vectorizado. El tamaño predeterminado de la ventana de trazado es de 7 pulgadas x 7 pulgadas. Produce lo siguiente:

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

El valor predeterminado para pnges un cuadrado de 480x480 píxeles. La salida es el siguiente archivo 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)

Sin embargo, para garantizar la relación de aspecto, necesitamos 5 bytes más para un 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)

Con mucha inspiración de la respuesta de Alex Axthelm , y gracias a Rift por guardar algunos bytes más.

Postdata, 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

¡Gracias al editor anónimo que sugirió una reducción de 99 bytes!

Rojo , 79 bytes

Código:

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

Resultado:

Explicación:

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 de bits, 160 bytes

Aquí hay un mapa de bits con profundidad de color de 1 bit, que utiliza una definición de color de 24 bits. Los últimos seis bytes de la segunda línea son la paleta y, a continuación, la matriz de píxeles. Cada cuatro bytes contiene una fila completa de píxeles.

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

Intenté truncar los ceros finales, pero los visores de imágenes requieren que haya suficientes píxeles definidos para todo el lienzo.

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

Salida como ppm binario, uso:

python golf_swiss.py > swiss.ppm

El aumento de la profundidad de color me permitió utilizar el espacio para obtener el máximo valor.

Tcl / Tk, 94

Si se ejecuta en el intérprete de comandos interactivo, se puede abreviar canvasa cany gridagri

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}

Si se ejecuta en el shell interactivo, se puede abreviar canvasacan

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