Palet CGA 16-warna (juga dikenal sebagai warna HTML ) adalah seperangkat 16 warna yang digunakan oleh adapter grafis awal. Tujuan dari tantangan ini adalah untuk menghasilkan ke 16 semuanya, dalam format hex ( RRGGBB), dalam urutan naik dengan nilai hex, dipisahkan oleh baris baru. Jadi, outputnya harus persis seperti ini:

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

Satu baris baru yang dibolehkan diperbolehkan, tetapi tidak diperlukan.

Jelly , 31 29 27 byte

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

Cobalah online!

Bagaimana itu bekerja

“×Ɗ¡‘menghasilkan poin kode karakter antara tanda kutip di Jelly's SBCS , yaitu 0x11 = 17 , 0x91 = 145 , dan 0x00 = 0 .

ŒP membangun powerset dari array titik kode, menghasilkan

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

Dua entri terakhir sesuai dengan kombinasi yang mengandung 80 dan FF , jadi kami harus membuangnya.

»Ṫ¦209 terdiri dari tiga bagian:

• Ṫ(tail) menghilangkan array terakhir dari titik kode, yaitu, [17, 145, 0] .

• »209mengambil maksimum setiap bilangan bulat di sisa PowerPet dan 0xD1 = 209 , menggantikan semuanya dengan 209 .

• ¦(Jarang) iterates atas elemen-elemen sisa PowerPet. Jika indeks yang sesuai ditemukan di [17, 145, 0] , elemen diganti dengan semua 209 . Jika tidak, itu tidak tersentuh.

  ¦bukan modular, jadi ini hanya memodifikasi array terakhir (indeks 0 ) di sisa PowerPet. Indeks 17 dan 145 terlalu besar dan tidak berpengaruh.

Hasilnya adalah sebagai berikut.

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

ṗ€3 menghitung kekuatan Kartesius ketiga dari setiap larik, yaitu larik semua 3-tupel elemen dari setiap larik.

Fd⁴meratakan hasil dan menghitung hasil bagi dan sisa dari setiap bilangan bulat dibagi dengan 16 .

ịØHindeks (berbasis 1) ke "0123456789ABCDEF , sehingga 0x11 , 0x91 , 0x00 , dan 0xD1 bisa dipetakan ke " 00 " , " 80 " , " FF " , dan " C0 " (resp.).

s3ṢQ membagi pasangan karakter menjadi 3-tupel, mengurutkan tupel, dan menduplikat.

Akhirnya, Ybergabung dengan tupel unik, pisahkan dengan linefeeds.

Bash + GNU Utilities, 67

• 2 byte disimpan berkat @manatwork
• 2 byte disimpan berkat @zeppelin

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

• The ekspansi brace {00,80,FF}{00,80,FF}{00,80,FF} memberikan semua kombinasi kebutuhan dalam urutan yang benar (tidak termasuk C0C0C0), bersama beberapa tambahan. Ekstra adalah yang mengandung karakter Fdan 8karakter.
• Hasil dari ekspansi brace adalah garis yang dipisahkan oleh ruang. fmtmenempatkan setiap entri pada barisnya sendiri
• Baris pertama sedekspresi memasukkan C0C0C0baris yang sesuai
• Baris ke-2 dari sedekspresi memfilter "ekstra" yang dijelaskan di atas.

Ideone .

Jelly , 38 31 byte

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

TryItOnline!

Basis 250 kompresi angka ( “...’),
dikonversi ke basis 4 ( b4),
zip ( ż) dengan salinan dirinya sendiri setelah logis-dan vektor dengan 1 ( a1$) *,
diindeks ( ị) ke dalam empat karakter yang digunakan ( “08CF”),
dibagi menjadi potongan-potongan dengan panjang 3 ( s3),
dan bergabung dengan umpan baris ( Y).

* Dengan demikian memasangkan setiap digit nol dengan nol lainnya dan masing-masing digit lainnya dengan satu digit. Seiring dengan berikut diindeks mengambil cara ini 'F'menjadi dipasangkan dengan yang lain 'F'sementara '0', '8'dan 'C'masing-masing pasangan dengan '0'.

Python 3, 134 129 125 108 91 90 byte

Saya pikir masih banyak golf yang bisa dilakukan di sini. Selamat datang saran bermain golf!

Sunting: -9 byte dan terima kasih banyak kepada Mego untuk membantu memformat string. -17 byte dari mencari tahu cara yang lebih baik untuk mencetak string di tempat pertama. -17 byte dari mencari tahu cara yang lebih baik untuk menulis loop for di tempat pertama. -1 byte berkat tip xnor untuk digunakan i%3//2*"\n"sebagai ganti "\n"*(i%3<2).

