La palette CGA 16 couleurs (également connue sous le nom de couleurs HTML ) est un ensemble de 16 couleurs utilisées par les premiers adaptateurs graphiques. Le but de ce défi est de sortir tous les 16 d'entre eux, au format hexadécimal ( RRGGBB), dans l'ordre croissant par la valeur hexadécimale, séparés par des nouvelles lignes. Ainsi, la sortie doit être exactement la suivante:

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

Une seule nouvelle ligne de fin est autorisée, mais pas obligatoire.

Gelée , 31 29 27 octets

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

Essayez-le en ligne!

Comment ça marche

“×Ɗ¡‘produisent les points de code des caractères entre les guillemets dans le SBCS de Jelly , qui sont 0x11 = 17 , 0x91 = 145 et 0x00 = 0 .

ŒP construit l'ensemble de puissance du tableau de points de code, ce qui donne

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

Les deux dernières entrées correspondent à des combinaisons contenant à la fois 80 et FF , nous devons donc les éliminer.

»Ṫ¦209 se compose de trois parties:

• Ṫ(tail) supprime le dernier tableau de points de code, c'est-à-dire [17, 145, 0] .

• »209prend le maximum de chaque entier dans le reste du jeu de puissance et 0xD1 = 209 , en les remplaçant tous par 209 .

• ¦(clairsemé) parcourt les éléments du reste du jeu de pouvoirs. Si l'index correspondant se trouve dans [17, 145, 0] , l'élément est remplacé par tous les 209 . Sinon, il reste intact.

  ¦n'est pas modulaire, donc cela ne modifie que le dernier tableau (index 0 ) dans le reste du jeu de puissance. Les indices 17 et 145 sont trop grands et n'ont aucun effet.

Le résultat est le suivant.

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

ṗ€3 calcule la troisième puissance cartésienne de chaque tableau, c'est-à-dire le tableau de tous les 3-tuples d'éléments de chaque tableau.

Fd⁴aplatit le résultat et calcule le quotient et le reste de chaque entier divisé par 16 .

ịØHindex (basés sur 1) dans "0123456789ABCDEF , donc 0x11 , 0x91 , 0x00 et 0xD1 sont mappés sur " 00 " , " 80 " , " FF " et " C0 " (resp.).

s3ṢQ divise les paires de caractères en 3 tuples, trie les tuples et dédoublonne.

Enfin, Yjoint les tuples uniques, séparés par des sauts de ligne.

Utilitaires Bash + GNU, 67

• 2 octets économisés grâce à @manatwork
• 2 octets économisés grâce à @zeppelin

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

• L' expansion du croisillon {00,80,FF}{00,80,FF}{00,80,FF} donne toutes les combinaisons de besoins dans le bon ordre (à l'exclusion C0C0C0), le long de certains extras. Les extras sont ceux qui contiennent les deux caractères Fet 8.
• Le résultat de l'expansion de l'accolade est une seule ligne séparée par des espaces. fmtmet chaque entrée sur sa propre ligne
• La 1ère ligne de l' sedexpression s'insère C0C0C0dans la ligne appropriée
• La 2ème ligne de l' sedexpression filtre les "extras" décrits ci-dessus.

Ideone .

Gelée , 38 31 octets

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

TryItOnline!

Compression en base 250 d'un nombre ( “...’),
converti en base 4 ( b4),
zippé ( ż) avec une copie de lui-même après une logique vectorisée et avec 1 ( a1$) *,
indexé ( ị) dans les quatre caractères utilisés ( “08CF”),
divisé en morceaux de longueur 3 ( s3),
et rejoint par des sauts de ligne ( Y).

* Associer ainsi chaque chiffre zéro à un autre zéro et chacun des autres chiffres à un. En plus de ce qui suit la récupération de ce moyen indexé 'F'devient lié à un autre 'F'alors que '0', '8'et 'C'chaque paire avec un '0'.

Python 3, 134 129 125 108 91 90 octets

Je pense qu'il y a encore beaucoup de golf à faire ici. Suggestions de golf bienvenues!

