Diese! ist ein RGB-Farbraster ...

Grundsätzlich handelt es sich um eine zweidimensionale Matrix, in der:

• Die erste Zeile und die erste Spalte sind rot.
• Die zweite Zeile und die zweite Spalte sind grün.
• Die dritte Zeile und die dritte Spalte sind blau.

Hier sind die grafisch beschriebenen Farben mit den Buchstaben R, G und B.

Hier ist, wie wir die Farbe jedes Raumes im Raster berechnen.

• Rot + Rot = Rot (# FF0000)
• Grün + Grün = Grün (# 00FF00)
• Blau + Blau = Blau (# 0000FF)
• Rot + Grün = Gelb (# FFFF00)
• Rot + Blau = Lila (# FF00FF)
• Grün + Blau = Blaugrün (# 00FFFF)

Die Herausforderung

• Schreiben Sie Code, um ein RGB-Farbraster zu generieren.
• Es ist Codegolf, also versuchen Sie es mit der kleinsten Anzahl von Bytes.
• Verwenden Sie eine beliebige Programmiersprache oder Auszeichnungssprache, um Ihr Raster zu generieren.
• Dinge, die mir wichtig sind:
  • Das Ergebnis sollte ein RGB-Raster mit den definierten Farben grafisch anzeigen.
• Dinge, die mir egal sind:
  • Wenn es sich bei der Ausgabe um ein Bild, HTML, SVG oder ein anderes Markup handelt.
  • Die Größe oder Form der Farbblöcke.
  • Rahmen, Abstände usw. zwischen oder um die Blöcke.
  • Es muss definitiv keine Beschriftung geben, die angibt, welche Zeilen- und Spaltenfarben verwendet werden sollen.

Bash, 44

• 2 Bytes dank @NahuelFouilleul gespart
• 2 Bytes gespart dank @manatwork

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

Hier sind Blöcke .Zeichen. ^[ist ein buchstäbliches ASCII-Escapezeichen (0x1b).

Sie können dieses Skript wie folgt neu erstellen:

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

8088-Assembly, IBM PC DOS,  44  43 Bytes

Auflistung:

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

Dies verwendet die IBM PC BIOS- INT 10HVideoservices, um das Farbraster auf den Bildschirm zu schreiben. Leider erfordert die einzige Möglichkeit, ein bestimmtes Farbattribut zu schreiben, auch das Schreiben von Code, um den Cursor an der nächsten korrekten Stelle zu platzieren. Daher gibt es viel zusätzlichen Code dafür.

Hier ist die Ausgabe, die auf einem IBM PC CGA ausgeführt wird (im 40x25-Textmodus, um sie zu vergrößern).

Laden Sie RGBGRID.COM für DOS herunter und testen Sie es .

Wolfram Language (Mathematica) , 41 Byte

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

Wolfram Language (Mathematica) , 68 Byte

Mathematica verfügt über integrierte Funktionen für all diese Farben.

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

80386 Maschinencode, IBM PC DOS, 38 Bytes

verhexen:

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

skalierte Ausgabe von Dosbox:

Excel VBA (Direktfenster), 80 Byte

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

Excel VBA (Funktion), 96 Bytes

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

Kein schreckliches Werkzeug für den Job ... Ich schätze die Tatsache, dass Excel bereits ein Raster anzeigt, so dass es darum geht, die Hintergrundfarbe festzulegen.

Wir danken @Neil für den Vorschlag, dass ich 43 Byte einspare, ColorIndexanstatt dies zu tun Color.

-21 Bytes dank @Keeta

-16 Bytes dank @Chronocidal für die Empfehlung des "Sofortfensters"

-2 Bytes dank @i_saw_drones

Viele Änderungen von meiner ursprünglichen Einreichung :)

GFA Basic 2.02 (Atari ST), 48 Byte

Eine manuell bearbeitete Liste im .LST-Format. Enthält viele nicht druckbare Zeichen, deren Codes in Klammern angegeben sind.

?"[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]

Das Betriebssystem des Atari ST definiert erweiterte VT52-Befehle, die hier verwendet werden.

Ausgabe

Die Ausgabe ist ein Block mit Pixeln (9 Leerzeichen mit Pixeln).$24\times24$$8\times8$

^{Screenshot von Steem SSE}

SVG, 210 182 Bytes

<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/>

Da die Größe oder Form der Farbblöcke keine Rolle spielt, können mit diesem etwas merkwürdigen Layout einige Bytes abgespielt werden:

HTML + CSS, 121 120 Bytes

Das schlechteste Stück HTML, das ich je geschrieben habe. Ein Byte weniger dank @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 Bytes (halb gültig)

Ich setze dies als semi-gültig, weil das Blau nicht genau # 0000FF Blau ist und auch darauf beruht, dass nicht auf den Link geklickt wurde.

Vielen Dank an @Lynn für die Idee

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|
\----+----+----/

Dies ist die Ausgabe mit der -EOption:

R 89 50 48 Bytes

Neueste Version:

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

Nicht genügend Elemente im Vektor, um die 3x3-Matrix zu füllen. Daher wird das erste Element umgebrochen und wiederverwendet.

Alte Versionen:

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 Byte

Bearbeiten: Sie können das Direktfenster verwenden und auf das Sub/ verzichten End Sub, um 16 Bytes zu sparen:

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

Ursprüngliche Antwort:

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

Dies wurde von Neils Vorschlag zu dieser Antwort inspiriert und ist meine erste Einreichung!

Ergebnis:

-2 Bytes : Entfernen von Zellreihennummern - dank Taylor Scott !

Perl 6 (und wahrscheinlich ähnlich für viele Sprachen) (31 Bytes)

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

Dabei wird eine kopflose TIFF-Datei ausgegeben, die von Photoshop mit der Dateierweiterung .raw erstellt wurde und, sofern zum Zeitpunkt des Öffnens nicht anders angegeben, quadratisch ist. Das Herumspielen mit der Farbtiefe (falls zulässig) könnte dies weiter reduzieren.

ffplay (ffmpeg), 93 Bytes

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

Alt :

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

Bearbeitungen:

1. Vielen Dank an @flawr für den Hinweis, wie die Farben repariert werden können!

2. Konnte durch Ersetzen durch abschneiden, was wie folgt aussehen würde:$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}$$

   sieht aber einfach nicht ganz gleich aus.

3. Könnte wahrscheinlich ein paar Bytes mehr einsparen, wenn Farbnamen gefunden werden, die den beabsichtigten Farben in akzeptabler Weise ähneln.

4. Nur um zu zeigen, wie eine anständige -Version davon aussehen würde:$\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 Bytes

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

Probieren Sie es online!

Mein erster Code Golf Eintrag!

MATL, 44 23 21 20 19 Bytes

Ein direkter Port meiner Octave-Antwort mit den Vorschlägen von @ExpiredData und @LuisMendo.

126973007Bo7B3*e0YG

versuche es online

Octave / MATLAB , 57 56 40 Bytes

-17 Byte dank @ExpiredData! Testen Sie die noch bessere Lösung für Golfer !

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

Probieren Sie es online!

Factorio Blueprint String, 705 Bytes

Ich gebe zu, ich gehe nur an die Grenzen dessen, was als Lösung zählt.

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

Im Spiel erzeugte Ausgabe (niedrige Grafikeinstellungen verwendet):

Um zu beweisen, dass es sich um eine gültige Lösung handelt, müssen Sie dieses Pixelraster abtasten, das genau der Spezifikation entspricht:

Der Rest des Bildes wird als Rand oder Abstand klassifiziert, was, wie in der Frage gesagt, keine Rolle spielt.

Oktave , 38 Bytes

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

Probieren Sie es online!

HTML / CSS, 278 141 137 Bytes

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 Bytes dank Kommentatoren, vor allem @data
-4 Bytes dank @Einacio

Verwendet Unicode █(U + 2588) für die "Blöcke" und verwendet CSS-Klassen / Inline-Stil, um sie einzufärben.

Ich denke, dass die <font>Tags mehr Golf gespielt werden könnten, aber sie in ein kürzeres Tag zu ändern, wie zum Beispiel <a>das colorAttribut zu brechen

JavaScript, 108 102 Bytes

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

Kein Snippet, da dies nur in einer echten Browser-Konsole und nicht in der Snippet-Konsole funktioniert. Edit: Danke an @AJFaraday für den Screenshot. Erläuterung: Browser ermöglichen es dem ersten Parameter von console.log, Ersetzungen einzuschließen. Die %cErsetzung übernimmt einen Parameter und wendet ihn als (bereinigtes) CSS an. Jeder █Block wird daher unter Verwendung der entsprechenden Teilzeichenfolge eingefärbt, die f0ff00f0als dreistelliger hexadezimaler Farbcode interpretiert wird.

HTML (GIF), 108 Byte

Es ist der Kampf der webbasierten Bildformate! (Gibt es TIF- oder JPG-Konkurrenten?)

Antwort von @AC .

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

HTML (BMP), 116 115 Bytes

Antwort nur mit @ ASCII .

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

HTML (WebP), 116 Byte

Antwort von @Hohmannfan .

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

HTML (PNG), 151 136 135 Bytes

-15 Bytes dank @Hohmannfan .

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

Siehe auch meine CSS- und SVG- Antworten.

dc (auf xterm), 64 bytes

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

Du bekommst nur ein paar verrückte Escape-Codes anstelle von Farben, aber du kannst es trotzdem online ausprobieren!

Nach meinem Verständnis können die 16 ANSI-Grundfarben frei interpretiert werden, wie das Terminal dies wünscht. Andererseits haben die 216 Farben im xterm-Farbwürfel explizite RGB-Werte. Ich benutze diese Codes und drucke ein Raster von Xs:

Zuerst setzen wir den Eingaberadix mit auf Basis 15 Fi. Das kostet zwei Bytes, gibt aber drei zurück, also ... einen Nettogewinn von einem Byte (und einen großen Verlust an Lesbarkeit). Als nächstes versuchen wir, unsere Farbwerte auf den Stapel zu bekommen. Im Dezimalformat wäre dies der Fall 21 51 201 51 46 226 201 226 196, aber wir befinden uns im verrückten Modus 16 36 D6 36 31 101 D6 101 D1. Wir entfernen eines der Leerzeichen, indem wir es in ein Makro einfügen, das wir irgendwann definieren müssen [AP]sF(wodurch einfach ein Zeilenvorschub gedruckt wird). Wir können verkleinern 36 D6 36und 101 D6 101indem wir den ersten Wert auf den Stapel legen, duplizieren, den zweiten platzieren und dann tauschen ( 36dD6r, 101dD6r).

Makro Mübernimmt das Drucken und so weiter. 1CPdruckt das Escapezeichen. Klammern werden zur Begrenzung von Zeichenfolgen verwendet. Soweit mir bekannt ist, können Zeichenfolgen nicht umgangen werden. Daher müssen wir die Klammern auch mit einem ASCII-Wert ausgeben 61P. [38;5;]Pist der Code für die Einstellung der Vordergrundfarbe aus der nummerierten Liste. ndruckt den Wert von der Oberseite des Stapels ohne Zeilenumbruch. [mX]PBeendet den Code und gibt ein 'X' aus. z3%0=FÜberprüft die Stapeltiefe Mod 3 und führt Fbei Bedarf unser Zeilenvorschubmakro aus . z0<Mhält Mlaufen, solange es auf dem Stapel Zeug. dsMxzu rennen.

Beachten Sie, dass Ihre Vordergrundfarbe blau bleibt, wenn Sie dies in dc in einem xterm ausführen. 1CP61P74P(Eingabe im Screenshot gezeigt) sollte dies zurücksetzen.

Block Schildkröte, 45 Blöcke

Probieren Sie es online!

Wie wäre es, wenn wir ein kleines Spiel spielen, um das lächerlichste Werkzeug für den Job zu finden?

Ausgabe:

Das Programm (als Screenshot für zusätzliche Häresie):

Hinweis: Die ausgegrauten Blöcke werden auch für die Metrik gezählt.

Node.js, 79 Bytes

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

Erzeugt eine Datei mit dem Namen "P" im PPM-Format, die das Farbraster enthält.

TI-Basic, x Bytes (wird punkten, wenn ich kann)

Hinweis: Der Inhaltsfilter hindert mich daran, die Tokengrößen für jeden dieser Befehle nachzuschlagen. Wenn jemand für mich punkten will, dann mach mit.

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"

Das sieht auf meinem kleinen Taschenrechnerbildschirm wirklich schlecht aus. Aber hey, Form spielt keine Rolle: ^)

Golf-Ausgabe: Modifiziert für 8x größere Ausgabe:

TI-BASIC, x Bytes

Verwenden von Pxl-On anstelle von 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

Ausgang: Aufgeblasen ~ 11x:

C ++, SFML, 177 Bytes

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

Verwendet die sf::Image::create(int,int,unsigned char*)Methode, um ein Bild mit RGB-Werten zu erstellen

C #, 248 204 198 Bytes

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

Ausgabe:

BASIC C64, 106 Bytes

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 Byte

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