Aufgabe: Ausgabe der Schweizer Flagge.

Fröhlichen Schweizer Nationalfeiertag / Schweizer Bundesfeiertag / Fête nationale suisse / Festa nazionale svizzera

Details: Die Flagge besteht aus einem weißen ( #FFFFFF) Kreuz auf rotem ( #FF0000) Hintergrund. Das Kreuz besteht aus einem 6x6 Quadrat mit Armen der Größe 6x7, die an jeder Seite festgeklebt sind. Das Kreuz befindet sich in der Mitte des 32x32-Quadrats mit einem Abstand von 6 Einheiten zu jeder Seite. ( Quelle )

Die Ausgabegröße kann vom Teilnehmer gewählt werden, das Bild muss jedoch genau mit diesen Proportionen übereinstimmen. Dies bedeutet, dass die Größe ein Vielfaches von 32 sein muss.

Eine minimale Version würde so aussehen:

SVG (HTML5), 94 83 82 64 Bytes

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

2 Bytes dank @ThePirateBay gespart. 1 Byte dank @ATaco gespeichert. Dank @CraigAyre, der darauf hinweist, dass ein 32 × 32-Bild akzeptabel ist, wurden 18 Byte eingespart. Wie von @Shaggy hervorgehoben, wird davon ausgegangen, dass Ihr Standardhintergrund weiß ist. Füge 22 Bytes für ein Flag hinzu, das auf jedem Hintergrund funktioniert:

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

x86-16-Maschinencode für 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

Der obige Code soll als COM-Datei zusammengestellt und dann unter DOS ausgeführt werden. Es ruft die ROM BIOS-Videodienste auf, um die einzelnen Pixel der Flagge zu zeichnen und eine 32 × 32-Darstellung der Schweizer Flagge in der oberen linken Ecke des Bildschirms zu bilden.

Der Code setzt voraus, dass der Videomodus bereits auf den Modus 0x13 eingestellt ist. Dies bedeutet auch, dass ein VGA-Display erforderlich ist. Es können auch andere Videomodi verwendet werden. Wenn Sie jedoch VGA benötigen, erhalten Sie zwei Dinge: (1) quadratische Pixel und (2) eine Standardpalette mit einem echten Rotanteil von 100% ( 0xFF0000) (Sie müssen also keine Bytes für das Ändern der Palette verschwenden) Farben). Bevor Sie dieses Programm ausführen, müssen Sie Ihre Anzeige daher in den Modus 0x13 schalten. Dazu brauchen Sie nur den folgenden Code:

mov  ax, 0x13
int  0x10

Der Code macht keine anderen Annahmen und sollte auf jeder x86-kompatiblen Hardware unter einem DOS-kompatiblen Betriebssystem ausgeführt werden.

Das Programm wird jedoch sofort nach dem Zeichnen des Flags beendet, sodass die DOS-Eingabeaufforderung normalerweise in der oberen linken Ecke des Bildschirms erneut gedruckt wird und die obersten paar Zeilen des Flags verdeckt. Wenn Sie also die wahre Ausgabe bestaunen möchten, müssen Sie das System anhalten, bevor es funktioniert RET. Hier ist ein Screenshot davon, wie das auf einer virtuellen FreeDOS-Maschine aussieht:

Es könnte möglich sein, dies weiter abzuspielen, indem Pixeldaten direkt in den Videopuffer geschrieben werden, zumal ich bereits den Modus 0x13 einnehme. Das habe ich noch nicht ausprobiert. INT 0x10ist bereits eine ziemlich kurze Anweisung, aber wenn ich die Ein-Byte-Zeichenfolgenanweisungen verwenden kann, um Pixeldaten direkt in den Speicher zu schreiben, könnte dies zu einer erheblichen Codeeinsparung führen.

MATL , 29 Bytes

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

Probieren Sie es bei MATL Online!

Erläuterung

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

Vielen Dank an @Aaron für -64 Bytes.
-4 Bytes durch Ausgabe in eine Datei aohne Erweiterung.

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

Ein Lamba-Ausdruck, der einer funktionalen Schnittstellenmethode zugewiesen werden kann, die eine Ausnahme auslöst. Erstellt eine Bilddatei mit dem Namen a(eine Bilddatei) in dem Verzeichnis, in dem diese Datei ausgeführt wird.

Umgebungscode für die Ausführung: Probieren Sie es online aus!

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

Ergebnis

Raster, das von der IntelliJ IDEA-Bildvorschau bereitgestellt wird (anscheinend).

Excel VBA, _{86 85} 79 Bytes

Code

