La paleta CGA de 16 colores (también conocida como colores HTML ) es un conjunto de 16 colores utilizados por los primeros adaptadores gráficos. El objetivo de este desafío es generar los 16, en formato hexadecimal ( RRGGBB), en orden ascendente por valor hexadecimal, separados por nuevas líneas. Por lo tanto, la salida debería ser exactamente esto:

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

Se permite una nueva línea final, pero no se requiere.

Jalea , 31 29 27 bytes

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

Pruébalo en línea!

Cómo funciona

“×Ɗ¡‘produce los puntos de código de los caracteres entre las comillas en el SBCS de Jelly , que son 0x11 = 17 , 0x91 = 145 y 0x00 = 0 .

ŒP construye el conjunto de potencia de la matriz de puntos de código, produciendo

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

Las dos últimas entradas corresponden a combinaciones que contienen 80 y FF , por lo que debemos descartarlas.

»Ṫ¦209 consta de tres partes:

• Ṫ(cola) elimina la última matriz de puntos de código, es decir, [17, 145, 0] .

• »209toma el máximo de cada número entero en el resto del conjunto de potencia y 0xD1 = 209 , reemplazándolos por 209 .

• ¦(disperso) itera sobre los elementos del resto del conjunto de potencia. Si el índice correspondiente se encuentra en [17, 145, 0] , el elemento se reemplaza con todos los 209 . Si no, se deja intacto.

  ¦no es modular, por lo que esto modifica solo la última matriz (índice 0 ) en el resto del conjunto de alimentación. Los índices 17 y 145 son demasiado grandes y no tienen efecto.

El resultado es el siguiente.

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

ṗ€3 calcula el tercer poder cartesiano de cada matriz, es decir, la matriz de todas las 3 tuplas de elementos de cada matriz.

Fd⁴ aplana el resultado y calcula el cociente y el resto de cada entero dividido por 16 .

ịØHíndices (basados ​​en 1) en "0123456789ABCDEF , por lo que 0x11 , 0x91 , 0x00 y 0xD1 se asignan a " 00 " , " 80 " , " FF " y " C0 " (resp.).

s3ṢQ divide los pares de caracteres en 3 tuplas, clasifica las tuplas y deduplica.

Finalmente, se Yune a las tuplas únicas, separándose por avances de línea.

Bash + GNU Utilities, 67

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

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

• La expansión de llaves {00,80,FF}{00,80,FF}{00,80,FF} proporciona todas las combinaciones de necesidades en el orden correcto (excluyendo C0C0C0), junto con algunos extras. Los extras son los que contienen ambos Fy 8personajes.
• El resultado de la expansión de la llave es una sola línea separada por espacios. fmtpone cada entrada en su propia línea
• La primera línea de la sedexpresión se inserta C0C0C0en la línea apropiada.
• La segunda línea de la sedexpresión filtra los "extras" descritos anteriormente.

Ideone .

Gelatina , 38 31 bytes

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

TryItOnline!

Compresión base 250 de un número ( “...’),
convertido a base 4 ( b4),
comprimido ( ż) con una copia de sí mismo después de un vectorizado lógico y con 1 ( a1$) *,
indexado ( ị) en los cuatro caracteres utilizados ( “08CF”),
dividido en trozos de longitud 3 ( s3),
y unidos con saltos de línea ( Y).

* Emparejando así cada dígito cero con otro cero y cada uno de los otros dígitos con uno. Junto con la siguiente indexadas podido recuperar este medio 'F'se convierte emparejado con otro 'F', mientras que '0', '8'y 'C'cada par con una '0'.

Python 3, 134 129 125 108 91 90 bytes

Creo que todavía hay mucho golf por hacer aquí. Sugerencias de golf bienvenidas!

