Tâche: produire le drapeau suisse.

Fête nationale suisse / Fête nationale suisse / Fête nationale suisse / Fiasta naziunala svizra / Fête nationale suisse / Schweizer Bundesfeiertag!

Détails: Le drapeau consiste en une #FFFFFFcroix blanche ( ) sur un #FF0000fond rouge ( ). La croix consiste en un carré 6x6 avec des bras de taille 6x7 collés de chaque côté. La croix est au centre du fond carré 32x32 ayant une distance de 6 unités de chaque côté. ( Source )

La taille de sortie peut être choisie par le participant, mais l'image doit correspondre exactement à ces proportions, ce qui signifie que sa taille doit être un multiple de 32.

Une version minimale ressemblerait à ceci:

SVG (HTML5), 94 83 82 64 octets

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

2 octets sauvés grâce à @ThePirateBay. Sauvegardé 1 octet grâce à @ATaco. Enregistrement de 18 octets grâce à @CraigAyre indiquant qu'une image au format 32 × 32 était acceptable. Comme l'a souligné @Shaggy, cela suppose que votre arrière-plan par défaut est blanc; ajoutez 22 octets pour un drapeau qui fonctionne sur n’importe quel fond:

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

Code machine x86-16 pour DOS, 43 octets

               ; 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

Le code ci-dessus est conçu pour être assemblé en tant que fichier COM, puis exécuté sous DOS. Il appelle les services vidéo du BIOS ROM pour tracer les pixels individuels du drapeau, formant ainsi une représentation 32 × 32 du drapeau suisse dans le coin supérieur gauche de l'écran.