Anonyme VBE-Sofortfensterfunktion, die keine Eingabe und Ausgabe der Schweizer Flagge in den Bereich [A1:F32]des ActiveSheetObjekts übernimmt . Dies funktioniert, indem zuerst die Zellen quadratisch gemacht werden, dann der rote Bereich und schließlich das weiße Kreuz eingezeichnet werden.

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

^{Es ist zu beachten, dass Anordnungen, die den Schritt des Färbens des "Kreuzes" der Schweizer Flagge nach dem Einfügen des roten Hintergrunds entfernen, tatsächlich länger sind als die obige Konfiguration, da sie mindestens 16 Zellenadressen erfordern, die zu den 8 verschiedenen Regionen der Schweiz koordinieren Flagge}

-1 Byte dank @ Greedo's für RowHeight=48überColumnWidth=2

-6 Bytes dank @ Greedo's -1stattdessenrgbWhite

Ausgabe

C ++, SFML, 406 399 394 Bytes

-2 Bytes dank pdpi
-10 Bytes dank Zacharý

SFML (Simple and Fast Multimedia Library) ist eine C ++ - Bibliothek, die entwickelt wurde, um die Entwicklung von Videospielen und Multimediaprogrammen zu vereinfachen

Der Code :

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

Die Flagge wird in einem 128x128 Fenster angezeigt. Ihr Betriebssystem muss in der Lage sein, ein 128x128-Fenster anzuzeigen (mein Win8.1 kann nicht mit einer geringeren Breite angezeigt werden)

WARNUNG : Möglicherweise möchten Sie diese beiden Codezeilen hinzufügen t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);, damit sich Ihre CPU nicht erwärmt, wenn Sie den Code ausführen. Ich habe sie aus Golfgründen nicht in den Originalcode eingefügt.

Braindraw, 227 Bytes (nicht konkurrierend) (aktualisiert, um tatsächlich zu funktionieren)

Ungolfed-Version (241 Bytes)

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

Leicht golfene Version (227 Bytes)

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

Braindraw ist eine Programmiersprache meines eigenen Designs. Ab heute, 15:08 Uhr, habe ich einen funktionierenden Dolmetscher und habe überprüft, ob das Programm ordnungsgemäß ausgeführt wird. Der Dolmetscher existierte jedoch nicht, bevor dieser Wettbewerb begann. Ich nehme also nicht teil.

Braindraw ist dasselbe wie Brainf ***, außer dass es auf drei zweidimensionalen Arrays und nicht auf einem eindimensionalen Array ausgeführt wird. Diese Arrays heißen r, g und b und fungieren als rot-grüne und blaue Farbkanäle. Der Operator r bewegt den Zeiger auf den roten Kanal usw. usw. Oben ist ^, unten ist v.