Edit: -9 octets et merci beaucoup à Mego pour son aide dans le formatage des chaînes. -17 octets de trouver une meilleure façon d'imprimer la chaîne en premier lieu. -17 octets pour trouver une meilleure façon d'écrire la boucle for en premier lieu. -1 octet grâce à l'astuce de xnor à utiliser à la i%3//2*"\n"place 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 octets

Enregistré 2 octets, grâce à Neil

Cela représente 7 à 9 octets de moins que le simple retour de la chaîne brute en guillemets.

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

Tester

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 octets

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

Ouais, je n'ai rien trouvé de plus court que d'imprimer la chaîne littérale ... Merci à @ Martin Smith d' avoir réduit 7 octets en utilisant un simple remplacement (que j'ai complètement ignoré). Donc, nous sommes au moins 7 octets plus courts que le simple codage en dur. Yay!

Mais c'est ennuyeux!

Donc au lieu ...

PowerShell v4, 128 octets

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

L' [system.consolecolor]espace de noms définit (nativement) les couleurs de console disponibles pour la console PowerShell. Si nous les référençons via un tableau entier comme celui-ci, la valeur par défaut est le nom (par exemple, Blackou Whitesimilaire). Nous combinons cela avec une chaîne qui a été -splitplacée sur des espaces, nous avons donc maintenant un tableau de chaînes de noms de couleurs.

Nous les parcourons |%{...}et chaque itération extrait la [system.windows.media.colors]valeur correspondante . La chaîne de caractères par défaut pour ces objets est la couleur au #AARRGGBBformat sous forme de valeur hexadécimale, nous utilisons donc cela en encapsulant cet appel dans une chaîne avec un bloc de script "$(...)". Mais, puisque nous ne voulons pas les valeurs alpha ou le hachage, nous prenons l'extrémité arrière [3..8]de la chaîne et avons besoin de -joince chartableau résultant en une chaîne. Ensuite, un simple Sort-Objectpour les mettre dans le bon ordre.

Pyth - 64 48 44 octets

Compression de base super simple.

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

Essayez-le en ligne ici .

MATL , 39 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Ce que nous devons produire est fondamentalement (inversé et divisé):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Ce qui, en décimal, est:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Ce qui dans Base-214 est:

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

C'est la solution la plus simple que j'ai pu trouver, car il n'y a aucun moyen de battre Dennis. J'ai passé une heure à essayer et rien n'a battu son idée.

PHP, 92 octets

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

Essayez-le en ligne!

simplement remplacer à partir des chiffres comme clé dans le tableau avec les valeurs strtr

Lot, 137 octets

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

Oui, c'est ennuyeux. Tentative précédente de 148 octets:

@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

Malheureusement, vous ne pouvez pas diriger la sortie d'un forou d'une call:commande, je dois donc m'invoquer récursivement.

Pyke, 42 octets

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

Essayez-le ici!

Befunge, 83 69 octets

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

Essayez-le en ligne!

Les couleurs sont codées dans la chaîne que vous voyez sur la première ligne, deux bits par composante de couleur, avec un bit élevé supplémentaire défini pour forcer chaque valeur dans la plage ASCII (sauf dans le cas de 63, qui serait hors de portée comme 127 ).

La liste des couleurs de la pile est ensuite traitée comme suit:

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 octets

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

Malheureusement, cela bat, par une énorme marge, le plus intéressant bien qu'incroyablement alambiqué (j'ai eu beaucoup plus de plaisir à l'écrire) C #, 270 octets

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 octets

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

Essayez-le en ligne!

Après avoir tenté de créer une liste de nombres et de les sortir lors du tri, j'ai comparé à la solution naïve, qui faisait réfléchir:

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

Celui-ci horloge à 140 octets par rapport à mon essai à 200 et changement.

La solution était de le considérer comme un texte comme les autres, bien qu'avec un petit alphabet. Chaque couleur peut être considérée comme un triplet d'indices 2 bits dans l'alphabet {0xff, 0xc0, 0x80, 00}. Le processus de couleur -> triplet -> nombre -> caractère (avec un décalage +35 pour les rendre tous imprimables et éviter tout besoin d'évasion) peut être illustré comme tel:

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   #

Il suffit ensuite d'itérer sur la chaîne résultante et de découper les parties appropriées de la chaîne alphabétique.