16-kolorowa paleta CGA (znana również jako kolory HTML ) to zestaw 16 kolorów używanych przez wczesne karty graficzne. Celem tego wyzwania jest wyprowadzenie wszystkich 16 z nich, w formacie szesnastkowym ( RRGGBB), w porządku rosnącym według wartości szesnastkowej, oddzielonych znakami nowej linii. Dlatego wynik powinien być dokładnie taki:

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

Pojedyncza nowa linia jest dozwolona, ​​ale nie wymagana.

Galaretka , 31 29 27 bajtów

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

Wypróbuj online!

Jak to działa

“×Ɗ¡‘dają punkty kodowe znaków między cudzysłowami w SBCS Jelly , które wynoszą 0x11 = 17 , 0x91 = 145 i 0x00 = 0 .

ŒP konstruuje zestaw potęgowy tablicy punktów kodowych, dając

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

Ostatnie dwa wpisy odpowiadają kombinacjom zawierającym zarówno 80, jak i FF , więc musimy je odrzucić.

»Ṫ¦209 składa się z trzech części:

• Ṫ(ogon) usuwa ostatnią tablicę punktów kodowych, tj. [17, 145, 0] .

• »209przyjmuje maksimum każdej liczby całkowitej w pozostałej części zestawu mocy i 0xD1 = 209 , zastępując je wszystkie wartością 209 .

• ¦(rzadkie) iteruje elementy pozostałej części zestawu mocy. Jeśli odpowiedni indeks znajduje się w [17, 145, 0] , element jest zastępowany wszystkimi 209 . Jeśli nie, pozostaje nietknięty.

  ¦nie jest modułowy, więc modyfikuje tylko ostatnią tablicę (indeks 0 ) w pozostałej części zestawu mocy. Wskaźniki 17 i 145 są zbyt duże i nie mają wpływu.

Wynik jest następujący.

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

ṗ€3 oblicza trzecią potęgę kartezjańską każdej tablicy, tj. tablicę wszystkich 3 krotek elementów każdej tablicy.

Fd⁴spłaszcza wynik i oblicza iloraz i resztę każdej liczby całkowitej podzielonej przez 16 .

ịØHindeksy (oparte na 1) na „0123456789ABCDEF , więc 0x11 , 0x91 , 0x00 i 0xD1 są mapowane na „ 00 ” , „ 80 ” , „ FF ” i „ C0 ” (odpowiednio).

s3ṢQ dzieli pary znaków na 3-krotki, sortuje krotki i deduplikuje.

Wreszcie Ydołącza do unikalnych krotek, oddzielając je liniami.

Bash + GNU Utilities, 67

• 2 bajty zapisane dzięki @manatwork
• 2 bajty zapisane dzięki @zeppelin

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

• Rozszerzenie nawiasu klamrowego {00,80,FF}{00,80,FF}{00,80,FF} zapewnia wszystkie kombinacje potrzeb w odpowiedniej kolejności (z wyłączeniem C0C0C0) wraz z dodatkami. Dodatki zawierają te Fi 8znaki.
• Wynikiem rozszerzenia nawiasu jest pojedyncza linia oddzielona spacją. fmtumieszcza każdy wpis we własnej linii
• Pierwszy wiersz sedwyrażenia wstawia C0C0C0do odpowiedniego wiersza
• Druga linia sedwyrażenia odfiltrowuje „dodatki” opisane powyżej.

Ideone .

Galaretka , 38 31 bajtów

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

TryItOnline!

Kompresja bazy 250 liczby ( “...’),
przekonwertowana na bazę 4 ( b4),
skompresowana ( ż) z kopią siebie po wektoryzacji logicznej i za pomocą 1 ( a1$) *,
indeksowana ( ị) na cztery użyte znaki ( “08CF”),
podzielona na części o długości 3 ( s3)
i połączone z liniowym przesunięciem ( Y).

* W ten sposób parowanie każdej cyfry zerowej z innym zerem i każdą inną cyfrą z jednym. Wraz z następujących indeksowanej pobierania tych środków 'F'zostaje połączony z innym 'F'czasie '0', '8'i 'C'każdy parę z '0'.

Python 3, 134 129 125 108 91 90 bajtów

Myślę, że jest jeszcze wiele do gry w golfa. Zapraszamy do gry w golfa!

