Cette! est une grille de couleurs RVB ...

Fondamentalement, c'est une matrice à 2 dimensions dans laquelle:

• La première ligne et la première colonne sont en rouge.
• La deuxième ligne et la deuxième colonne sont vertes.
• La troisième ligne et la troisième colonne sont en bleu.

Voici les couleurs décrites graphiquement, en utilisant les lettres R, G et B.

Voici comment nous calculons la couleur de chaque espace de la grille.

• Rouge + Rouge = Rouge (# FF0000)
• Vert + Vert = Vert (# 00FF00)
• Bleu + Bleu = Bleu (# 0000FF)
• Rouge + Vert = Jaune (# FFFF00)
• Rouge + Bleu = Violet (# FF00FF)
• Vert + Bleu = Teal (# 00FFFF)

Le défi

• Écrivez le code pour générer une grille de couleurs RVB.
• C'est du code golf, alors essayez de le faire avec le plus petit nombre d'octets.
• Utilisez n’importe quel langage de programmation ou de balisage pour générer votre grille.
• Ce qui m'importe:
  • Le résultat devrait afficher graphiquement une grille RVB avec les couleurs définies.
• Des choses qui m'importe peu:
  • Si le résultat est une image, HTML, SVG ou un autre balisage.
  • La taille ou la forme des blocs de couleur.
  • Bordures, espacement, etc. entre ou autour des blocs.
  • Il n'est certainement pas nécessaire que les étiquettes vous indiquent quelles doivent être les couleurs des lignes et des colonnes.

Bash, 44

• 2 octets économisés grâce à @NahuelFouilleul
• 2 octets sauvegardés grâce à @manatwork

printf "${f=^[[3%dm.}$f$f
" 1 3 5 3 2 6 5 6 4

Ici, les blocs sont des .personnages. ^[est un caractère d'échappement ASCII littéral (0x1b).

Vous pouvez recréer ce script comme suit:

base64 -d <<< cHJpbnRmICIke2Y9G1szJWRtLn0kZiRmCiIgMSAzIDUgMyAyIDYgNSA2IDQ= > rgbgrid.sh

Assemblage 8088, IBM PC DOS,  44  43 octets

Référencement:

BE 0122     MOV  SI, OFFSET CTBL    ; load color bar table into [SI]
        LOOP_COLOR: 
B9 0001     MOV  CX, 1              ; display 1 char and clear CH (changed by INT 10H:3)
AC          LODSB                   ; load next color byte 
8A D8       MOV  BL, AL             ; move new color to BL
3C 10       CMP  AL, 010H           ; if this is third color in row: SF=0, CF=0 
                                    ; else if last color: SF=1, CF=0
                                    ; else continue on same row: CF=1
B8 09DB     MOV  AX, 09DBH          ; AH=9 (write char with attr), AL=0DBH (a block char) 
CD 10       INT  10H                ; call PC BIOS, display color block
B4 03       MOV  AH, 3              ; get cursor position function
CD 10       INT  10H                ; call PC BIOS, get cursor
72 04       JC   NEXT_COL           ; if not last in row, move to next column 
78 09       JS   EXIT               ; if last color, exit 
B2 FF       MOV  DL, -1             ; otherwise move to first column and next row 
        NEXT_COL:
42          INC  DX                 ; move to next column (and/or row)
B4 02       MOV  AH, 2              ; set cursor position function 
CD 10       INT  10H                ; call PC BIOS, set cursor position
EB E2       JMP  LOOP_COLOR         ; loop to next color byte 
        EXIT:
C3          RET                     ; return to DOS
CTBL    DB  0CH, 0EH, 1DH, 0EH, 0AH, 1BH, 0DH, 0BH, 91H ; color table

Ceci utilise les INT 10Hservices vidéo IBM PC BIOS pour écrire la grille de couleurs à l'écran. Malheureusement, la seule façon d'écrire un attribut de couleur spécifique nécessite également d'écrire du code pour placer le curseur à l'emplacement correct suivant. Il y a donc beaucoup de code supplémentaire pour cela.

Voici la sortie s'exécutant sur un IBM PC CGA (en mode texte 40x25 pour l'agrandir).

Téléchargez et testez RGBGRID.COM pour DOS.

Wolfram Language (Mathematica) , 41 octets

Image@Outer[Plus,#,#,1]&@IdentityMatrix@3

Wolfram Language (Mathematica) , 68 octets

Mathematica possède des fonctions intégrées pour toutes ces couleurs.

Image@{{Red,Yellow,Magenta},{Yellow,Green,Cyan},{Magenta,Cyan,Blue}}

Code machine 80386, IBM PC DOS, 38 octets

hex:

B0 13 CD 10 68 00 A0 1F 66 C7 06 00 00 28 2C 24
00 66 C7 06 40 01 2C 30 34 00 66 C7 06 80 02 24
34 20 00 CD 16 C3

asm:

mov al,13h
int 10h ; initialize vga 13h mode (320x200x256 colors)
push 0a000h
pop ds ; push video buffer address to ds
mov dword ptr ds:0, 242c28h ; print 3 pixels
mov dword ptr ds:320, 34302ch ; print 3 pixels
mov dword ptr ds:640, 203424h ; print 3 pixels
int 16h ; wait for any keypress
ret ; exit to os

Sortie mise à l'échelle de dosbox:

Excel VBA (fenêtre immédiate), 80 octets

For i=1To 9:Cells(i Mod 3+1,(i+1)/3).Interior.ColorIndex=Mid(673486857,i,1):Next

Excel VBA (Fonction), 96 octets

Sub g()
For i=1To 9
Cells(i Mod 3+1,(i+1)/3).Interior.ColorIndex=Mid(673486857,i,1)
Next
End Sub

Ce n'est pas un outil horrible pour le travail ... J'apprécie le fait qu'Excel affiche déjà une grille, il s'agit donc de définir la couleur de fond.

Nous remercions @Neil d'avoir suggéré d'utiliser ColorIndexplutôt que d' Coloréconomiser 43 octets.

-21 octets grâce à @Keeta

-16 octets grâce à @Chronocidal pour avoir suggéré la "fenêtre immédiate"

-2 octets grâce à @i_saw_drones

Beaucoup de changements de ma soumission originale :)

GFA Basic 2.02 (Atari ST), 48 octets

Une liste modifiée manuellement au format .LST. Inclut de nombreux caractères non imprimables, dont les codes sont indiqués entre parenthèses.

?"[ESC]c[SOH] [ESC]c[ETX] [ESC]c[ENQ] "[CR]
?"[ESC]c[ETX] [ESC]c[STX] [ESC]c[ACK] "[CR]
?"[ESC]c[ENQ] [ESC]c[ACK] [ESC]c[EOT] "[CR]

Le système d'exploitation de l'Atari ST définit les commandes VT52 étendues qui sont utilisées ici.

Sortie

$24\times24$$8\times8$

^{capture d'écran de Steem SSE}

SVG, 210 182 octets

<svg><path d="h3v3h-3" fill=#f0f/><path d="h2v2h-2" fill=#ff0/><path d="m1 1h2v2h-2" fill=#0ff/><line x2=1 stroke=red/><path d="m1 1h1v1h-1" fill=#0f0/><path d="m2 2h1v1" fill=#00f/>

Étant donné que la taille ou la forme des blocs de couleur n'a pas d'importance, vous pouvez créer plusieurs octets avec cette disposition légèrement étrange:

HTML + CSS, 121 120 octets

Le pire morceau de HTML que j'ai jamais écrit. Sauvegarde d'un octet grâce à @Gust van de Wal

b{color:#ff0}a{color:cyan}i{color:lime}u{color:blue

<pre><body bgcolor=#f0f text=red>█<b>█
█<i>█<a>█
 █<u>█

HTML + CSS, 114 octets (semi-valide)

Je mets ceci comme semi-valide parce que le bleu n'est pas exactement bleu # 0000FF et repose aussi sur le fait de ne pas avoir cliqué sur le lien.

Merci à @Lynn pour l'idée

b{color:#ff0}i{color:lime}c{color:cyan

<pre><body bgcolor=#f0f text=red>█<b>█
█<i>█<c>█
 █<a href=x>█

ditaa , 118 bytes

/----+----+----\
|cF00|cFF0|cF0F|
+----+----+----+
|cFF0|c0F0|c0FF|
+----+----+----+
|cF0F|c0FF|c00F|
\----+----+----/

Ceci est la sortie utilisant l' -Eoption:

R, 89 50 48 octets

Version la plus récente:

image(matrix(c(6,4,5,2:4,1,2),3),col=rainbow(6))

Pas assez d'éléments dans le vecteur pour remplir la matrice 3x3, donc il enroule autour et réutilise le premier élément.

Anciennes versions:

image(matrix(c(6,4,5,2:4,1,2,6),3),col=rainbow(6))

image(matrix(c(3,5,6,2,4,5,1:3),3),col=c('red','yellow','magenta','green','cyan','blue'))

Excel-VBA, 89 73 72 70 octets

Edit: Vous pouvez utiliser la fenêtre immédiate et vous passer de Sub/ End Subpour sauvegarder 16 octets:

For i=1To 9:[A:C].Cells(i).Interior.ColorIndex=Mid(367648785,i,1):Next

Réponse originale:

Sub a()
For i=1To 9
[A1:C3].Cells(i).Interior.ColorIndex=Mid(367648785,i,1)
Next
End Sub

Cela a été inspiré par la suggestion de Neil concernant cette réponse et constitue ma première soumission!

Résultat:

-2 octets : Suppression des numéros de ligne de cellule - grâce à Taylor Scott !

Perl 6 (et probablement similaire pour de nombreuses langues) (31 octets)

{'ÿ   ÿÿÿ ÿ ÿÿ  ÿ ÿÿÿ ÿ ÿÿ  ÿ'}   # replace spaces with ASCII 00
                                  # which I can't seem to enter

Cela génère un fichier TIFF sans tête, qui était généré par Photoshop avec l’extension de fichier .raw et qui est présumé être carré, sauf indication contraire au moment de l’ouverture. Jouer avec la profondeur de couleur (si autorisée) pourrait la réduire davantage.

ffplay (ffmpeg), 93 octets

ffplay -f rawvideo -s 3x3 -pix_fmt rgb24 "data:/;base64,/wAA//8A/wD///8AAP8AAP///wD/AP//AAD/"

Vieux :

ffplay -f lavfi -i testsrc=s=3x3,geq=r=255*not(X*Y):g=255*not((X-1)*(Y-1)):b=255*not((X-2)*(Y-2))

$\Large{\mathbf{\TeX} \left(\text{MathJax}\right)},~122\,\text{bytes}$

Golf'd:

$\def\c#1{\color{#1}{\rule{5em}{5em}}}\c{red}\c{yellow}\c{fuchsia}\\\c{yellow}\c{lime}\c{aqua}\\\c{fuchsia}\c{aqua}\c{blue}$

Ungolf'd:

$$
\def\coloredBox#1{\color{#1}{\rule{5em}{5em}}}
\coloredBox{red}
\coloredBox{yellow}
\coloredBox{fuchsia} \\
\coloredBox{yellow}
\coloredBox{lime}
\coloredBox{aqua}    \\
\coloredBox{fuchsia}
\coloredBox{aqua}
\coloredBox{blue}
$$

Modifications:

1. Merci à @flawr pour avoir expliqué comment corriger les couleurs!

2. $14\,\text{bytes}$\rule{5em}{5em}▉

   $$\def\d#1{\color{#1}{▉}} \d{red} \d{yellow} \d{fuchsia} \\ \d{yellow} \d{lime} \d{aqua} \\ \d{fuchsia} \d{aqua} \d{blue}$$

   , mais ce n’est pas tout à fait pareil.

3. Pourrait probablement supprimer quelques octets supplémentaires en trouvant des noms de couleurs qui ressemblent de manière acceptable aux couleurs souhaitées.

4. $\mathrm{\TeX}\text{'d}$

   $${\newcommand{\rotate}[2]{{\style{transform-origin: center middle; display: inline-block; transform: rotate(#1deg); padding: 50px}{#2}}}} {\def\place#1#2#3{\smash{\rlap{\hskip{#1em}\raise{#2em}{#3}}}}} {\def\placeBox#1#2#3{\place{#1}{#2}{\color{#3}{\rule{5em}{5em}}}}} {\def\placeLabelTop#1#2#3{\place{#1}{#2}{\large{\textbf{#3}}}}} {\def\placeLabelLeft#1#2#3{\place{#1}{#2}{\rotate{-90}{\large{\textbf{#3}}}}}} \placeLabelTop{1.1}{15.5}{Red} \placeLabelTop{5.5}{15.5}{Green} \placeLabelTop{11.2}{15.5}{Blue} \placeLabelLeft{-6.2}{13.6}{Red} \placeLabelLeft{-7.1}{8.5}{Green} \placeLabelLeft{-6.5}{3.5}{Blue} \placeBox{0}{10}{red} \placeBox{5}{10}{yellow} \placeBox{10}{10}{fuchsia} \placeBox{0}{5}{yellow} \placeBox{5}{5}{lime} \placeBox{10}{5}{aqua} \placeBox{0}{0}{fuchsia} \placeBox{5}{0}{aqua} \placeBox{10}{0}{blue} \place{15.1}{0}{\large{.}} \phantom{\rule{15em}{16.5em}}$$

Lua + LÖVE / Love2D , 186 183 octets

t={[0>1]=0,[0<1]=1}l=love g=l.graphics function l.draw()for i=1,3 do for j=1,3 do g.setColor(t[i<2 or j<2],t[i==2 or j==2],t[i>2 or j>2])g.rectangle('fill',j*10,i*10,10,10)end end end

Essayez-le en ligne!

Ma première entrée de golf de code!

MATL, 44 23 21 20 19 octets

Un portage direct de ma réponse Octave avec les suggestions de @ExpiredData et @LuisMendo.

126973007Bo7B3*e0YG

essayez-le en ligne

Octave / MATLAB , 57 56 40 octets

-17 octets grâce à @ExpiredData! Découvrez leur solution encore plus golfeuse !

image(reshape(de2bi(126973007),[3,3,3]))

Essayez-le en ligne!

Factorio Blueprint String, 705 octets

Je reconnais que je ne fais que repousser les limites de ce qui compte comme solution.

0eNrdWNGOqyAQ/ReedeNo0daH/ZHNTYOW7ZJFNAi91zT99wua7ZpdaaT1pb40oQ6HOecwA3pGBde0kUwolJ8RK2vRovztjFp2FITb/1TXUJQjpmiFAiRIZUdtzYkMGyIoR5cAMXGg/1AOlz8BokIxxegA0w+6vdBVQaUJuAKQstSV5kTV0qA2dWvm1MKuZ3FecIA6lIf4BV8uwS+YeDKPXzBhPKAkUxjJPAy4AbG5QljZFBEqLOuqYGKa1Vc6YAQzE5Ss+b6gH+TETLQJeWdcUemQ/8Sk0oSPHOgjQkkPqMfT1kEYWzEsI2hpc2gtFtgfO2NkDTMjbIKnCOLv1SrCechJ1UzwSm7zKpksNVN78+xwnffOZKv2s2kS0akPJo4D10FslEd2UDVE9oLn6NU+1i01S/HaKqmkpvNl2DhkSGfJEK1Eha1DhWyWCmvZCzuHCtu7aj5asuQ7ynn99/GqT0f07BjAwXnnx3kohEW7XMPE5+OEs5+EUwdhiL4T0IVh3LNzHlMwfUoB+LTPeK19A2LPkoGbety1f46SUvH4BoLExTHxOCKe3mmIXTJ43ogGp5MlnS47soTR+GeryFyUscex+PzOu65IkPr0OrzW2wFkHn0Ar3c3eN6S4pt63NUH7GvtAn3AafTOo+yf3+jhbDcv9/1XgHz00SBAJ+NNn3uWRJDiDcDWXIf+Aya7oEk=

Sortie produite lors de la mise en jeu (paramètres graphiques bas utilisés):

Pour prouver que cette solution est valable, vous devez échantillonner cette grille de pixels qui correspondent exactement à la spécification:

Le reste de l'image est classé comme une bordure ou un espacement qui, comme le dit la question, n'a pas d'importance.

Octave , 38 octets

image(reshape(de2bi(126973007),3,3,3))

Essayez-le en ligne!

HTML / CSS, 278 141 137 octets

r{color:red}y{color:#ff0}m{color:#f0f}g{color:#0f0}c{color:#0ff}l{color:#00f

<pre><r>█<y>█<m>█
<y>█<g>█<c>█
<m>█<c>█<l>█

-137 octets grâce aux commentateurs, notamment @data
-4 octets grâce à @Einacio

Utilise Unicode █(U + 2588) pour les "blocs" et utilise les classes CSS / style en ligne pour les colorer.

Je pense que les <font>tags pourraient être plus joués au golf, mais les changer en un tag plus court, tel que <a>rompt l' colorattribut

JavaScript, 108 102 octets

console.log(`%c█%c█%c█
`.repeat(3),...[...`320251014`].map(c=>`color:#`+`f0ff00f0`.substr(c,3)))

Pas d'extrait, car cela ne fonctionne que dans une console de navigateur réelle et non dans la console de l'extrait. Edit: Merci à @AJFaraday pour la capture d'écran. Explication: Les navigateurs permettent au premier paramètre d' console.loginclure des substitutions. La %csubstitution prend un paramètre et l'applique comme CSS (assaini). Chaque █bloc est donc coloré en utilisant la sous-chaîne appropriée f0ff00f0interprétée comme un code de couleur à trois chiffres hexadécimaux.

HTML (GIF), 108 octets

C'est la bataille des formats d'image basés sur le Web! (Y at-il des prétendants au TIF ou au JPG?)

Répondre par @AC .

<img src=data:image/gif;base64,R0lGODdhAwADAMIGAAAA//8AAP8A/wD/AAD/////AAAAAAAAACwAAAAAAwADAAADBhglNSQEJAA7>

HTML (BMP), 116 115 octets

Réponse de @ ASCII uniquement .

<img src=data:image/bmp;base64,Qk0+AAAAQVNDTxoAAAAMAAAAAwADAAEAGAD/AP///wD/AAAAAAAA//8A/wD//wAAAAAAAP8A////AP8AAAA>

HTML (WebP), 116 octets

Réponse de @Hohmannfan .

<img src=data:image/webp;base64,UklGRjYAAABXRUJQVlA4TCoAAAAvAoAAAC8gEEjaH3qN+RcQFPk/2vwHH0QCg0I2kuDYvghLcAoX0f/4Hgc>

HTML (PNG), 151 136 135 octets

-15 octets grâce à @Hohmannfan .

<img src=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAFElEQVR4AWP4z8Dw/z8DEIIodB4A4D0O8pOGuTgAAAAASUVORK5CYII>

Voir aussi mes réponses CSS et SVG .

dc (sur xterm), 64 octets

Fi16[AP]sF36dD6r31 101dD6rD1[1CP61P[38;5;]Pn[mX]Pz3%0=Fz0<M]dsMx

Vous aurez juste un tas de codes d'échappement farfelus au lieu de couleurs, mais vous pouvez toujours l' essayer en ligne!

D'après ce que j'ai compris, les 16 couleurs ANSI de base peuvent être interprétées librement, à la demande du terminal. Par ailleurs, les 216 couleurs du cube de couleur xterm ont des valeurs RVB explicites. J'utilise ces codes et j'imprime une grille de Xs:

Nous définissons d’abord la base d’entrée en base 15 avec Fi. Cela coûte deux octets, mais en rend trois, donc ... un gain net d'un octet (et une perte de lisibilité importante). Ensuite, nous essayons d’obtenir nos valeurs de couleur sur la pile. En décimal, ce serait 21 51 201 51 46 226 201 226 196, mais nous sommes en mode loufoque donc ça va être 16 36 D6 36 31 101 D6 101 D1. Nous éliminons l'un des espaces en insérant une macro que nous devons définir à un moment donné [AP]sF(qui affiche simplement un saut de ligne). Nous pouvons réduire 36 D6 36et 101 D6 101en plaçant la première valeur sur la pile, en la dupliquant, en plaçant la seconde, puis en permutant ( 36dD6r, 101dD6r).

Macro Mgère l'impression et tout le reste. 1CPaffiche le caractère d'échappement. Les crochets sont utilisés pour délimiter des chaînes, et pour autant que je sache, ils ne peuvent pas être échappés. Nous devons donc imprimer le crochet avec une valeur ASCII également 61P. [38;5;]Pest le code 'définir la couleur de premier plan à partir de la liste numérotée'. naffiche la valeur du haut de la pile avec une nouvelle ligne, en la sautant. [mX]Ptermine le code et imprime un 'X'. z3%0=Fvérifie la profondeur de pile mod 3, en exécutant notre macro de saut de ligne Fsi nécessaire. z0<Mcontinue à Mfonctionner tant qu'il y a des choses sur la pile. dsMxcourir.

Notez que si vous exécutez ceci en courant continu dans un xterm, votre couleur de premier plan sera bleue. 1CP61P74P(entrée affichée dans la capture d'écran) devrait réinitialiser cela.

Tortue en bloc, 45 blocs

Essayez-le en ligne!

Pourquoi ne pas jouer à un petit jeu pour trouver l'outil le plus ridicule pour le poste?

Sortie:

Le programme (en tant que capture d'écran pour une hérésie supplémentaire):

Remarque: Les blocs grisés sont également comptés dans la métrique.

Node.js, 79 octets

require('fs').writeFile(a='P',a+[...'3331100110101110010011101011001'].join` `)

Produit un fichier nommé "P" au format PPM contenant la grille de couleurs.

TI-Basic, x octets (marquera quand je peux)

Remarque: le filtre de contenu m'empêche de rechercher la taille des jetons pour chacune de ces commandes. Si quelqu'un veut marquer pour moi, fonce.

TextColor(11
Text(0,0,"0"
TextColor(19
Text(0,2,"0"
Text(2,0,"0"
TextColor(13
Text(4,0,"0"
Text(0,4,"0"
TextColor(14
Text(2,2,"0"
TextColor(18
Text(2,4,"0"
Text(4,2,"0"
TextColor(17
Text(4,4,"0"

Cela semble vraiment mauvais sur mon petit écran de calculatrice. Mais bon, la forme n'a pas d'importance: ^)

Sortie de golf: Modifiée pour une sortie 8x plus grande:

TI-BASIC, x octets

Utiliser Pxl-On au lieu de Text:

Pxl-On(0,0,11
Pxl-On(0,1,19
Pxl-On(0,2,13
Pxl-On(1,0,19
Pxl-On(1,1,14
Pxl-On(1,2,18
Pxl-On(2,0,13
Pxl-On(2,1,18
Pxl-On(2,2,17

Sortie: gonflée ~ 11x:

C ++, SFML, 177 octets

#include<SFML/Graphics.hpp>
int d[]={255,65535,0xFF00FF,65535,65280,0xFFFF00,0xFF00FF,0xFFFF00,0xFF0000};void f(){sf::Image g;g.create(3,3,(sf::Uint8*)d);g.saveToFile("a.jpg");}

Utilise une sf::Image::create(int,int,unsigned char*)méthode pour créer une image contenant des valeurs rgb

C #, 248 204 198 octets

class P{static void Main(){for(int i=0;i<12;i++){foreach(dynamic n in Enum.GetValues(typeof(ConsoleColor)))if((""+n)[0]=="RYMRYGCRMCBR"[i])Console.BackgroundColor=n;Console.Write(i%4<3?" ":"\n");}}}

Sortie:

BASIC C64, 106 octets

0 POKE53281,0
1 DATA144,28,158,156,144,13,158,30,159,144,13,156,159,31,144
2 READA:PRINTCHR$(A)+"o";:GOTO2

Wolfram Language (Mathematica), 72 octets

Grid@Partition[RGBColor/@Unitize[Total/@Tuples[IdentityMatrix@3,{2}]],3]