¡Esta! es una cuadrícula de color RGB ...

Básicamente es una matriz bidimensional en la que:

• La primera fila y la primera columna son rojas.
• La segunda fila y la segunda columna son verdes.
• La tercera fila y la tercera columna son azules.

Aquí están los colores descritos gráficamente, usando las letras R, G y B.

Así se calcula el color de cada espacio en la cuadrícula.

• Rojo + Rojo = Rojo (# FF0000)
• Verde + Verde = Verde (# 00FF00)
• Azul + Azul = Azul (# 0000FF)
• Rojo + Verde = Amarillo (# FFFF00)
• Rojo + Azul = Púrpura (# FF00FF)
• Verde + azul = verde azulado (# 00FFFF)

El reto

• Escribir código para generar una cuadrícula de color RGB.
• Es un código de golf, así que intente hacerlo en el menor número de bytes.
• Use cualquier lenguaje de programación o lenguaje de marcado para generar su grilla.
• Cosas que me importan:
  • El resultado debería mostrar gráficamente una cuadrícula RGB con los colores definidos.
• Cosas que no me importan:
  • Si el resultado es una imagen, HTML, SVG u otro marcado.
  • El tamaño o la forma de los bloques de colores.
  • Bordes, espacios, etc. entre o alrededor de los bloques.
  • Definitivamente no tiene que tener etiquetas que le digan cuáles deberían ser los colores de fila y columna.

Bash, 44

• 2 bytes guardados gracias a @NahuelFouilleul
• 2 bytes guardados gracias a @manatwork

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

Aquí, los bloques son .personajes. ^[es un carácter de escape ASCII literal (0x1b).

Puede recrear este script de la siguiente manera:

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

8088 ensamblado, IBM PC DOS,  44  43 bytes

Listado:

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

Esto utiliza los INT 10Hservicios de video de IBM PC BIOS para escribir la cuadrícula de colores en la pantalla. Desafortunadamente, la única forma de escribir un atributo de color específico requiere también escribir código para colocar el cursor en la siguiente ubicación correcta, por lo que hay mucho código adicional para eso.

Aquí está la salida que se ejecuta en un PC de IBM CGA (en modo de texto 40x25 para hacerlo más grande).

Descargue y pruebe RGBGRID.COM para DOS.

Wolfram Language (Mathematica) , 41 bytes

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

Wolfram Language (Mathematica) , 68 bytes

Mathematica tiene incorporados para todos estos colores.

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

Código de máquina 80386, IBM PC DOS, 38 bytes

maleficio:

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

salida escalada de dosbox:

Excel VBA (ventana inmediata), 80 bytes

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

Excel VBA (Función), 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

No es una herramienta horrible para el trabajo ... Aprecio el hecho de que Excel ya muestra una cuadrícula, por lo que se trata de establecer el color de fondo.

Gracias a @Neil por sugerir que use en ColorIndexlugar de generar Colorun ahorro de 43 bytes.

-21 bytes gracias a @Keeta

-16 bytes gracias a @Chronocidal por sugerir la "Ventana Inmediata"

-2 bytes gracias a @i_saw_drones

Muchos cambios de mi presentación original :)

GFA Basic 2.02 (Atari ST), 48 bytes

Una lista editada manualmente en formato .LST. Incluye muchos caracteres no imprimibles, cuyos códigos se muestran entre paréntesis.

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

El sistema operativo de Atari ST define los comandos VT52 extendidos que se utilizan aquí.

Salida

$24\times24$$8\times8$

^{captura de pantalla de 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/>

Dado que el tamaño o la forma de los bloques de color no importan, se pueden aprovechar bastantes bytes con este diseño ligeramente extraño:

HTML + CSS, 121 120 bytes

La peor pieza de HTML que he escrito. Un byte ahorrado gracias 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 bytes (semi válido)

Estoy poniendo esto como semi-válido porque el azul no es exactamente # 0000FF azul y también se basa en no haber hecho clic en el enlace.

Gracias a @ Lynn por la idea

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

Esta es la salida usando la -Eopción:

R, 89 50 48 bytes

Versión más nueva:

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

No hay suficientes elementos en el vector para llenar la matriz de 3x3, por lo que se envuelve y reutiliza el primer elemento.

Versiones antiguas:

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 bytes

Editar: puede usar la ventana inmediata y prescindir de Sub/ End Subpara guardar 16 bytes:

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

Respuesta original:

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

Esto fue inspirado por la sugerencia de Neil sobre esta respuesta, ¡y es mi primera presentación!

Resultado:

-2 bytes : Eliminación de números de fila de celdas, ¡gracias a Taylor Scott !

Perl 6 (y probablemente similar para muchos idiomas) (31 bytes)

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

Esto genera un archivo TIFF sin cabeza, que solía generar Photoshop con la extensión de archivo .raw y se presume que es cuadrado a menos que se especifique lo contrario en el momento de la apertura. Jugar con la profundidad de color (si está permitido) podría reducir esto aún más.

ffplay (ffmpeg), 93 bytes

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

Viejo :

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

Ediciones:

1. ¡Gracias a @flawr por señalar cómo arreglar los colores!

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

   , pero simplemente no se ve exactamente igual.

3. Probablemente podría reducir algunos bytes más al encontrar nombres de colores que se parezcan aceptablemente a los colores previstos.

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

Pruébalo en línea!

Mi primer código de entrada de golf!

MATL, 44 23 21 20 19 bytes

Un puerto directo de mi respuesta Octave con las sugerencias de @ExpiredData y @LuisMendo.

126973007Bo7B3*e0YG

pruébalo en línea

Octava / MATLAB , 57 56 40 bytes

-17 byte gracias a @ExpiredData! ¡Mira su solución aún más golfista !

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

Pruébalo en línea!

Cadena de planos de Factorio, 705 bytes

Lo admito, solo estoy empujando los límites de lo que cuenta como una solución.

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

Salida producida cuando se coloca en el juego (se utilizan configuraciones de gráficos bajos):

Para demostrar que es una solución válida, necesita probar esta cuadrícula de píxeles que coinciden exactamente con la especificación:

El resto de la imagen se clasifica como un borde o un espaciado que, como se dijo en la pregunta, no importa.

Octava , 38 bytes

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

Pruébalo en línea!

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 gracias a los comentaristas, especialmente @data
-4 bytes gracias a @Einacio

Utiliza Unicode █(U + 2588) para los "bloques" y utiliza clases CSS / estilo en línea para colorearlos.

Creo que las <font>etiquetas podrían jugar más golf, sin embargo, cambiarlas a una etiqueta más corta, como <a>romper el coloratributo

JavaScript, 108102 bytes

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

Sin fragmento porque esto solo funciona en una consola de navegador real y no en la consola del fragmento. Editar: Gracias a @AJFaraday por la captura de pantalla. Explicación: Los navegadores permiten que el primer parámetro console.logincluya sustituciones. La %csustitución toma un parámetro y lo aplica como CSS (desinfectado). █Por lo tanto, cada bloque se colorea usando la subcadena apropiada de f0ff00f0interpretado como un código de color de tres dígitos hexadecimales.

HTML (GIF), 108 bytes

¡Es la batalla de los formatos de imagen basados ​​en la web! (¿Algún competidor de TIF o JPG por ahí?)

Respuestas de @AC .

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

HTML (BMP), 116 115 bytes

Respuesta por @ ASCII-only .

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

HTML (WebP), 116 bytes

Respuestas de @Hohmannfan .

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

HTML (PNG), 151 136 135 bytes

-15 bytes gracias a @Hohmannfan .

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

Además, vea mis respuestas CSS y SVG .

dc (en xterm), 64 bytes

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

Solo obtendrá un montón de códigos de escape extravagantes en lugar de colores, ¡pero aún puede probarlo en línea!

Según tengo entendido, los 16 colores básicos ANSI son libres de ser interpretados como quiera el terminal. Por otro lado, los 216 colores en el cubo de color xterm tienen valores RGB explícitos. Estoy usando estos códigos e imprimiendo una cuadrícula de Xs:

Primero establecemos la raíz de entrada a base 15 con Fi. Esto cuesta dos bytes, pero devuelve tres, así que ... una ganancia neta de un byte (y una gran pérdida de legibilidad). A continuación, intentamos obtener nuestros valores de color en la pila. En decimal, esto sería 21 51 201 51 46 226 201 226 196, pero estamos en modo loco, así que será 16 36 D6 36 31 101 D6 101 D1. Eliminamos uno de los espacios colocando en una macro que necesitamos definir en algún momento [AP]sF(que simplemente imprime un avance de línea). Podemos reducir 36 D6 36y 101 D6 101colocando el primer valor en la pila, duplicándolo, colocando el segundo y luego intercambiando ( 36dD6r, 101dD6r).

Macro Mmaneja la impresión y demás. 1CPimprime el personaje de escape. Los corchetes se usan para delimitar cadenas, y que yo sepa, no se pueden escapar, por lo que también necesitamos imprimir el corchete con un valor ASCII 61P. [38;5;]Pes el código 'establecer color de primer plano de la lista numerada'. nimprime el valor desde la parte superior de la pila con una nueva línea, haciendo estallarlo. [mX]Ptermina el código e imprime una 'X'. z3%0=Fcomprueba la profundidad de pila mod 3, ejecutando nuestra macro de avance de línea Fcuando sea necesario. z0<Msigue Mfuncionando mientras haya cosas en la pila. dsMxcorrer.

Tenga en cuenta que si ejecuta esto en CC en un xterm, dejará su color de primer plano azul. 1CP61P74P(la entrada que se muestra en la captura de pantalla) debería restablecer esto.

Tortuga Blockly, 45 bloques

Pruébalo en línea!

¿Qué tal si jugamos un pequeño juego para encontrar la herramienta más ridícula para el trabajo?

Salida:

El programa (como captura de pantalla para herejía adicional):

Nota: Los bloques en gris también se cuentan hacia la métrica.

Node.js, 79 bytes

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

Produce un archivo llamado "P" en el formato PPM que contiene la cuadrícula de colores.

TI-Basic, x bytes (marcaré cuando pueda)

Nota: el filtro de contenido me impide buscar los tamaños de token para cada uno de estos comandos. Si alguien quiere marcar para mí, anímate.

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"

Esto se ve muy mal en mi pequeña pantalla de calculadora. Pero bueno, la forma no importa: ^)

Salida de golf: modificada para una salida 8x mayor:

TI-BASIC, x bytes

Usando Pxl-On en lugar de Texto:

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

Salida: explotada ~ 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");}

Utiliza el sf::Image::create(int,int,unsigned char*)método para crear una imagen con valores rgb

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

Salida:

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 bytes

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