Bảng màu CGA 16 màu (còn được gọi là màu HTML ) là một bộ gồm 16 màu được sử dụng bởi các bộ điều hợp đồ họa ban đầu. Mục tiêu của thử thách này là xuất ra tất cả 16 trong số chúng, ở định dạng hex ( RRGGBB), theo thứ tự tăng dần theo giá trị hex, được phân tách bằng các dòng mới. Vì vậy, đầu ra phải chính xác như sau:

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

Một dòng mới duy nhất được cho phép, nhưng không bắt buộc.

Thạch , 31 29 27 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

“×Ɗ¡‘mang lại các điểm mã của các ký tự giữa các dấu ngoặc kép trong SBCS của Jelly , là 0x11 = 17 , 0x91 = 145 và 0x00 = 0 .

ŒP xây dựng quyền hạn của mảng các điểm mã, mang lại

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

Hai mục cuối cùng tương ứng với các kết hợp chứa cả 80 và FF , vì vậy chúng tôi phải loại bỏ chúng.

»Ṫ¦209 bao gồm ba phần:

• Ṫ(đuôi) loại bỏ mảng mã điểm cuối cùng, nghĩa là [17, 145, 0] .

• »209lấy tối đa của mỗi số nguyên trong phần còn lại của powerset và 0xD1 = 209 , thay thế tất cả chúng bằng 209 .

• ¦(thưa thớt) lặp đi lặp lại các yếu tố của phần còn lại của powerset. Nếu chỉ mục tương ứng được tìm thấy trong [17, 145, 0] , phần tử được thay thế bằng tất cả 209 . Nếu không, nó bị bỏ hoang.

  ¦không phải là mô-đun, do đó, điều này chỉ sửa đổi mảng cuối cùng (chỉ số 0 ) trong phần còn lại của tập quyền. Các chỉ số 17 và 145 quá lớn và không có hiệu lực.

Kết quả là như sau.

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

ṗ€3 tính toán sức mạnh Cartesian thứ ba của mỗi mảng, nghĩa là mảng của tất cả 3 phần tử của các phần tử của mỗi mảng.

Fd⁴làm phẳng kết quả và tính thương và phần còn lại của mỗi số nguyên chia cho 16 .

ịØHlập chỉ mục (dựa trên 1) thành "0123456789ABCDEF , vì vậy 0x11 , 0x91 , 0x00 và 0xD1 được ánh xạ tới " 00 " , " 80 " , " FF " và " C0 " (tương ứng).

s3ṢQ chia các cặp ký tự thành 3 bộ, sắp xếp các bộ dữ liệu và lặp lại.

Cuối cùng, Ytham gia các bộ dữ liệu độc đáo, phân tách bằng các đường dẫn.

Tiện ích Bash + GNU, 67

• 2 byte được lưu nhờ @manatwork
• Lưu 2 byte nhờ @zeppelin

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

• Việc mở rộng niềng răng {00,80,FF}{00,80,FF}{00,80,FF} cung cấp cho tất cả các kết hợp cần thiết theo đúng thứ tự (không bao gồm C0C0C0), cùng với một số tính năng bổ sung. Các tính năng bổ sung là những cái có chứa cả hai Fvà 8ký tự.
• Kết quả của việc mở rộng nẹp là một dòng tách biệt không gian. fmtđặt mỗi mục trên dòng riêng của nó
• Dòng thứ nhất của sedbiểu thức chèn C0C0C0vào dòng thích hợp
• Dòng thứ 2 của sedbiểu thức lọc ra các "phần bổ sung" được mô tả ở trên.

Ideone .

Thạch , 38 31 byte

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

Dùng thử trực tuyến!

Nén 250 cơ sở một số ( “...’), được
chuyển đổi thành cơ sở 4 ( b4), được
nén ( ż) bằng một bản sao của chính nó sau một logic được vectơ hóa - và với 1 ( a1$) *,
được lập chỉ mục ( ị) thành bốn ký tự được sử dụng ( “08CF”),
chia thành các khối có độ dài 3 ( s3)
và được nối với nguồn cấp dữ liệu ( Y).

* Do đó, ghép từng chữ số 0 với một số 0 khác và mỗi chữ số khác với một chữ số. Cùng với những điều sau đây được lập chỉ mục lấy phương tiện này 'F'trở nên kết hợp với nhau 'F'trong khi '0', '8'và 'C'mỗi cặp có một '0'.

Python 3, 134 129 125 108 91 90 byte

Tôi nghĩ rằng vẫn còn rất nhiều golf để làm ở đây. Gợi ý chơi golf chào mừng!

Chỉnh sửa: -9 byte và cảm ơn Mego vì đã giúp định dạng chuỗi. -17 byte từ việc tìm ra một cách tốt hơn để in chuỗi ở vị trí đầu tiên. -17 byte từ việc tìm ra một cách tốt hơn để viết vòng lặp for ở vị trí đầu tiên. -1 byte nhờ vào mẹo của xnor để sử dụng i%3//2*"\n"thay vì "\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

