Este! é uma grade de cores RGB ...

Basicamente, é uma matriz bidimensional na qual:

• A primeira linha e a primeira coluna são vermelhas.
• A segunda linha e a segunda coluna são verdes.
• A terceira linha e a terceira coluna são azuis.

Aqui estão as cores descritas graficamente, usando as letras R, G e B.

Veja como calculamos a cor de cada espaço na grade.

• Vermelho + Vermelho = Vermelho (# FF0000)
• Verde + Verde = Verde (# 00FF00)
• Azul + Azul = Azul (# 0000FF)
• Vermelho + Verde = Amarelo (# FFFF00)
• Vermelho + azul = roxo (# FF00FF)
• Verde + azul = azul-petróleo (# 00FFFF)

O desafio

• Escreva um código para gerar uma grade de cores RGB.
• É código de golfe, então tente fazê-lo no menor número de bytes.
• Use qualquer linguagem de programação ou linguagem de marcação para gerar sua grade.
• Coisas que me interessam:
  • O resultado deve exibir graficamente uma grade RGB com as cores definidas.
• Coisas com as quais não me importo:
  • Se a saída for uma imagem, HTML, SVG ou outra marcação.
  • O tamanho ou a forma dos blocos de cores.
  • Fronteiras, espaçamento etc. entre ou ao redor dos blocos.
  • Definitivamente, ele não precisa ter rótulos informando quais devem ser as cores da linha e da coluna.

Bash, 44

• 2 bytes salvos graças a @NahuelFouilleul
• 2 bytes salvos graças a @manatwork

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

Aqui, blocos são .caracteres. ^[é um caractere de escape ASCII literal (0x1b).

Você pode recriar esse script da seguinte maneira:

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

Montagem 8088, IBM PC DOS,  44  43 bytes

Listagem:

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

Isso usa os INT 10Hserviços de vídeo do IBM PC BIOS para gravar a grade de cores na tela. Infelizmente, a única maneira de escrever um atributo de cor específico também exige escrever código para colocar o cursor no próximo local correto, portanto, há muito código extra para isso.

Aqui está a saída em execução em um IBM PC CGA (no modo de texto 40x25 para aumentá-lo).

Faça o download e teste o RGBGRID.COM para DOS.

Wolfram Language (Mathematica) , 41 bytes

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

Wolfram Language (Mathematica) , 68 bytes

O Mathematica possui built-ins para todas essas cores.

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

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

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

saída em escala do dosbox:

Excel VBA (janela imediata), 80 bytes

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

Excel VBA (Função), 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

Não é uma ferramenta horrível para o trabalho ... Aprecio o fato de o Excel já mostrar uma grade, por isso é uma questão de definir a cor do plano de fundo.

Os nossos agradecimentos a @Neil por sugerir o uso em ColorIndexvez de gerar Coloruma economia de 43 bytes.

-21 bytes graças a @Keeta

-16 bytes graças a @Chronocidal por sugerir a "Janela imediata"

-2 bytes graças a @i_saw_drones

Muitas alterações do meu envio original :)

GFA Basic 2.02 (Atari ST), 48 bytes

Uma listagem editada manualmente no formato .LST. Inclui muitos caracteres não imprimíveis, cujos códigos são mostrados entre colchetes.

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

O sistema operacional do Atari ST define comandos VT52 estendidos que são usados ​​aqui.

Resultado

$24\times24$$8\times8$

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

Como o tamanho ou a forma dos blocos de cores não importa, é possível obter alguns bytes com este layout um pouco estranho:

HTML + CSS, 121 120 bytes

Pior pedaço de HTML que eu já escrevi. Economize um byte graças 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)

Estou colocando isso como semi-válido, porque o azul não é exatamente # 0000FF azul e também depende de não ter clicado no link.

Obrigado a @Lynn pela ideia

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 é a saída usando a -Eopção:

R, 89 50 48 bytes

Versão mais recente:

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

Não há elementos suficientes no vetor para preencher a matriz 3x3; portanto, ela envolve e reutiliza o primeiro elemento.

Versões antigas:

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: você pode usar a janela imediata e dispensar o Sub/ End Subpara salvar 16 bytes:

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

Resposta original:

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

Isso foi inspirado na sugestão de Neil sobre essa resposta e é minha primeira submissão!

Resultado:

-2 bytes : Remoção de números de linhas de células - graças a Taylor Scott !

Perl 6 (e provavelmente semelhante para muitos idiomas) (31 bytes)

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

Isso gera um arquivo TIFF sem cabeça, que costumava ser gerado pelo Photoshop com a extensão .raw e presume-se quadrado, a menos que seja especificado de outra forma no momento da abertura. Brincar com a profundidade da cor (se permitida) pode reduzir ainda mais essa questão.

ffplay (ffmpeg), 93 bytes

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

Antigo :

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

Editar% s:

1. Agradecemos a @flawr por mostrar como corrigir as cores!

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

   , mas simplesmente não parece o mesmo.

3. Provavelmente, poderia economizar mais alguns bytes encontrando nomes de cores que se assemelhem às cores pretendidas.

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

Experimente online!

Minha primeira entrada de código de golfe!

MATL, 44 23 21 20 19 bytes

Uma porta direta da minha oitava responde com as sugestões de @ExpiredData e @LuisMendo.

126973007Bo7B3*e0YG

experimente online

Oitava / MATLAB , 57 56 40 bytes

-17 bytes graças a @ExpiredData! Confira sua solução ainda mais golfista !

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

Experimente online!

Fatorio Blueprint String, 705 bytes

Eu admito, estou apenas ultrapassando os limites do que conta como solução.

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

Saída produzida quando colocada no jogo (configurações gráficas baixas usadas):

Para provar que é uma solução válida, é necessário provar esta grade de pixels que correspondem exatamente à especificação:

O restante da imagem é classificado como uma borda ou um espaçamento que, como dito na pergunta, não importa.

Oitava , 38 bytes

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

Experimente 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 graças a comentaristas, principalmente @data
-4 bytes graças a @Einacio

Usa Unicode █(U + 2588) para os "blocos" e usa classes CSS / estilo embutido para colori-los.

Eu acho que as <font>tags podem ter mais golf, no entanto, alterá-las para uma tag mais curta, como <a>quebra o coloratributo

JavaScript, 108 102 bytes

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

Nenhum trecho porque isso funciona apenas em um console do navegador real e não no console do trecho. Edit: Obrigado a @AJFaraday pela captura de tela. Explicação: Os navegadores permitem que o primeiro parâmetro console.loginclua substituições. A %csubstituição pega um parâmetro e o aplica como CSS (higienizado). █Portanto, cada bloco é colorido usando a substring apropriada f0ff00f0interpretada como um código de cores de três dígitos hexadecimais.

HTML (GIF), 108 bytes

É a batalha dos formatos de imagem baseados na Web! (Algum candidato a TIF ou JPG por aí?)

Responder por @AC .

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

HTML (BMP), 116 115 bytes

Responder por @ apenas ASCII .

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

HTML (WebP), 116 bytes

Responder por @Hohmannfan .

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

HTML (PNG), 151 136 135 bytes

-15 bytes graças a @Hohmannfan .

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

Veja também minhas respostas em CSS e SVG .

dc (no xterm), 64 bytes

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

Você receberá apenas um monte de códigos de escape malucos em vez de cores, mas ainda poderá experimentá-lo online!

Pelo meu entendimento, as 16 cores básicas do ANSI são livres para serem interpretadas da maneira que o terminal desejar. Por outro lado, as 216 cores no cubo de cores xterm têm valores RGB explícitos. Estou usando esses códigos e imprimindo uma grade de Xs:

Primeiro, ajustamos o raio de entrada para a base 15 com Fi. Isso custa dois bytes, mas retorna três, então ... um ganho líquido de um byte (e uma grande perda de legibilidade). Em seguida, estamos tentando colocar nossos valores de cores na pilha. Em decimal, isso seria21 51 201 51 46 226 201 226 196 , mas estamos no modo maluco, então será 16 36 D6 36 31 101 D6 101 D1. Eliminamos um dos espaços inserindo uma macro que precisamos definir em algum momento [AP]sF(que simplesmente imprime um avanço de linha). Podemos reduzir 36 D6 36e 101 D6 101colocando o primeiro valor na pilha, duplicando-o, colocando o segundo e depois trocando ( 36dD6r, 101dD6r).

Macro Mlida com a impressão e outros enfeites. 1CPimprime o caractere de escape. Os colchetes são usados ​​para delimitar as strings e, até onde eu sei, não são escapáveis, portanto, precisamos imprimir o colchete com um valor ASCII também 61P. [38;5;]Pé o código 'definir cor de primeiro plano da lista numerada'. nimprime o valor da parte superior da pilha sem uma nova linha, exibindo-a.[mX]Ptermina o código e imprime um 'X'. z3%0=Fverifica a profundidade da pilha mod 3, executando nossa macro de avanço de linha Fquando necessário. z0<Mcontinua Mfuncionando enquanto houver coisas na pilha. dsMxpara correr.

Observe que, se você executar isso em CC em um xterm, a cor do primeiro plano ficará azul. 1CP61P74P(entrada mostrada na captura de tela) deve redefinir isso.

Tartaruga Blockly, 45 blocos

Experimente online!

Que tal jogar um pequeno jogo de encontrar a ferramenta mais ridícula para o trabalho?

Resultado:

O programa (como uma captura de tela para heresia adicional):

Nota: Os blocos acinzentados também são contados na métrica.

Node.js, 79 bytes

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

Produz um arquivo chamado "P" no formato PPM que contém a grade de cores.

TI-Basic, x bytes (será pontuado quando puder)

Nota: o filtro de conteúdo está me impedindo de procurar os tamanhos de token para cada um desses comandos. Se alguém quiser marcar para mim, vá em frente.

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"

Isso parece muito ruim na minha pequena tela de calculadora. Mas ei, a forma não importa: ^)

Saída de golfe: Modificada para uma saída 8x maior:

TI-BASIC, x bytes

Usando Pxl-On em vez 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

Saída: ampliada ~ 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");}

Usa o sf::Image::create(int,int,unsigned char*)método para criar uma imagem com 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");}}}

Resultado:

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]