Edycja: -9 bajtów i wiele podziękowań dla Mego za pomoc w formatowaniu łańcucha. -17 bajtów od znalezienia lepszego sposobu na wydrukowanie łańcucha. -17 bajtów od znalezienia lepszego sposobu na napisanie pętli for. -1 bajt dzięki końcówce xnor do użycia i%3//2*"\n"zamiast "\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 bajtów

Zaoszczędzono 2 bajty dzięki Neilowi

Jest to 7 9 bajtów krótszych niż zwykłe zwracanie nieprzetworzonego ciągu w odwrotnych wierszach.

_=>[...'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 bajtów

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

Tak, nie znalazłem nic krótszego niż tylko wydrukowanie dosłownego ciągu ... Dzięki @ Martin Smith za golenie 7 bajtów za pomocą prostego zamiennika (który całkowicie przeoczyłem). Mamy więc co najmniej 7 bajtów krótszych niż zwykłe kodowanie. Tak!

Ale to jest nudne!

Więc zamiast ...

PowerShell v4, 128 bajtów

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

Przestrzeń [system.consolecolor]nazw określa kolory konsoli (natywnie) dostępne dla konsoli PowerShell. Jeśli będziemy odwoływać się do nich poprzez tablicę liczb całkowitych jak ta, domyślnie jest to nazwa (np Blacklub Whitelub podobne). Łączymy to z ciągiem znaków -splitspacji, więc teraz mamy tablicę ciągów nazw kolorów.

Pętlimy je |%{...}i każda iteracja wyciąga odpowiednią [system.windows.media.colors]wartość. Domyślnym ciągiem znaków dla tych obiektów jest kolor w #AARRGGBBformacie jako wartość szesnastkowa, więc wykorzystujemy to, zamykając to wywołanie w ciągu za pomocą bloku skryptu "$(...)". Ponieważ jednak nie chcemy wartości alfa ani skrótu, bierzemy tylny koniec [3..8]łańcucha i potrzebujemy, aby -joinwynikowa chartablica wróciła do łańcucha. Następnie wystarczy Sort-Objectustawić je we właściwej kolejności.

Pyth - 64 48 44 bajtów

Super prosta kompresja bazy.

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

Wypróbuj online tutaj .

MATL , 39 bajtów

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

To, co musimy wygenerować, to w zasadzie (odwrócone i podzielone):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Co w liczbach dziesiętnych to:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Który w Base-214 to:

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

Jest to najprostsze rozwiązanie, jakie mogłem wymyślić, ponieważ nie ma mowy, aby w piekle pokonałem Dennisa. Spędziłem godzinę próbując i nic nie przeszło jego pomysłu.

PHP, 92 bajty

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

Wypróbuj online!

wystarczy zastąpić cyfry jako klucz w tablicy wartościami strtr

Partia, 137 bajtów

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

Tak, to takie nudne. Poprzednia 148-bajtowa próba:

@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

Niestety nie możesz przesyłać danych wyjściowych polecenia forlub call:polecenia, więc muszę wywoływać się rekurencyjnie.

Pyke, 42 bajty

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

Wypróbuj tutaj!

Befunge, 83 69 bajtów

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

Wypróbuj online!

Kolory są zakodowane w ciągu, który widzisz w pierwszym wierszu, dwa bity na komponent koloru, z dodatkowym ustawieniem wysokiego bitu, aby wymusić każdą wartość w zakresie ASCII (z wyjątkiem przypadku 63, który byłby poza zakresem jako 127 ).

Lista kolorów na stosie jest następnie przetwarzana w następujący sposób:

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 bajtów

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

Niestety, to znacznie przewyższa, tym bardziej interesujący, choć niesamowicie zawiły (napisanie go było o wiele fajniejsze) C #, 270 bajtów

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 bajtów

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

Wypróbuj online!

Po próbie utworzenia listy liczb i wysłania ich podczas sortowania porównałem do naiwnego rozwiązania, które otrzeźwiło:

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

Ten zapisuje się na 140 bajtów w porównaniu do mojej próby na 200 i zmieniam.

Rozwiązaniem było potraktowanie go jak tekstu, jakkolwiek z małym alfabetem. Każdy kolor można traktować jako triplet 2-bitowych indeksów w alfabecie {0xff, 0xc0, 0x80, 00}. Proces kolorowania -> tryplet -> liczba -> znak (z przesunięciem +35, aby wszystkie można było wydrukować i uniknąć potrzeby ucieczki) można zilustrować jako:

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   #

Następnie wystarczy powtórzyć powstały ciąg i wyciąć odpowiednie części ciągu alfabetu.