La tavolozza CGA a 16 colori (nota anche come i colori HTML ) è un set di 16 colori utilizzati dai primi adattatori grafici. L'obiettivo di questa sfida è di produrre tutti e 16, in formato esadecimale ( RRGGBB), in ordine crescente per valore esadecimale, separati da nuove righe. Pertanto, l'output dovrebbe essere esattamente questo:

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

È consentita una singola riga finale finale, ma non richiesta.

Gelatina , 31 29 27 byte

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

Provalo online!

Come funziona

“×Ɗ¡‘restituisce i punti di codice dei caratteri tra le virgolette in SBCS di Jelly , che sono 0x11 = 17 , 0x91 = 145 e 0x00 = 0 .

ŒP costruisce il powerset della matrice di punti di codice, cedendo

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

Le ultime due voci corrispondono a combinazioni che contengono sia 80 che FF , quindi dobbiamo scartarle.

»Ṫ¦209 si compone di tre parti:

• Ṫ(coda) rimuove l'ultimo array di punti di codice, ovvero [17, 145, 0] .

• »209prende il massimo di ogni numero intero nel resto del powerset e 0xD1 = 209 , sostituendoli tutti con 209 .

• ¦(rado) scorre sopra gli elementi del resto del powerset. Se l'indice corrispondente si trova in [17, 145, 0] , l'elemento viene sostituito con tutti i 209 . Altrimenti, non viene toccato.

  ¦non è modulare, quindi modifica solo l'ultimo array (indice 0 ) nel resto del powerset. Gli indici 17 e 145 sono troppo grandi e non hanno alcun effetto.

Il risultato è il seguente.

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

ṗ€3 calcola la terza potenza cartesiana di ciascun array, ovvero l'array di tutte le 3 tuple di elementi di ciascun array.

Fd⁴appiattisce il risultato e calcola il quoziente e il resto di ciascun numero intero diviso per 16 .

ịØHgli indici (basati su 1) in "0123456789ABCDEF , quindi 0x11 , 0x91 , 0x00 e 0xD1 vengono mappati su " 00 " , " 80 " , " FF " e " C0 " (resp.).

s3ṢQ divide le coppie di caratteri in 3 tuple, ordina le tuple e deduplica.

Infine, Yunisce le tuple uniche, separate da avanzamenti di riga.

Utilità Bash + GNU, 67

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

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

• L' espansione del controvento {00,80,FF}{00,80,FF}{00,80,FF} fornisce tutte le combinazioni di necessità nell'ordine giusto (escluso C0C0C0), insieme ad alcuni extra. Gli extra sono quelli che contengono sia caratteri Fche 8caratteri.
• Il risultato dell'espansione del controvento è una singola linea separata dallo spazio. fmtmette ogni voce sulla propria riga
• La prima riga seddell'espressione si inserisce C0C0C0nella riga appropriata
• La seconda riga seddell'espressione filtra gli "extra" sopra descritti.

Ideone .

Gelatina , 38 31 byte

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

TryItOnline!

Base 250 compressione di un numero ( “...’),
convertito in base 4 ( b4),
zippato ( ż) con una copia di se stesso dopo un logico vettoriale e con 1 ( a1$) *,
indicizzato ( ị) nei quattro caratteri utilizzati ( “08CF”),
suddiviso in blocchi di lunghezza 3 ( s3)
e unito a feed di riga ( Y).

* In questo modo accoppiando ciascuna cifra zero con un altro zero e ciascuna delle altre cifre con una. Insieme con la seguente indicizzati prendere questo mezzo 'F'diventa accoppiato con un altro 'F'mentre '0', '8'e 'C'ogni coppia con un '0'.

Python 3, 134 129 125 108 91 91 byte

Penso che ci sia ancora molto da giocare a golf qui. Suggerimenti di golf benvenuti!

Modifica: -9 byte e molte grazie a Mego per l'aiuto nella formattazione delle stringhe. -17 byte dal capire un modo migliore per stampare la stringa in primo luogo. -17 byte dal capire un modo migliore per scrivere il ciclo for in primo luogo. -1 byte grazie al suggerimento di xnor da usare al i%3//2*"\n"posto di "\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 byte