Le code suppose que le mode vidéo est déjà défini sur le mode 0x13, ce qui signifie également qu'il nécessite un affichage VGA. D'autres modes vidéo peuvent être utilisés, mais le format VGA nécessite deux choses: (1) des pixels carrés et (2) une palette par défaut comprenant un vrai 100% rouge ( 0xFF0000) (ce qui signifie que vous n'avez pas à perdre des octets pour changer de palette. couleurs). Avant d'exécuter ce programme, vous devrez donc basculer votre affichage en mode 0x13; le code suivant est tout ce dont vous avez besoin pour faire cela:

mov  ax, 0x13
int  0x10

Le code ne fait aucune autre hypothèse et doit être exécuté sur tout matériel compatible x86 sous un système d'exploitation compatible DOS.

Cependant, le programme se termine immédiatement après avoir dessiné l'indicateur. L'invite DOS est donc normalement réimprimée dans le coin supérieur gauche de l'écran, couvrant ainsi les quelques lignes supérieures de l'indicateur. Par conséquent, si vous voulez vous émerveiller de la véritable sortie, vous devez suspendre / mettre en pause le système avant qu'il ne soit RETuriné. Voici une capture d'écran de ce à quoi cela ressemble, s'exécutant sur une machine virtuelle FreeDOS:

Il serait peut-être possible de jouer au golf plus loin en écrivant des données de pixels directement dans le tampon vidéo, d’autant plus que j’assume déjà le mode 0x13. Je n'ai pas encore essayé. INT 0x10est déjà une instruction assez courte, mais si je peux utiliser les instructions de chaîne sur un octet pour écrire des données de pixels directement dans la mémoire, cela pourrait entraîner une économie de code significative.

MATL , 29 octets

2Y66t&Y"OJQht3$)6thYaQK7hBoYG

Essayez-le sur MATL Online!

Explication

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 octets

Merci à @Aaron pour -64 octets.
-4 octets en sortie dans un fichier asans extension.

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

Expression lamba pouvant être affectée à une méthode d'interface fonctionnelle générant une exception. Crée un fichier image nommé a(un fichier image) dans le répertoire qui exécute ce fichier.

Le code environnant utilisé pour l'exécuter: essayez-le en ligne!

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

Résultat

Grille fournie par l'aperçu de l'image IntelliJ IDEA (apparemment).

Excel VBA, _{86 85} 79 octets

Code

Fonction de fenêtre immédiate VBE anonyme qui ne prend aucune entrée et affiche le drapeau suisse sur la plage [A1:F32]de l' ActiveSheetobjet. Cela fonctionne en commençant par rendre les cellules carrées, puis en traçant la région rouge et enfin en traçant la croix blanche.

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

^{Notez que les arrangements qui suppriment l'étape consistant à colorer la "croix" du drapeau suisse après la mise en arrière-plan rouge sont en réalité plus longs que la configuration ci-dessus, car ils nécessitent au moins 16 adresses de cellule, qui se coordonnent vers les 8 régions distinctes de la carte. drapeau}

-1 octet grâce à @ Greedo pour RowHeight=48plusColumnWidth=2

-6 octets grâce à @ Greedo pour la -1placergbWhite

Sortie

C ++, SFML, 406 399 394 octets

-2 octets grâce à pdpi
-10 octets grâce à Zacharý

SFML (bibliothèque multimédia simple et rapide) est une bibliothèque C ++ écrite pour faciliter le développement de jeux vidéo et de programmes multimédias

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

Le drapeau est affiché dans une fenêtre de 128x128. Votre système d'exploitation doit pouvoir afficher une fenêtre 128x128 (ma Win8.1 ne peut pas afficher avec une largeur inférieure)

AVERTISSEMENT : vous voudrez peut-être ajouter ces 2 lignes de code:, t.setFramerateLimit(60);t.setVerticalSyncEnabled(true);afin que votre CPU ne chauffe pas lorsque vous exécutez le code. Je ne les ai pas mis dans le code original pour des raisons de golf.

Braindraw, 227 octets (non concurrents) (mis à jour pour fonctionner réellement)

Version non-golfée (241 octets)

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

Version légèrement golfée (227 octets)

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

Braindraw est un langage de programmation de ma propre conception. À partir de 15h08 aujourd'hui, j'ai un interprète qui travaille et j'ai vérifié que le programme fonctionne correctement. Cependant, l'interprète n'existait pas avant le début de la compétition, je ne suis donc pas en compétition.

Braindraw est identique à Brainf ***, à la différence qu’il fonctionne sur trois tableaux bidimensionnels plutôt que sur un tableau unidimensionnel. Ces tableaux s'appellent r, g et b et servent de canaux de couleur rouge vert et bleu. L'opérateur r déplace le pointeur sur le canal rouge, etc. etc. Up is ^, down v.

TI-BASIC (TI-84 Plus C (S) E uniquement), 58 octets

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

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

la prochaine est de @ ASCII seulement (je pensais que c'était une blague mais ça marche!)

Mathematica, 23 octets

"CH"~CountryData~"Flag"

-10 octets de @Jonathan Frech

HTML + CSS, 15 + 117 octets = 132 octets

Utiliser un wrapper flexbox avec 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 octets = 140 octets

Réponse précédente en utilisant borderet un wrapper flexbox intermédiaire avec négatif 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 octets

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

Vous ne savez pas comment jouer au golf avec GM (cela devrait-il être considéré comme une langue?). Aussi pas sûr de savoir comment compter les octets ici ...

Avec GM installé, tapez le code donné dans Windows cmd, vous obtiendrez une image avec le nom 1.bmp. Vous voudrez peut-être remplacer les guillemets par des guillemets simples si vous utilisez bash (cela devrait fonctionner, mais je ne l’avais pas testé).

Merci à Digital Trauma. utilisez seulement une -drawsauvegarde de 8 octets

JavaScript + HTML, 99 + 13 = 112 octets

2 octets enregistrés grâce à user2428118
2 octets enregistrés grâce à 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>

Pure JavaScript, 194 129 octets

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 octets

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

Oui! Nous n'avons pas besoin <canvas>ni <svg>ni même <img>!

Grâce à Justin Mariner, économisez 2 octets.

Löve2D , 139 138 octets

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

Un octet enregistré grâce à 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 octets

Enregistrez la sortie sous image.xpmet ouvrez-la avec votre éditeur de texte préféré.

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

Essayez-le en ligne!

Sortie:

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

Code de 176 octets + 8 pour -Mutf8 -p.

Je ne suis pas tout à fait sûr que cela soit conforme aux besoins, il faut que les entrées vides soient fournies conformément à ce méta-post , qui ne fonctionne pas sur TIO et fournit donc une nouvelle ligne (non utilisée). La sortie est au terminal et ressemble à ceci:

Les proportions doivent être à l'échelle d'un espace de caractère constitué de deux «pixels» verticaux.

%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

Essayez-le en ligne!

Vous pouvez prévisualiser la sortie en copiant à partir de TIO et en la collant ici (cela affiche les caractères de contrôle lorsque vous survolez l'élément) .

GFA BASIC (Atari ST), 62 octets

Une liste modifiée manuellement au format .LST. Toutes les lignes se terminent par CR, y compris la dernière.

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

Développé et commenté:

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

Sortie

La sortie est 32x32.

NB: Il s’agit bien de la couleur «blanche», bien que celle-ci ait un aspect gris sur l’émulateur (et sur la réalité, à moins que la luminosité ne soit trop élevée).

R, 171 140 octets.

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

Merci à @gregor pour avoir économisé quelques octets

Exécuter!

Octave, 105 octets 73 octets

_{Remarque: les sauts de ligne ajoutés pour plus de clarté ne sont pas inclus dans le nombre d'octets.}

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

EDIT: merci à flawr pour avoir économisé pas mal d’octets!

Voici le résultat sur octave-online.net, grâce aux sanchises

GIF, 97 octets

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

Pas cher et lourd d'octets, mais ça vaut le coup.

EDIT: Certains caractères ne sont pas dans le code ci-dessus, voici une boîte à copier pour l'hexdump du GIF.

EDIT: compressé jusqu'à 97 octets avec l'outil en ligne.

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

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 octets

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 octets

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

J'ai écrit des caractères "espace" dans la console tout en changeant la couleur de fond. Mais si vous pensez qu'il est trop grand et que vous comptez un seul caractère comme 8 x 16 pixels, vous doublez simplement les valeurs proches de "j" comme ceci (+ 1 octet et + c.ReadKey();pour qu'il s'arrête):

  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 octets sauvegardés grâce à 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 octets

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

Ici c'est "non-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}

Ici c'est ungolfé un peu plus

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

Cela fait 3 rectangles un grand rouge et deux plus petits blancs pour le plus.

Voici à quoi ça ressemble. Ça n'a pas vraiment l'air différent des autres.

R, 109 octets

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)

Utilisé framepour éviter de prédéfinir un tracé, mais la région de tracé par défaut est définie sur l'intervalle [0,1] au lieu de [0,32]. Utilise également le fait qu'il rectest vectorisé. La taille par défaut de la fenêtre de traçage est 7 po x 7 po. Il génère les éléments suivants:

R, 125 octets

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

La valeur par défaut pour pngest un carré de 480x480 pixels. La sortie est le fichier png suivant:

R, 112 octets

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)

Cependant, pour garantir les proportions, nous avons besoin de 5 octets supplémentaires pour 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)

Inspiré par la réponse d’ Alex Axthelm et merci à Rift d’avoir économisé quelques octets supplémentaires.

Postscript, 301 286 187 octets

/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

Merci à l'éditeur anonyme qui a suggéré une réduction de 99 octets!

Rouge , 79 octets

Code:

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

Résultat:

Explication:

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 octets

Voici un bitmap avec une profondeur de couleur de 1 bit, utilisant une définition de couleur de 24 bits. Les six derniers octets de la deuxième ligne constituent la palette et suivent le tableau de pixels. Tous les quatre octets contiennent une rangée entière 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

J'ai essayé de tronquer les zéros de fin, mais les visualiseurs d'images ont besoin de suffisamment de pixels pour toute la zone de travail.

Python 2, 92 91 89 octets

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

Sortie en ppm binaire, utilisation:

python golf_swiss.py > swiss.ppm

L'augmentation de la profondeur de couleur m'a permis d'utiliser l'espace pour une valeur maximale

Tcl / Tk, 94

Si elle fonctionne sur le shell interactif, on peut abrégez canvasà canet gridàgri

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 elle fonctionne sur le shell interactif, on peut abrégez canvasàcan

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