TI-BASIC (nur 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 Bytes

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

nächste ist von @ ASCII-only (ich dachte, es wäre ein Witz, aber es funktioniert!)

Mathematica, 23 Bytes

"CH"~CountryData~"Flag"

-10 Bytes von @Jonathan Frech

HTML + CSS, 15 + 117 Bytes = 132 Bytes

Verwenden eines Flexbox-Wrappers mit einem 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

Vorherige Antwort mit borderund einem Zwischen-Flexbox-Wrapper mit Negativ 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

Ich bin mir nicht sicher, wie ich mit GM Golf spielen soll (sollte dies als Sprache betrachtet werden?). Auch nicht sicher, wie man hier Bytes zählt ...

Wenn GM installiert ist, geben Sie den angegebenen Code in Windows Cmd ein. Sie erhalten ein Bild mit Namen 1.bmp. Sie können doppelte Anführungszeichen in einfache Anführungszeichen ändern, wenn Sie Bash verwenden (es sollte funktionieren, aber ich hatte dies nicht getestet).

Dank Digital Trauma. Verwenden Sie nur einen -drawSave 8 Bytes

JavaScript + HTML, 99 + 13 = 112 Byte

2 Bytes dank user2428118 gespeichert 2 Bytes dank Matheus Avellar gespeichert

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>

Reines JavaScript, 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) in 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>`)

Ja! Wir brauchen weder <canvas>noch <svg>noch <img>!

Dank Justin Mariner sparen Sie 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)"

Dank ThePirateBay ein Byte gespart

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

Ausgabe speichern unter image.xpmund mit Ihrem bevorzugten Texteditor öffnen.

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

Probieren Sie es online!

Ausgabe:

! 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

176 Byte Code + 8 für -Mutf8 -p.

Ich bin mir nicht ganz sicher, ob dies der Fall ist. Es hängt davon ab, dass leere Eingaben gemäß diesem Meta-Post bereitgestellt werden , was bei TIO nicht funktioniert. Es wird also eine neue Zeile bereitgestellt (die nicht verwendet wird). Die Ausgabe erfolgt zum Terminal und sieht folgendermaßen aus:

Die Proportionen sollten skalierbar sein, wobei ein Zeichenabstand zwei vertikale "Pixel" sein sollte.

%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

Probieren Sie es online!

Sie können eine Vorschau der Ausgabe anzeigen, indem Sie sie aus TIO kopieren und hier einfügen (dies zeigt die Steuerzeichen, wenn Sie den Mauszeiger über das Element halten) .

GFA BASIC (Atari ST), 62 Byte

Eine manuell bearbeitete Liste im .LST-Format. Alle Zeilen enden mit CR, einschließlich der letzten.

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

Erweitert und kommentiert:

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

Ausgabe

Die Ausgabe ist 32x32.

NB: Dies verwendet in der Tat die 'weiße' Farbe, obwohl sie auf dem Emulator grau aussieht (und auch auf der realen, es sei denn, Sie drehen die Helligkeit ziemlich hoch).

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)

(etwas) ungolfed:

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)

Vielen Dank an @gregor für das Speichern einiger Bytes

Starte es!

Oktave, 105 Bytes 73 Bytes

_{Hinweis: Der Übersichtlichkeit halber wurden Zeilenvorschübe hinzugefügt, die nicht in der Byteanzahl enthalten sind}

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

EDIT: danke an flawr für das sparen einer menge bytes!

Hier ist das Ergebnis auf octave-online.net, dank der Lizenzen

GIF, 97 Bytes

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

Billig und bytelastig, aber es lohnt sich.

BEARBEITEN: Einige Zeichen sind nicht im obigen Code enthalten. Hier ist ein Pastebin für den Hexdump des GIF.

BEARBEITEN: Mit dem Online-Tool auf 97 Byte komprimiert.

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

Ich habe Leerzeichen in die Konsole geschrieben, während ich die Hintergrundfarbe geändert habe. Aber wenn Sie denken, dass es zu groß ist und Sie ein einzelnes Zeichen als 8 x 16 Pixel zählen, verdoppeln Sie einfach die Werte in der Nähe von "j" wie folgt (+ 1 Byte und +, c.ReadKey();damit es aufhört):

  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 gespart dank 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}

Hier ist es "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}

Hier ist es etwas mehr ungolfed

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

Dies macht aus 3 Rechtecken ein großes rotes und zwei kleinere weiße Rechtecke für das Plus.

So sieht es aus. Es sieht nicht wirklich anders aus als die anderen.

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)

Dient framezum Vermeiden der Voreinstellung eines Plots, aber der Standard-Plotbereich ist Intervall [0,1] anstelle von [0,32]. Verwendet auch die Tatsache, dass rectvektorisiert wird. Die Standardgröße des Plotfensters beträgt 7 x 7 Zoll. Es gibt Folgendes aus:

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

Die Standardeinstellung für pngist ein Quadrat mit 480 x 480 Pixeln. Ausgabe ist die folgende PNG-Datei:

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)

Um das Seitenverhältnis zu gewährleisten, benötigen wir jedoch 5 weitere Bytes für insgesamt 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)

Mit viel Inspiration von Alex Axthelm's Antwort und danke an Rift für das Speichern einiger weiterer 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

Vielen Dank an den anonymen Editor, der eine Reduzierung von 99 Byte vorgeschlagen hat !

Rot , 79 Bytes

Code:

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

Ergebnis:

Erläuterung:

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

Hier ist eine Bitmap mit 1-Bit-Farbtiefe unter Verwendung einer 24-Bit-Farbdefinition. Die letzten sechs Bytes der zweiten Zeile sind die Palette und danach das Pixel-Array. Alle vier Bytes enthalten eine ganze Reihe von Pixeln.

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

Ich habe versucht, die nachgestellten Nullen abzuschneiden, aber für Bildbetrachter ist es erforderlich, dass genügend Pixel für die gesamte Leinwand definiert sind.

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

Ausgabe als binäre ppm, Verwendung:

python golf_swiss.py > swiss.ppm

Durch Erhöhen der Farbtiefe konnte ich den Platz für den maximalen Wert nutzen

Tcl / Tk, 94

Wenn es auf der interaktiven Shell läuft, kann man abkürzen canvaszu canund gridzugri

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}

Wenn es auf der interaktiven Shell läuft, kann man abkürzen canvaszucan

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