Questo! è una griglia di colori RGB ...

Fondamentalmente è una matrice bidimensionale in cui:

• La prima riga e la prima colonna sono rosse.
• La seconda riga e la seconda colonna sono verdi.
• La terza riga e la terza colonna sono blu.

Ecco i colori descritti graficamente, usando le lettere R, G e B.

Ecco come viene calcolato il colore di ogni spazio sulla griglia.

• Rosso + Rosso = Rosso (# FF0000)
• Verde + Verde = Verde (# 00FF00)
• Blu + Blu = Blu (# 0000FF)
• Rosso + Verde = Giallo (# FFFF00)
• Rosso + Blu = Viola (# FF00FF)
• Verde + Blu = Verde acqua (# 00FFFF)

La sfida

• Scrivi il codice per generare una griglia di colori RGB.
• È il golf del codice, quindi prova a farlo nel minor numero di byte.
• Usa qualsiasi linguaggio di programmazione o linguaggio di markup per generare la tua griglia.
• Cose a cui tengo:
  • Il risultato dovrebbe visualizzare graficamente una griglia RGB con i colori definiti.
• Cose che non mi interessano:
  • Se l'output è un'immagine, HTML, SVG o altro markup.
  • La dimensione o la forma dei blocchi di colore.
  • Bordi, spaziatura ecc. Tra o attorno ai blocchi.
  • Non è necessario che le etichette ti dicano quali dovrebbero essere i colori delle righe e delle colonne.

Bash, 44

• 2 byte salvati grazie a @NahuelFouilleul
• 2 byte salvati grazie a @manatwork

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

Qui, i blocchi sono .personaggi. ^[è un carattere letterale di escape ASCII (0x1b).

È possibile ricreare questo script come segue:

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

8088 assembly, IBM PC DOS,  44  43 byte

annuncio:

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

Questo utilizza i INT 10Hservizi video BIOS del PC IBM per scrivere la griglia dei colori sullo schermo. Sfortunatamente, l'unico modo per scrivere un attributo di colore specifico richiede anche la scrittura di codice per posizionare il cursore nella posizione corretta successiva, quindi c'è molto codice aggiuntivo per quello.

Ecco l'output in esecuzione su un PC CGA IBM (in modalità testo 40x25 per ingrandirlo).

Scarica e prova RGBGRID.COM per DOS.

Wolfram Language (Mathematica) , 41 byte

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

Wolfram Language (Mathematica) , 68 byte

Mathematica ha incorporato per tutti questi colori.

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

80386 codice macchina, IBM PC DOS, 38 byte

esadecimale:

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

output ridimensionato da dosbox:

Excel VBA (finestra immediata), 80 byte

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

Excel VBA (funzione), 96 byte

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

Non è uno strumento orribile per il lavoro ... Apprezzo il fatto che Excel mostri già una griglia, quindi si tratta di impostare il colore di sfondo.

Ringraziamo @Neil per aver suggerito di utilizzare ColorIndexinvece di Colorportare a un risparmio di 43 byte.

-21 byte grazie a @Keeta

-16 byte grazie a @Chronocidal per aver suggerito la "Finestra immediata"

-2 byte grazie a @i_saw_drones

Molte modifiche dalla mia presentazione originale :)

GFA Basic 2.02 (Atari ST), 48 byte

Un elenco modificato manualmente in formato .LST. Include molti caratteri non stampabili, i cui codici sono indicati tra parentesi.

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

Il sistema operativo di Atari ST definisce comandi VT52 estesi che vengono utilizzati qui.

Produzione

$24\times24$$8\times8$

^{screenshot di Steem SSE}

SVG, 210 182 byte

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

Dal momento che la dimensione o la forma dei blocchi di colore non ha importanza, è possibile eliminare alcuni byte con questo layout leggermente strano:

HTML + CSS, 121 120 byte

Il peggior pezzo di HTML che abbia mai scritto. Risparmio di un byte grazie a @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 byte (semi valido)

Lo sto mettendo come semi-valido perché il blu non è esattamente # 0000FF blu e si basa anche sul fatto di non aver fatto clic sul collegamento.

Grazie a @Lynn per l'idea

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

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

ditaa , 118 byte

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

Questo è l'output usando l' -Eopzione:

R, 89 50 48 byte

Ultima versione:

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

Non ci sono abbastanza elementi nel vettore per riempire la matrice 3x3, quindi si avvolge e riutilizza il primo elemento.

Vecchie versioni:

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

Modifica: è possibile utilizzare la finestra immediata e dispensare con Sub/ End Subper salvare 16 byte:

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

Risposta originale:

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

Questo è stato ispirato dal suggerimento di Neil su questa risposta, ed è la mia prima presentazione!

Risultato:

-2 byte : rimozione dei numeri di riga delle celle - grazie a Taylor Scott !

Perl 6 (e probabilmente simile per molte lingue) (31 byte)

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

Questo genera un file TIFF senza testa, che prima era generato da Photoshop con estensione .raw e si presume che sia quadrato se non diversamente specificato al momento dell'apertura. Giocare con l'intensità del colore (se consentito) potrebbe ridurlo ulteriormente.

ffplay (ffmpeg), 93 byte

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

Vecchio :

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

modifiche:

1. Grazie a @flawr per aver sottolineato come correggere i colori!

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

   , ma non sembra proprio lo stesso.

3. Probabilmente potrebbe radere qualche byte in più trovando nomi di colore che assomigliano in modo accettabile ai colori previsti.

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 byte

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

Provalo online!

Il mio primo codice golf entry!

MATL, 44 23 21 20 19 byte

Una porta diretta della mia Octave risponde con i suggerimenti di @ExpiredData e @LuisMendo.

126973007Bo7B3*e0YG

provalo online

Octave / MATLAB , 57 56 40 byte

-17 byte grazie a @ExpiredData! Scopri la loro soluzione ancora più golfista !

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

Provalo online!

Factorio Blueprint String, 705 byte

Lo ammetto, sto solo spingendo i limiti di ciò che conta come soluzione.

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

Prodotto prodotto quando inserito nel gioco (utilizzate impostazioni grafiche basse):

Per dimostrare che si tratta di una soluzione valida è necessario campionare questa griglia di pixel che corrispondono esattamente alle specifiche:

Il resto dell'immagine è classificato come un bordo o una spaziatura che, come detto nella domanda, non ha importanza.

Ottava , 38 byte

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

Provalo online!

HTML / CSS, 278 141 137 byte

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 byte grazie ai commentatori, in particolare @data
-4 byte grazie a @Einacio

Utilizza Unicode █(U + 2588) per i "blocchi" e utilizza le classi CSS / stile in linea per colorarli.

Penso che i <font>tag potrebbero essere più giocati a golf, tuttavia cambiandoli in un tag più breve come <a>spezza l' colorattributo

JavaScript, 108 102 byte

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

Nessuno snippet perché funziona solo in una vera console del browser e non nella console dello snippet. Modifica: grazie a @AJFaraday per lo screenshot. Spiegazione: I browser consentono al primo parametro di console.logincludere sostituzioni. La %csostituzione accetta un parametro e lo applica come CSS (sanificato). Ogni █blocco viene quindi colorato usando la sottostringa appropriata f0ff00f0interpretata come un codice colore a tre cifre esadecimali.

HTML (GIF), 108 byte

È la battaglia dei formati di immagini basati sul web! (Qualche contendente TIF o JPG là fuori?)

Risposta di @AC .

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

HTML (BMP), 116 115 byte

Risposta solo per @ ASCII .

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

HTML (WebP), 116 byte

Risposta di @Hohmannfan .

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

HTML (PNG), 151 136 135 byte

-15 byte grazie a @Hohmannfan .

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

Inoltre, vedi le mie risposte CSS e SVG .

dc (su xterm), 64 byte

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

Riceverai un sacco di codici di fuga stravaganti invece di colori, ma puoi ancora provarlo online!

Secondo la mia comprensione, i 16 colori ANSI di base sono liberi di essere interpretati nel modo desiderato dal terminale. D'altra parte, i 216 colori nel cubo di colore xterm hanno valori RGB espliciti. Sto usando questi codici e stampando una griglia di Xs:

Innanzitutto impostiamo l'ingresso radix su base 15 con Fi. Questo costa due byte, ma ne restituisce tre, quindi ... un guadagno netto di un byte (e una grande perdita di leggibilità). Quindi stiamo provando a mettere i nostri valori di colore in pila. In decimale, questo sarebbe 21 51 201 51 46 226 201 226 196, ma siamo in modalità stravagante, quindi sarà 16 36 D6 36 31 101 D6 101 D1. Eliminiamo uno degli spazi inserendo una macro che dobbiamo definire ad un certo punto [AP]sF(che stampa semplicemente un avanzamento riga). Possiamo ridurre 36 D6 36e 101 D6 101posizionando il primo valore nello stack, duplicandolo, posizionando il secondo e quindi scambiando ( 36dD6r, 101dD6r).

La macro Mgestisce la stampa e quant'altro. 1CPstampa il carattere di fuga. Le parentesi vengono utilizzate per delimitare le stringhe e, per quanto ne so, non sono evitabili, quindi è necessario stampare anche la parentesi con un valore ASCII 61P. [38;5;]Pè il codice "imposta il colore di primo piano dall'elenco numerato". nstampa il valore dall'alto dello stack senza una nuova riga, facendolo scattare. [mX]Ptermina il codice e stampa una "X". z3%0=Fcontrolla la profondità dello stack mod 3, eseguendo la nostra macro di avanzamento riga Fquando necessario. z0<Mcontinua a Mfunzionare finché ci sono elementi nello stack. dsMxcorrere.

Nota che se lo esegui in cc in un xterm, il colore di primo piano verrà lasciato in blu. 1CP61P74P(input mostrato nella schermata) dovrebbe ripristinare questo.

Tartaruga a blocchi, 45 blocchi

Provalo online!

Che ne dici di giocare a un piccolo gioco per trovare lo strumento più ridicolo per il lavoro?

Produzione:

Il programma (come screenshot per un'eresia aggiuntiva):

Nota: anche i blocchi in grigio vengono conteggiati verso la metrica.

Node.js, 79 byte

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

Produce un file denominato "P" nel formato PPM contenente la griglia dei colori.

TI-Basic, x byte (segnerà quando posso)

Nota: il filtro contenuti mi impedisce di cercare le dimensioni del token per ciascuno di questi comandi. Se qualcuno vuole segnare per me, provaci.

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"

Questo sembra davvero brutto sulla mia piccola schermata della calcolatrice. Ma hey, la forma non ha importanza: ^)

Uscita golf: modificata per un output 8 volte maggiore:

TI-BASIC, x byte

Usando Pxl-On invece di 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

Uscita: esplosa ~ 11x:

C ++, SFML, 177 byte

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

Utilizza il sf::Image::create(int,int,unsigned char*)metodo per creare un'immagine con valori rgb al suo interno

C #, 248 204 198 byte

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

Produzione:

BASIC C64, 106 byte

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]