Compito: produrre la bandiera svizzera.

Buona festa nazionale svizzera / Schweizer Bundesfeiertag / Fête nationale suisse / Festa nazionale svizzera / Fiasta naziunala svizra!

Dettagli: la bandiera è composta da una #FFFFFFcroce bianca ( ) su uno #FF0000sfondo rosso ( ). La croce è composta da un quadrato 6x6 con bracci di dimensioni 6x7 incollati su ciascun lato. La croce è al centro dello sfondo quadrato 32x32 con una distanza di 6 unità per lato. ( Fonte )

La dimensione dell'output può essere scelta dal partecipante, ma l'immagine deve corrispondere esattamente a queste proporzioni, ciò significa che la sua dimensione deve essere un multiplo di 32.

Una versione minimale sarebbe simile a questa:

SVG (HTML5), 94 83 82 64 byte

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

Salvato 2 byte grazie a @ThePirateBay. Salvato 1 byte grazie a @ATaco. 18 byte salvati grazie a @CraigAyre sottolineando che un'immagine 32 × 32 era accettabile. Come sottolineato da @Shaggy, questo presuppone che lo sfondo predefinito sia bianco; aggiungi 22 byte per un flag che funziona su qualsiasi sfondo:

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

x86-16 Codice macchina per DOS, 43 byte

               ; 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

Il codice sopra è progettato per essere assemblato come file COM e quindi eseguito in DOS. Invoca i servizi video del BIOS ROM per tracciare i singoli pixel della bandiera, formando una rappresentazione 32 × 32 della bandiera svizzera nell'angolo in alto a sinistra dello schermo.

Il codice presuppone che la modalità video sia già impostata sulla modalità 0x13, il che significa anche che richiede un display VGA. Potrebbero essere utilizzate altre modalità video, ma richiedere VGA offre due cose: (1) pixel quadrati e (2) una tavolozza predefinita che include un rosso reale al 100% ( 0xFF0000) (il che significa che non devi sprecare byte cambiando la tavolozza colori). Prima di eseguire questo programma, sarà quindi necessario commutare il display in modalità 0x13; il seguente codice è tutto ciò che serve per farlo:

mov  ax, 0x13
int  0x10

Il codice non fa altre ipotesi e dovrebbe essere eseguito su qualsiasi hardware compatibile x86 con un sistema operativo compatibile DOS.

Tuttavia, il programma termina immediatamente dopo aver disegnato il flag, quindi il prompt del DOS verrà normalmente ristampato nell'angolo in alto a sinistra dello schermo, coprendo le prime linee del flag. Pertanto, se si desidera meravigliarsi dell'output reale, è necessario bloccare / mettere in pausa il sistema prima che RETurti. Ecco uno screenshot di come appare, in esecuzione in una macchina virtuale FreeDOS:

Potrebbe essere possibile approfondire ulteriormente questo problema scrivendo i dati pixel direttamente nel buffer video, soprattutto perché sto già assumendo la modalità 0x13. Non l'ho ancora provato. INT 0x10è già un'istruzione piuttosto breve, ma se posso usare le istruzioni di stringa a un byte per scrivere i dati dei pixel direttamente nella memoria, ciò potrebbe comportare un notevole risparmio di codice.

MATL , 29 byte

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

Provalo su MATL Online!

Spiegazione

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 byte

Grazie a @Aaron per -64 byte.
-4 byte inviando al file asenza estensione.

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

Un'espressione lamba che può essere assegnata a un metodo di interfaccia funzionale che genera un'eccezione. Crea un file immagine denominato a(un file immagine) nella directory che esegue questo file.

Codice circostante utilizzato per eseguirlo: provalo 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"));
}

Risultato

Griglia fornita dall'anteprima dell'immagine IDEA di IntelliJ (apparentemente).

Excel VBA, _{86 85} 79 byte

Codice

