A paleta CGA de 16 cores (também conhecida como cores HTML ) é um conjunto de 16 cores usadas pelos primeiros adaptadores gráficos. O objetivo desse desafio é gerar todos os 16 deles, no formato hexadecimal ( RRGGBB), em ordem crescente por valor hexadecimal, separados por novas linhas. Assim, a saída deve ser exatamente isso:

000000
000080
0000FF
008000
008080
00FF00
00FFFF
800000
800080
808000
808080
C0C0C0
FF0000
FF00FF
FFFF00
FFFFFF

Uma única nova linha à direita é permitida, mas não necessária.

Geléia , 31 29 27 bytes

“×Ɗ¡‘ŒP»Ṫ¦209ṗ€3Fd⁴ịØHs3ṢQY

Experimente online!

Como funciona

“×Ɗ¡‘forneça os pontos de código dos caracteres entre as aspas no SBCS de Jelly , que são 0x11 = 17 , 0x91 = 145 e 0x00 = 0 .

ŒP constrói o conjunto de potências da matriz de pontos de código, produzindo

[[], [17], [145], [0], [17, 145], [17, 0], [145, 0], [17, 145, 0]]

As duas últimas entradas correspondem a combinações que contêm 80 e FF , portanto, temos que descartá-las.

»Ṫ¦209 consiste em três partes:

• Ṫ(cauda) remove a última matriz de pontos de código, ou seja, [17, 145, 0] .

• »209pega o máximo de cada número inteiro no restante do conjunto de potência e 0xD1 = 209 , substituindo todos por 209 .

• ¦(esparso) itera sobre os elementos do restante do conjunto de potência. Se o índice correspondente for encontrado em [17, 145, 0] , o elemento será substituído por todos os 209 's. Caso contrário, ele permanece intocado.

  ¦não é modular, portanto, modifica apenas a última matriz (índice 0 ) no restante do conjunto de potência. Os índices 17 e 145 são muito grandes e não têm efeito.

O resultado é o seguinte.

[[], [17], [145], [0], [17, 145], [17, 0], [209, 209]]

ṗ€3 calcula a terceira potência cartesiana de cada matriz, ou seja, a matriz de todas as 3 tuplas de elementos de cada matriz.

Fd⁴nivela o resultado e calcula o quociente e o restante de cada número inteiro dividido por 16 .

ịØHíndices (com base em 1) em "0123456789ABCDEF , para que 0x11 , 0x91 , 0x00 e 0xD1 sejam mapeados para " 00 " , " 80 " , " FF " e " C0 " (resp.).

s3ṢQ divide os pares de caracteres em três tuplas, classifica as tuplas e deduplica.

Por fim, Yune as tuplas exclusivas, separando por feeds de linha.

Utilitários Bash + GNU, 67

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

a={00,80,FF}
eval echo $a$a$a|fmt -w9|sed '16iC0C0C0
/F0*8\|80*F/d'

• A expansão de braçadeira {00,80,FF}{00,80,FF}{00,80,FF} fornece todas as combinações de necessidade na ordem correta (excluindo C0C0C0), além de alguns extras. Os extras são os que contêm ambos Fe 8caracteres.
• O resultado da expansão do braquete é uma única linha separada por espaço. fmtcoloca cada entrada em sua própria linha
• A primeira linha da sedexpressão é inserida C0C0C0na linha apropriada
• A segunda linha da sedexpressão filtra os "extras" descritos acima.

Ideone .

Geléia , 38 31 bytes

“mạ9ṣṃwɠƁ,¡ẓw’b4µża1$ị“08CF”s3Y

TryItOnline!

Compactação da base 250 de um número ( “...’),
convertida em base 4 ( b4),
zipada ( ż) com uma cópia de si mesma após uma lógica vetorizada - e com 1 ( a1$) *,
indexada ( ị) nos quatro caracteres usados ​​( “08CF”),
divididos em partes de comprimento 3 ( s3)
e associado a feeds de linha ( Y).

* Assim, emparelhe cada dígito zero com outro zero e cada um dos outros dígitos com um. Juntamente com o seguinte indexado buscar este meio 'F'torna-se emparelhado com outro 'F'enquanto que '0', '8', e 'C'cada par com um '0'.

Python 3, 134 129 125 108 91 90 bytes

Eu acho que ainda há muito golfe para fazer aqui. Sugestões de golfe são bem-vindas!

Edit: -9 bytes e muito obrigado ao Mego por ajudar na formatação da string. -17 bytes para descobrir uma maneira melhor de imprimir a string em primeiro lugar. -17 bytes para descobrir uma maneira melhor de escrever o loop for em primeiro lugar. -1 byte graças à dica do xnor para usar em i%3//2*"\n"vez de "\n"*(i%3<2).