Đã lưu 2 byte, nhờ Neil

Đây là 7 9 byte ngắn hơn so với việc chỉ trả về chuỗi thô trong backticks.

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

Kiểm tra

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'

Vâng, tôi đã không tìm thấy bất cứ điều gì ngắn hơn là chỉ in chuỗi ký tự ... Cảm ơn @ Martin Smith đã cạo xuống 7 byte bằng cách thay thế đơn giản (mà tôi hoàn toàn bỏ qua). Vì vậy, chúng tôi ngắn hơn ít nhất 7 byte so với chỉ đơn giản là mã hóa nó. Yay!

Nhưng điều đó thật nhàm chán!

Vì vậy, thay vào đó ...

PowerShell v4, 128 byte

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

Không [system.consolecolor]gian tên xác định màu của bảng điều khiển (nguyên bản) có sẵn cho bảng điều khiển PowerShell. Nếu chúng ta tham chiếu chúng thông qua một mảng số nguyên như thế này, giá trị mặc định là tên (ví dụ: Blackhoặc Whitetương tự). Chúng tôi kết hợp điều đó với một chuỗi đã có -splittrên các khoảng trắng, vì vậy bây giờ chúng tôi có một chuỗi các chuỗi tên màu.

Chúng tôi lặp qua những cái đó |%{...}và mỗi lần lặp lại kéo ra [system.windows.media.colors]giá trị tương ứng . Chuỗi hóa mặc định cho các đối tượng đó là màu có #AARRGGBBđịnh dạng dưới dạng giá trị hex, vì vậy chúng tôi tận dụng điều đó bằng cách gói gọn cuộc gọi đó trong một chuỗi bằng một khối tập lệnh "$(...)". Nhưng, vì chúng tôi không muốn các giá trị alpha hoặc hàm băm, chúng tôi lấy phần cuối [3..8]của chuỗi và cần -joinkết quả đó char-array trở lại thành một chuỗi. Sau đó, một cách đơn giản Sort-Objectđể đặt chúng theo đúng thứ tự.

Pyth - 64 48 44 byte

Nén cơ sở siêu đơn giản.

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

Hãy thử trực tuyến tại đây .

MATL , 39 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Những gì chúng ta cần đầu ra về cơ bản (đảo ngược và phân chia):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Trong đó, trong số thập phân là:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Mà trong Base-214 là:

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

Đây là giải pháp đơn giản nhất tôi có thể đưa ra, bởi vì không có cách nào tôi đánh bại Dennis. Đã dành một giờ cố gắng và không có gì đánh bại ý tưởng của mình.

PHP, 92 byte

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

Hãy thử trực tuyến!

chỉ cần thay thế từ các chữ số là khóa trong mảng bằng các giá trị strtr

Mẻ, 137 byte

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

Vâng, nó thật nhàm chán. Nỗ lực 148 byte trước đó:

@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

Thật không may, bạn không thể dẫn đầu ra của một forhoặc một call:lệnh, vì vậy tôi phải tự gọi mình một cách đệ quy.

Pyke, 42 byte

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

Hãy thử nó ở đây!

Befunge, 83 69 byte

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

Hãy thử trực tuyến!

Các màu được mã hóa trong chuỗi bạn nhìn thấy trên dòng đầu tiên, hai bit cho mỗi thành phần màu, với một bit cao bổ sung được đặt để buộc từng giá trị vào phạm vi ASCII (trừ trường hợp 63, nằm ngoài phạm vi là 127 ).

Danh sách các màu trên ngăn xếp sau đó được xử lý như sau:

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

Đáng buồn thay, nhịp này, với một biên độ lớn, càng thú vị hơn mặc dù cực kỳ phức tạp (tôi đã có rất nhiều niềm vui khi viết nó) 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);}

Hãy thử trực tuyến!

Sau khi thực hiện một nỗ lực liên quan đến việc tạo ra một danh sách các số và xuất chúng trong khi sắp xếp, tôi so sánh với giải pháp ngây thơ, rất tỉnh táo:

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

Đó là một đồng hồ ở mức 140 byte so với thử của tôi ở mức 200 và thay đổi.

Giải pháp là nghĩ về nó như văn bản như mọi thứ khác, mặc dù với một bảng chữ cái nhỏ. Mỗi màu có thể được coi là một bộ ba chỉ số 2 bit vào bảng chữ cái {0xff, 0xc0, 0x80, 00}. Quá trình tô màu -> bộ ba -> số -> ký tự (với offset +35 để làm cho tất cả có thể in được và tránh mọi nhu cầu thoát) có thể được minh họa như sau:

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   #

Sau đó, chỉ là vấn đề lặp lại chuỗi kết quả và cắt bỏ các phần thích hợp của chuỗi bảng chữ cái.