Anonimo VBE funzione finestra immediata che non tiene in ingresso ed emette la bandiera svizzera sulla gamma [A1:F32]di ActiveSheetoggetto. Funziona prima facendo quadrare le celle, quindi disegnando la regione rossa e infine disegnando la croce bianca.

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

^{Si noti che le disposizioni che rimuovono la fase di colorazione della "croce" della bandiera svizzera dopo aver inserito lo sfondo rosso sono in realtà più lunghe della configurazione precedente, in quanto richiedono almeno 16 indirizzi di cella, che si coordinano con le 8 regioni distinte del bandiera}

-1 Byte grazie a @ Greedo's per RowHeight=48oltreColumnWidth=2

-6 byte grazie a @ Greedo's per -1invecergbWhite

Produzione

C ++, SFML, 406 399 394 byte

-2 byte grazie a pdpi
-10 byte grazie a Zacharý

SFML (Simple and Fast Multimedia Library) è una libreria C ++ scritta per facilitare lo sviluppo di videogiochi e programmi multimediali

Il codice :

#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 bandiera viene visualizzata in una finestra 128x128. Il tuo sistema operativo deve essere in grado di visualizzare una finestra 128x128 (il mio Win8.1 non può essere visualizzato con una larghezza inferiore)

ATTENZIONE : potresti voler aggiungere queste 2 righe di codice:, t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);quindi la tua CPU non si riscalda quando esegui il codice. Non li ho inseriti nel codice originale per motivi di golf.

Braindraw, 227 byte (non concorrenti) (aggiornato per funzionare effettivamente)

Versione non golfata (241 byte)

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

Versione leggermente golfata (227 byte)

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

Braindraw è un linguaggio di programmazione di mia progettazione. Oggi alle 15:08 ho un interprete funzionante e ho verificato che il programma funzioni correttamente. Tuttavia, l'interprete non esisteva prima dell'inizio di questa competizione, quindi non sto gareggiando.

Braindraw è uguale a Brainf ***, tranne per il fatto che opera su tre array bidimensionali, anziché su un array unidimensionale. Queste matrici sono chiamate r, g e b e fungono da canali di colore rosso verde e blu. L'operatore r sposta il puntatore sul canale rosso, ecc. Ecc. Su è ^, giù è v.

TI-BASIC (solo TI-84 Plus C (S) E), 58 byte

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

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

il prossimo è solo da @ ASCII (ho pensato che fosse uno scherzo ma funziona!)

Mathematica, 23 byte

"CH"~CountryData~"Flag"

-10 byte da @Jonathan Frech

HTML + CSS, 15 + 117 byte = 132 byte

Utilizzando un wrapper 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 byte = 140 byte

Risposta precedente utilizzando bordere un wrapper 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 byte

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

Non sei sicuro di come giocare a golf con GM (questo dovrebbe essere considerato come una lingua?). Inoltre, non sono sicuro di come contare i byte qui ...

Con GM installato, digita il codice indicato in Windows cmd, otterrai un'immagine con il nome 1.bmp. Puoi usare la virgoletta doppia per virgoletta singola se stai usando bash (dovrebbe funzionare, ma non l'ho testato).

Grazie a Digital Trauma. utilizzare solo un -drawsalvataggio di 8 byte

JavaScript + HTML, 99 + 13 = 112 byte

Salvato 2 byte grazie a user2428118
Salvato 2 byte grazie 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 byte

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) in HTML4 (?), 178 176 byte

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

Sì! Non abbiamo bisogno <canvas>né <svg>nemmeno <img>!

Grazie a Justin Mariner, risparmia 2 byte.

Löve2D , 139 138 byte

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

Salvato un byte grazie 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 byte

Salva l'output come image.xpme aprilo con il tuo editor di testo preferito.

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

Provalo online!

Produzione:

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

176 byte codice + 8 per -Mutf8 -p.

Non sono del tutto sicuro che sia come richiesto, si basa sull'input vuoto fornito come da questo meta post , che non funziona su TIO quindi fornisce una nuova linea (che non viene utilizzata). L'output è al terminale e si presenta così:

Le proporzioni dovrebbero essere ridimensionate in base allo spazio di un carattere costituito da due "pixel" verticali.

%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

Provalo online!

È possibile visualizzare in anteprima l'output copiando da TIO e incollandolo qui (questo mostra i caratteri di controllo quando si passa con il mouse sopra l'elemento) .

GFA BASIC (Atari ST), 62 byte

Un elenco modificato manualmente in formato .LST. Tutte le righe finiscono con CR, inclusa l'ultima.

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

Ampliato e commentato:

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

Produzione

L'output è 32x32.

NB: Questo sta effettivamente usando il colore 'bianco', sebbene sia di colore grigio sull'emulatore (e anche sulla cosa reale, a meno che non si giri la luminosità abbastanza in alto).

R, 171 140 byte.

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 po ') non golfato:

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)

Grazie a @gregor per aver salvato alcuni byte

Eseguirlo!

Ottava, 105 byte 73 byte

_{Nota: feed di riga aggiunti per chiarezza, non inclusi nel conteggio dei byte}

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

EDIT: grazie a flawr per aver salvato parecchi byte!

Ecco il risultato su octave-online.net, grazie alle franchise

GIF, 97 byte

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

Economico e pesante, ma ne vale la pena.

EDIT: alcuni caratteri non sono nel codice sopra, ecco un pastebin per il hexdump della GIF.

EDIT: compresso fino a 97 byte con lo strumento online.

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

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 byte

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 byte

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

Ho scritto caratteri "spazio" nella console mentre cambiavo il colore di sfondo. Ma se pensi che sia troppo alto e conti un singolo carattere come 8 x 16 pixel, raddoppi semplicemente i valori vicino a "j" in questo modo (+ 1 byte e + in c.ReadKey();modo che si fermino):

  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 byte salvati grazie 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 byte

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

Qui è "ungolfed"

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

Qui è ungolf un po 'di più

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

Questo rende 3 rettangoli uno rosso grande e due bianchi più piccoli per il plus.

Ecco come appare. Non sembra davvero diverso dagli altri.

R, 109 byte

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)

Utilizza frameper evitare di preimpostare un diagramma, ma la regione di stampa predefinita è nell'intervallo [0,1] anziché [0,32]. Utilizza anche il fatto che rectè vettoriale. La dimensione predefinita della finestra di stampa è 7 pollici x 7 pollici. Emette quanto segue:

R, 125 byte

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

L'impostazione predefinita per pngè un quadrato di 480x480 pixel. L'output è il seguente file png:

R, 112 byte

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)

Tuttavia, per garantire le proporzioni, abbiamo bisogno di 5 byte in più per un totale di 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 molta ispirazione dalla risposta di Alex Axthelm e grazie a Rift per aver salvato qualche altro byte.

Postscript, 301286 187 byte

/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

Grazie all'editore anonimo che ha suggerito una riduzione di 99 byte!

Rosso , 79 byte

Codice:

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

Risultato:

Spiegazione:

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 byte

Ecco una bitmap con profondità di colore a 1 bit, usando una definizione di colore a 24 bit. Gli ultimi sei byte della seconda riga sono la tavolozza e in seguito è l'array di pixel. Ogni quattro byte contiene un'intera riga di pixel.

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

Ho provato a troncare gli zero finali, ma i visualizzatori di immagini richiedono che siano stati definiti pixel sufficienti per l'intera area di disegno.

Python 2, 92 91 89 byte

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

Uscita come ppm binario, utilizzo:

python golf_swiss.py > swiss.ppm

Aumentare la profondità del colore mi ha permesso di utilizzare lo spazio per il massimo valore

Tcl / Tk, 94

Se si corre sulla shell interattiva, si può abbreviare canvasal cane gridalgri

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 si corre sulla shell interattiva, si può abbreviare 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