for i in range(48):print(end="F0C8F000"[0x10114abf7f75c147d745d55//4**i%4::4]+i%3//2*"\n")

Ungolfing

z = 0
a = [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 2, 2, 2, 3, 3, 3, 1, 3, 3, 3, 1, 3, 1, 1, 3, 0, 0, 1, 1, 0, 1, 3, 3, 1, 1, 3, 1, 0, 1, 1, 3, 1, 1, 1, 1, 1]
for i in range(len(a)):
    z = (z + a[i]) * 4
z //= 4                   # we multiplied by 4 one too many times
for i in range(48):
    m = z // 4**j % 4
    s = "F0C8F000"[c::4]
    if i % 3 == 2:
        s += "\n"
    print(s, end="")

JavaScript (ES6), 109 107 bytes

Economizou 2 bytes, graças a Neil

Isso é 7 9 bytes mais curto do que apenas retornar a string bruta nos backticks.

_=>[...'1121173113106393'].map(v=>[4,2,0].map(x=>'08CF'[x=n>>x&3]+'000F'[x],n+=+v||21).join``,n=-1).join`
`

Teste

let f =

_=>[...'1121173113106393'].map(v=>[4,2,0].map(x=>'08CF'[x=n>>x&3]+'000F'[x],n+=+v||21).join``,n=-1).join`
`

console.log(f())

PowerShell, 113 106 bytes

'777
7780
77FF
7807
78080
7FF7
7FFFF
8077
80780
80807
808080
C0C0C0
FF77
FF7FF
FFFF7
FFFFFF'-replace7,'00'

Sim, não encontrei nada mais curto do que apenas imprimir a string literal ... Obrigado a @ Martin Smith por reduzir 7 bytes usando uma substituição simples (que eu esqueci completamente). Portanto, somos pelo menos 7 bytes mais curtos do que simplesmente codificá-lo. Yay!

Mas isso é chato!

Então, ao invés ...

PowerShell v4, 128 bytes

[consolecolor[]](0,7+9..15)+-split'Lime Maroon Navy Olive Purple Silver Teal'|%{-join"$([windows.media.colors]::$_)"[3..8]}|sort

O [system.consolecolor]espaço para nome define as cores do console (nativamente) disponíveis para o console do PowerShell. Se os referenciarmos por meio de uma matriz inteira como esta, o valor padrão é o nome (por exemplo, Blackou Whiteou similar). Combinamos isso com uma sequência de caracteres que está -splitnos espaços, e agora temos uma série de sequências de nomes de cores.

Passamos por eles |%{...}e cada iteração extrai o [system.windows.media.colors]valor correspondente . A string padrão para esses objetos é a cor no #AARRGGBBformato como um valor hexadecimal, por isso aproveitamos isso encapsulando essa chamada em uma string com um bloco de script "$(...)". Mas, como não queremos os valores alfa ou o hash, pegamos o backend [3..8]da string e precisamos do array -joinresultante de charvolta em uma string. Então, é simples Sort-Objectcolocá-los na ordem certa.

Pitão - 64 48 44 bytes

Compactação básica super simples.

jcs@L"FC80"jC"ÿÿûÿ¿û¿ðÿ¿»¿»·wðð\0ð\0"4 6

Experimente online aqui .

MATL , 39 bytes

'80FFC000'2e'3na:1Fswv1=`uIn'F4:ZaZ)6e!

Experimente online!

'80FFC000'         % Push this string
2e                 % Reshape with 2 rows. So 1st column contains '80', 2nd 'FF' etc
'3na:1Fswv1=`uIn'  % Push this string
F4:Za              % Convert from base 95 to alphabet [1 2 3 4]
Z)                 % Use as column indices into the first string
6e!                % Reshape with 6 rows and transpose.
                   % Implicitly display

05AB1E , 57 bytes