Salvato 2 byte, grazie a Neil

Si tratta di 7 9 byte in meno rispetto alla semplice restituzione della stringa non elaborata nei backtick.

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

Test

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 byte

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

Sì, non ho trovato niente di più breve della semplice stampa della stringa letterale ... Grazie a @ Martin Smith per aver rasato 7 byte usando una semplice sostituzione (che ho completamente ignorato). Quindi, abbiamo almeno 7 byte in meno rispetto alla semplice codifica. Sìì!

Ma è noioso!

Quindi invece ...

PowerShell v4, 128 byte

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

Lo [system.consolecolor]spazio dei nomi definisce i colori della console (nativamente) disponibili per la console di PowerShell. Se li facciamo riferimento tramite una matrice di numeri interi come questa, il valore predefinito è il nome (ad esempio, Blacko Whitesimili). Lo combiniamo con una stringa che è stata -splitnegli spazi, quindi ora abbiamo una serie di stringhe di nomi di colori.

Esaminiamo quelli |%{...}e ogni iterazione estrae il [system.windows.media.colors]valore corrispondente . La stringa di default per quegli oggetti è il colore nel #AARRGGBBformato come valore esadecimale, quindi lo sfruttiamo incapsulando quella chiamata in una stringa con un blocco di script "$(...)". Ma dal momento che non vogliamo i valori alfa o l'hash, prendiamo il back-end [3..8]della stringa e abbiamo bisogno -joinche il risultante char-array ritorni in una stringa. Quindi, un semplice Sort-Objectper metterli nel giusto ordine.

Pyth - 64 48 44 byte

Compressione base super semplice.

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

Provalo online qui .

MATL , 39 byte

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

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

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

Provalo online!

Ciò di cui abbiamo bisogno per produrre è sostanzialmente (invertito e diviso):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Che, in decimale è:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Che in Base-214 è:

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

Questa è la soluzione più semplice che potrei trovare, perché non c'è modo all'inferno di battere Dennis. Ho passato un'ora a provare e niente ha battuto la sua idea.

PHP, 92 byte

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

Provalo online!

semplicemente sostituzione dalle cifre come chiave nell'array con i valori strtr

Lotto, 137 byte

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

Sì, è così noioso. Tentativo precedente a 148 byte:

@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

Sfortunatamente non puoi reindirizzare l'output di un foro un call:comando, quindi devo invocare me stesso in modo ricorsivo.

Pyke, 42 byte

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

Provalo qui!

Befunge, 83 69 byte

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

Provalo online!

I colori sono codificati nella stringa che vedi nella prima riga, due bit per componente di colore, con un bit alto aggiuntivo impostato per forzare ciascun valore nell'intervallo ASCII (tranne nel caso di 63, che sarebbe fuori intervallo come 127 ).

L'elenco dei colori nello stack viene quindi elaborato come segue:

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 byte

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

Purtroppo questo batte, con un margine enorme, il più interessante sebbene incredibilmente contorto (mi sono divertito moltissimo a scriverlo) C #, 270 byte

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 byte

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

Provalo online!

Dopo aver tentato di creare un elenco di numeri e di emetterli durante l'ordinamento, ho confrontato con la soluzione ingenua, che faceva riflettere:

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

Quello arriva a 140 byte rispetto al mio tentativo di 200 e cambiare.

La soluzione era di pensarlo come un testo come tutti gli altri, anche se con un piccolo alfabeto. Ogni colore potrebbe essere pensato come una tripletta di indici a 2 bit nell'alfabeto {0xff, 0xc0, 0x80, 00}. Il processo di colore -> tripletta -> numero -> carattere (con offset +35 per renderli tutti stampabili ed evitare qualsiasi necessità di fuga) può essere illustrato come tale:

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   #

Quindi si tratta solo di scorrere la stringa risultante e ritagliare le parti appropriate della stringa alfabetica.