Editar: -9 bytes y muchas gracias a Mego por ayudar con el formato de la cadena. -17 bytes de encontrar una mejor manera de imprimir la cadena en primer lugar. -17 bytes de encontrar una mejor manera de escribir el bucle for en primer lugar. -1 byte gracias a la sugerencia de xnor para usar en i%3//2*"\n"lugar 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), 109107 bytes

Guardado 2 bytes, gracias a Neil

Esto es 7 9 bytes más corto que simplemente devolver la cadena sin formato en las comillas inversas.

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

Prueba

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, 113106 bytes

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

Sí, no he encontrado nada más corto que simplemente imprimir la cadena literal ... Gracias a @ Martin Smith por reducir 7 bytes usando un reemplazo simple (que pasé por alto por completo). Entonces, somos al menos 7 bytes más cortos que simplemente codificarlo. ¡Hurra!

¡Pero eso es aburrido!

Así que en vez ...

PowerShell v4, 128 bytes

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

El [system.consolecolor]espacio de nombres define los colores de la consola (de forma nativa) disponibles para la consola de PowerShell. Si los hacemos referencia a través de una matriz entera como esta, el valor predeterminado es el nombre (por ejemplo, Blacko Whitesimilar). Combinamos eso con una cadena que ha estado -spliten espacios, por lo que ahora tenemos una serie de cadenas de nombres de colores.

Recorremos esos |%{...}y cada iteración extrae el [system.windows.media.colors]valor correspondiente . La cadena de caracteres predeterminada para esos objetos es el color en #AARRGGBBformato como un valor hexadecimal, por lo que aprovechamos eso encapsulando esa llamada en una cadena con un bloque de secuencia de comandos "$(...)". Pero, dado que no queremos los valores alfa o el hash, tomamos el extremo posterior [3..8]de la cadena y necesitamos -joinesa charmatriz resultante de nuevo en una cadena. Entonces, un simple Sort-Objectponerlos en el orden correcto.

Pyth - 64 48 44 bytes

Compresión de base super simple.

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

Pruébelo en línea aquí .

MATL , 39 bytes

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

Pruébalo en línea!

'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ô»

Pruébalo en línea!

Lo que necesitamos generar es básicamente (invertido y dividido):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Que, en decimal es:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Que en Base-214 es:

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

Esta es la solución más simple que se me ocurrió, porque no hay forma de que esté golpeando a Dennis. Pasó una hora intentándolo y nada mejoró su idea.

PHP, 92 bytes

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

Pruébalo en línea!

simplemente reemplazo de los dígitos como clave en la matriz con los 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

Sí, es así de aburrido. Intento 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

Lamentablemente, no puede canalizar la salida de forun call:comando o un comando, por lo que tengo que invocarme recursivamente.

Pyke, 42 bytes

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

Pruébalo aquí!

Befunge, 83 69 bytes

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

Pruébalo en línea!

Los colores están codificados en la cadena que ve en la primera línea, dos bits por componente de color, con un bit alto adicional establecido para forzar cada valor en el rango ASCII (excepto en el caso de 63, que estaría fuera del rango como 127 )

La lista de colores en la pila se procesa de la siguiente manera:

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

Lamentablemente, esto supera, por un amplio margen, lo más interesante, aunque increíblemente complicado (me divertí mucho más escribiéndolo) 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);}

Pruébalo en línea!

Después de haber intentado crear una lista de números y generarlos mientras los ordenaba, los comparé con la solución ingenua, que era aleccionadora:

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

Ese se registra en 140 bytes en comparación con mi intento en 200 y cambia.

La solución fue pensarlo como un texto como cualquier otro, aunque con un alfabeto pequeño. Cada color podría considerarse como un triplete de índices de 2 bits en el alfabeto {0xff, 0xc0, 0x80, 00}. El proceso de color -> triplete -> número -> carácter (con desplazamiento +35 para hacerlos todos imprimibles y evitar la necesidad de fugas) puede ilustrarse como tal:

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   #

Entonces es solo una cuestión de iterar sobre la cadena resultante y cortar las partes apropiadas de la cadena del alfabeto.