•P{Ætg7«r¨ëÅ,…}ù¢Ý%Vt®£8ãøÚ$0óDÛY²Zþ…ð7ê‘Ó{òìàYëØU¥•hR6ô»

Experimente online!

O que precisamos produzir é basicamente (invertido e dividido):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Qual, em decimal é:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Que na Base-214 é:

P{Ætg7«r¨ëÅ,…}ù¢Ý%Vt®£8ãøÚ$0óDÛY²Zþ…ð7ê‘Ó{òìàYëØU¥

Esta é a solução mais simples que eu poderia encontrar, porque de jeito nenhum estou derrotando Dennis. Passou uma hora tentando e nada superou sua idéia.

PHP, 92 bytes

<?=strtr("000
001
002
010
011
020
022
100
101
110
111
333
200
202
220
222",["00",80,FF,CO]);

Experimente online!

basta substituir os dígitos como chave na matriz pelos valores strtr

Lote, 137 bytes

@for %%c in (000000 000080 0000FF 008000 008080 00FF00 00FFFF 800000 800080 808000 808080 C0C0C0 FF0000 FF00FF FFFF00 FFFFFF)do @echo %%c

Sim, é tão chato. Tentativa anterior de 148 bytes:

@if "%2"=="" (call %0 000000 80&call %0 C0C0C0 FF)|sort&exit/b
@echo %1
@for %%c in (0000%2 00%200 00%2%2 %20000 %200%2 %2%200 %2%2%2)do @echo %%c

Infelizmente você não pode canalizar a saída de um forou de um call:comando, então eu tenho que me invocar recursivamente.

Pyke, 42 bytes

"80FF"2c8DF3"00"]F3+b2tRT`_R.:(s}"C0"3*+SJ

Experimente aqui!

Befunge, 83 69 bytes

<v"UVTYZQPefij?EDA@"
v>>9\:4/:\4/>4%:3g,0`
<^_@#:,+55$_^#!-9:,g3
F08C

Experimente online!

As cores são codificadas na sequência que você vê na primeira linha, dois bits por componente de cor, com um bit alto adicional definido para forçar cada valor ao intervalo ASCII (exceto no caso de 63, que estaria fora do intervalo como 127 )

A lista de cores na pilha é processada da seguinte maneira:

9\          9 is pushed behind the current colour to serve as a marker.
:4/:\4/     The colour is repeatedly divided by 4, splitting it into 3 component parts.

>           The inner loop deals with each of the 3 components. 
 4%         Modulo 4 masks out the 2 bits of the colour component that we care about.
 :3g,       That is used as an index into the table on line 4 to get the character to output.
 0`3g,      For component values greater than 0 the second char is a '0', otherwise an 'F'. 
 :9-!       Check if the next component is our end marker.
^           If not, repeat the inner loop.

55+,        Output a newline.
:_          Repeat the outer loop until there are no more colours on the stack. 

C #, 195 bytes

void n(){string a="000000\r\n000080\r\n0000FF\r\n008000\r\n008080\r\m00FF00\r\n00FFFF\r\n800000\r\n800080\r\n808000\r\n808080\r\nC0C0C0\r\nFF0000\r\nFF00FF\r\nFFFF00\r\nFFFFFF";Console.Write(a);}

Infelizmente, isso supera, por uma margem enorme, o mais interessante, embora incrivelmente complicado (eu me diverti muito escrevendo) C #, 270 bytes

void n(){string a,b,c,d;a="00";b="80";c="C0";d="FF";for(int i=0;i<16;i++){Console.WriteLine((i<7?a:i<11?b:i>11?d:c)+(i<3?a:i<5?b:i<7?d:i<9?a:i<11?b:i==11?c:i<14?a:d)+(i==0||i==3||i==5|i==7||i==9||i==12||i==14?a:i==1||i==4||i==8||i==10?b:i==2||i==6||i==13||i==15?d:c));}}

C (gcc) , 99 bytes

f(i){for(i=48;i--;)printf("%.2s%s","FFC08000"+("#&/28MNQRSV]^_ab"[i/3]-35>>i%3*2&3)*2,"\n\0"+i%3);}

Experimente online!

Depois de tentar criar uma lista de números e produzi-los durante a classificação, comparei com a solução ingênua, que era preocupante:

f(){puts("000000\n000080\n0000FF\n008000\n008080\n00FF00\n00FFFF\n800000\n800080\n808000\n808080\nC0C0C0\nFF0000\nFF00FF\nFFFF00\nFFFFFF");}

Aquele tem clock de 140 bytes, comparado à minha tentativa de 200 e alteração.

A solução foi pensar nele como texto como qualquer outro, embora com um pequeno alfabeto. Cada cor pode ser vista como um trio de índices de 2 bits no alfabeto {0xff, 0xc0, 0x80, 00}. O processo de cor -> trigêmeo -> número -> caractere (com deslocamento +35 para torná-los imprimíveis e evitar a necessidade de escapamentos) pode ser ilustrado da seguinte forma:

000000  333     63  b
000080  332     62  a
0000FF  330     60  _
008000  323     59  ^
008080  322     58  ]
00FF00  303     51  V
00FFFF  300     48  S
800000  233     47  R
800080  232     46  Q
808000  223     43  N
808080  222     42  M
C0C0C0  111     21  8
FF0000  033     15  2
FF00FF  030     12  /
FFFF00  003     3   &
FFFFFF  000     0   #

Então é apenas uma questão de iterar sobre a sequência resultante e cortar as partes apropriadas da sequência do alfabeto.