16-цветная палитра CGA (также известная как цвета HTML ) представляет собой набор из 16 цветов, используемых ранними графическими адаптерами. Цель этой задачи - вывести все 16 из них в шестнадцатеричном формате ( RRGGBB) в порядке возрастания по шестнадцатеричному значению, разделенных символами новой строки. Таким образом, вывод должен быть именно таким:

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

Один трейлинг-перевод строки разрешен, но не обязателен.

Желе , 31 29 27 байт

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

Попробуйте онлайн!

Как это работает

“×Ɗ¡‘дают кодовые точки персонажей между кавычки в желе в SBCS , которые 0x11 = 17 , 0x91 = 145 и 0х00 = 0 .

ŒP строит powerset массива кодовых точек, давая

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

Последние две записи соответствуют комбинациям, которые содержат как 80 , так и FF , поэтому мы должны отбросить их.

»Ṫ¦209 состоит из трех частей:

• Ṫ(tail) удаляет последний массив кодовых точек, т. е. [17, 145, 0] .

• »209берет максимум каждого целого числа в оставшейся части powerset и 0xD1 = 209 , заменяя их все на 209 .

• ¦(разреженный) перебирает элементы оставшейся части powerset. Если соответствующий индекс найден в [17, 145, 0] , элемент заменяется на все 209 . Если нет, то он остается нетронутым.

  ¦не является модульным, поэтому он изменяет только последний массив (индекс 0 ) в оставшейся части блока питания. Индексы 17 и 145 слишком велики и не имеют никакого эффекта.

Результат выглядит следующим образом.

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

ṗ€3 вычисляет третью декартову степень каждого массива, то есть массив всех трех наборов элементов каждого массива.

Fd⁴выравнивает результат и вычисляет частное и остаток каждого целого числа, деленное на 16 .

ịØHиндексы (на основе 1) в "0123456789ABCDEF , поэтому 0x11 , 0x91 , 0x00 и 0xD1 отображаются в " 00 " , " 80 " , " FF " и " C0 " (соответственно).

s3ṢQ разбивает пары символов на 3 кортежа, сортирует кортежи и дедуплицирует.

Наконец, Yобъединяются уникальные кортежи, разделенные переводом строк.

Bash + GNU Utilities, 67

• 2 байта сохранены благодаря @manatwork
• 2 байта сохранены благодаря @zeppelin

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

• Расширение скобок {00,80,FF}{00,80,FF}{00,80,FF} дает все необходимые комбинации в правильном порядке (исключая C0C0C0), а также некоторые дополнительные функции. Дополнения содержат как символы, так Fи 8символы.
• Результатом раскрытия фигурной скобки является одна строка, разделенная пробелом. fmtпомещает каждую запись в свою строку
• 1-я строка sedвыражения вставляется C0C0C0в соответствующую строку
• 2-я строка sedвыражения отфильтровывает «дополнения», описанные выше.

Ideone .

Желе , 38 31 байт

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

TryItOnline!

Сжатие в Base 250 числа ( “...’),
преобразованного в base 4 ( b4),
zip ( ż) с копией самого себя после векторизованной логики и с помощью 1 ( a1$) *,
indexed ( ị) в четыре используемых символа ( “08CF”),
разбитых на куски длины 3 ( s3),
и соединены с переводами строки ( Y).

* Таким образом, каждая цифра нуля соединяется с другим нулем, а каждая другая цифра с единицей. Наряду со следующим индексируются выборками это означает , что 'F'становится в паре с другим 'F'временем '0', '8'и 'C'каждой парой с '0'.

Python 3, 134 129 125 108 91 90 байт

Я думаю, что здесь еще много занятий гольфом. Предложения по игре в гольф приветствуются!

Изменить: -9 байт и большое спасибо Мего за помощь в форматировании строки. -17 байт от выяснения лучшего способа сначала напечатать строку. -17 байт от выяснения лучшего способа написать цикл for. -1 байт благодаря подсказке xnor использовать i%3//2*"\n"вместо "\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 байт

Сохранено 2 байта, благодаря Нейлу

Это на 7 9 байт короче, чем просто возврат необработанной строки в обратных галочках.

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

Тест

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 байт

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

Да, я не нашел ничего более короткого, чем просто печать буквальной строки ... Спасибо @ Martin Smith за сокращение 7 байт с помощью простой замены (которую я полностью пропустил). Таким образом, мы по крайней мере на 7 байт короче, чем просто жесткое кодирование. Ура!

Но это скучно!

Так что вместо ...

PowerShell v4, 128 байт

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

Пространство [system.consolecolor]имен определяет цвета консоли (изначально), доступные для консоли PowerShell. Если мы ссылаемся на них через целочисленный массив, как это, значением по умолчанию является имя (например, BlackилиWhite подобное). Мы объединили это со строкой, которая была -splitв пробелах, так что теперь у нас есть массив строк с именами цветов.

Мы перебираем их, |%{...}и каждая итерация извлекает соответствующее [system.windows.media.colors]значение. Стрификация по умолчанию для этих объектов - это цвет в #AARRGGBBформате как шестнадцатеричное значение, поэтому мы используем его, инкапсулируя этот вызов в строку с блоком сценария "$(...)". Но, поскольку нам не нужны альфа-значения или хеш, мы берем конец [3..8]строки, и нам нужно, чтобы -joinэтот char-array вернулся в строку. Затем, просто Sort-Objectположить их в правильном порядке.

Pyth - 64 48 44 байта

Супер простая базовая компрессия.

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

Попробуйте это онлайн здесь .

MATL , 39 байт

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

Попробуйте онлайн!

'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 байтов

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

Попробуйте онлайн!

То, что нам нужно вывести в основном (перевернуто и разделено):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Который в десятичном виде:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Который в Base-214:

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

Это самое простое решение, которое я мог бы придумать, потому что ни в коем случае я не бью Денниса. Потратил час, пытаясь, и ничто не разбило его идею.

PHP, 92 байта

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

Попробуйте онлайн!

просто замена из цифр в качестве ключа в массиве со значениями strtr

Пакет, 137 байт

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

Да, это так скучно. Предыдущая 148-байтовая попытка:

@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

К сожалению, вы не можете передать вывод команды forили a call:, поэтому я должен вызывать себя рекурсивно.

Пайк, 42 байта

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

Попробуй это здесь!

Befunge, 83 69 байт

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

Попробуйте онлайн!

Цвета кодируются в строке, которую вы видите в первой строке, по два бита на компонент цвета, с дополнительным старшим битом, установленным для принудительного ввода каждого значения в диапазон ASCII (за исключением случая 63, который будет вне диапазона как 127 ).

Список цветов в стеке затем обрабатывается следующим образом:

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 байт

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

К сожалению, это бьет, с огромным отрывом, более интересным, хотя и невероятно запутанным (у меня было намного больше удовольствия писать это) C #, 270 байтов

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 байтов

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

Попробуйте онлайн!

После попытки составить список чисел и вывести их при сортировке, я сравнил наивное решение, которое было отрезвляющим:

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

Это составляет 140 байтов по сравнению с моей попыткой на 200 и изменением.

Решение состояло в том, чтобы думать об этом как о тексте, как о любом другом, хотя и с небольшим алфавитом. Каждый цвет можно рассматривать как триплет 2-битных индексов в алфавите {0xff, 0xc0, 0x80, 00}. Процесс цвет -> триплет -> число -> символ (со смещением +35, чтобы сделать их все для печати и избежать необходимости в побегах) можно проиллюстрировать следующим образом:

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   #

Тогда это просто вопрос перебора полученной строки и вырезания соответствующих частей строки алфавита.