for i in range(48):print(end="F0C8F000"[0x10114abf7f75c147d745d55//4**i%4::4]+i%3//2*"\n")

Tidak melakukanolf

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

Disimpan 2 byte, terima kasih kepada Neil

Ini lebih pendek 7 9 byte daripada hanya mengembalikan string mentah dalam backticks.

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

Uji

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'

Ya, saya belum menemukan sesuatu yang lebih pendek dari sekedar mencetak string literal ... Terima kasih kepada @ Martin Smith karena telah mengurangi 7 byte menggunakan pengganti sederhana (yang saya benar-benar diabaikan). Jadi, kami setidaknya 7 byte lebih pendek daripada hanya hardcoding itu. Yay!

Tapi itu membosankan!

Jadi sebagai gantinya ...

PowerShell v4, 128 byte

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

The [system.consolecolor]namespace mendefinisikan konsol warna (native) yang tersedia untuk konsol PowerShell. Jika kita mereferensikannya melalui array integer seperti ini, nilai default adalah namanya (misalnya, Blackatau Whitesejenisnya). Kami mengombinasikannya dengan string yang ada -splitdi spasi, jadi sekarang kami memiliki serangkaian string nama warna.

Kami mengulanginya |%{...}dan setiap iterasi menarik nilai yang sesuai [system.windows.media.colors]. Stringifikasi default untuk objek-objek tersebut adalah warna dalam #AARRGGBBformat sebagai nilai hex, jadi kami memanfaatkannya dengan merangkum panggilan itu dalam string dengan blok skrip "$(...)". Tetapi, karena kita tidak menginginkan nilai alpha atau hash, kita mengambil bagian belakang [3..8]string, dan perlu -joinagar char-array yang dihasilkan kembali menjadi string. Kemudian, sederhana Sort-Objectuntuk menempatkan mereka dalam urutan yang benar.

Pyth - 64 48 44 byte

Kompresi dasar super sederhana.

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

Cobalah online di sini .

MATL , 39 byte

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

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

Cobalah online!

Apa yang perlu kita hasilkan pada dasarnya (terbalik dan dibagi):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Yang, dalam desimal adalah:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Yang ada di Base-214 adalah:

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

Ini adalah solusi paling sederhana yang bisa saya buat, karena tidak mungkin saya mengalahkan Dennis. Menghabiskan satu jam mencoba dan tidak ada yang mengalahkan idenya.

PHP, 92 Bytes

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

Cobalah online!

cukup penggantian dari digit sebagai kunci dalam array dengan strtr nilai

Batch, 137 byte

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

Ya, itu membosankan. Upaya 148 byte sebelumnya:

@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

Sayangnya Anda tidak dapat mem-pipe output dari perintah foratau call:, jadi saya harus memohon diri saya secara rekursif.

Pyke, 42 byte

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

Coba di sini!

Befunge, 83 69 byte

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

Cobalah online!

Warna dikodekan dalam string yang Anda lihat pada baris pertama, dua bit per komponen warna, dengan bit tinggi tambahan yang ditetapkan untuk memaksa setiap nilai ke dalam rentang ASCII (kecuali dalam kasus 63, yang akan berada di luar kisaran 127) ).

Daftar warna pada tumpukan kemudian diproses sebagai berikut:

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

Sayangnya ini berdetak, dengan margin yang besar, semakin menarik walaupun sangat berbelit-belit (saya punya banyak lagi kesenangan menulisnya) 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);}

Cobalah online!

Setelah melakukan upaya yang melibatkan pembuatan daftar angka dan mengeluarkannya sambil menyortir, saya membandingkan dengan solusi naif, yang serius:

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

Itu satu jam di 140 byte dibandingkan dengan coba saya di 200 dan berubah.

Solusinya adalah menganggapnya sebagai teks seperti yang lainnya, meskipun dengan alfabet kecil. Setiap warna dapat dianggap sebagai triplet dari indeks 2-bit ke dalam alfabet {0xff, 0xc0, 0x80, 00}. Proses warna -> triplet -> angka -> karakter (dengan offset +35 untuk membuat semuanya dapat dicetak dan menghindari kebutuhan untuk melarikan diri) dapat diilustrasikan sebagai berikut:

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   #

Maka itu hanya masalah iterasi pada string yang dihasilkan dan memotong bagian-bagian yang sesuai dari string alfabet.