Die 16-Farben-CGA-Palette (auch als HTML-Farben bezeichnet ) besteht aus 16 Farben, die von früheren Grafikadaptern verwendet werden. Ziel dieser Herausforderung ist es, alle 16 im Hex-Format ( RRGGBB) in aufsteigender Reihenfolge nach Hex-Wert und durch Zeilenumbrüche getrennt auszugeben. Die Ausgabe sollte also genau so aussehen:

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

Ein einzelner abschließender Zeilenumbruch ist zulässig, aber nicht erforderlich.

Jelly , 31 29 27 Bytes

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

Probieren Sie es online!

Wie es funktioniert

“×Ɗ¡‘Geben Sie die Codepunkte der Zeichen zwischen den Anführungszeichen in Jellys SBCS an : 0x11 = 17 , 0x91 = 145 und 0x00 = 0 .

ŒP Konstruiert die Potenzmenge des Arrays von Codepunkten und ergibt

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

Die letzten beiden Einträge entsprechen Kombinationen, die sowohl 80 als auch FF enthalten. Wir müssen sie also verwerfen.

»Ṫ¦209 besteht aus drei Teilen:

• Ṫ(tail) entfernt das letzte Array von Codepunkten, dh [17, 145, 0] .

• »209Nimmt das Maximum jeder Ganzzahl im Rest des Potenzsatzes und 0xD1 = 209 , wobei alle durch 209 ersetzt werden .

• ¦(spärlich) iteriert über die Elemente des restlichen Powersets. Wird der entsprechende Index in [17, 145, 0] gefunden , wird das Element durch alle 209 ersetzt . Wenn nicht, bleibt es unberührt.

  ¦ist nicht modular, daher wird nur das letzte Array (Index 0 ) im restlichen Powerset geändert. Die Indizes 17 und 145 sind zu groß und haben keine Wirkung.

Das Ergebnis ist wie folgt.

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

ṗ€3 berechnet die dritte kartesische Potenz jedes Arrays, dh das Array aller 3-Tupel von Elementen jedes Arrays.

Fd⁴verflacht das Ergebnis und berechnet Quotienten und Rest jeder ganzen Zahl geteilt durch 16 .

ịØHIndizes (Basis 1) in „0123456789ABCDEF , so 0x11 , 0x91 , 0x00 und 0xD1 erhalten abgebildet "00" , "80" , "FF" und "C0" (resp.).

s3ṢQ Teilt die Zeichenpaare in 3-Tupel auf, sortiert die Tupel und dedupliziert sie.

Schließlich werden Ydie eindeutigen Tupel durch Zeilenvorschübe getrennt.

Bash + GNU Utilities, 67

• 2 Bytes gespart dank @manatwork
• 2 Bytes gespart dank @zeppelin

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

• Die Strebenerweiterung {00,80,FF}{00,80,FF}{00,80,FF} bietet C0C0C0neben einigen Extras alle erforderlichen Kombinationen in der richtigen Reihenfolge (außer ). Die Extras enthalten sowohl Fals auch 8Zeichen.
• Das Ergebnis der Klammererweiterung ist eine einzelne durch Leerzeichen getrennte Linie. fmtsetzt jeden Eintrag in eine eigene Zeile
• Die erste Zeile des sedAusdrucks wird C0C0C0in die entsprechende Zeile eingefügt
• In der 2. Zeile des sedAusdrucks werden die oben beschriebenen "Extras" herausgefiltert.

Ideone .

Jelly , 38 31 Bytes

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

TryItOnline!

Basis 250 Komprimierung einer Zahl ( “...’),
konvertiert zu Basis 4 ( b4),
gezippt ( ż) mit einer Kopie von sich selbst nach einer vektorisierten Logik und mit 1 ( a1$) *,
indiziert ( ị) in die vier verwendeten Zeichen ( “08CF”),
aufgeteilt in Blöcke der Länge 3 ( s3)
und mit Zeilenumbrüchen ( Y) verbunden.

* So wird jede Nullziffer mit einer anderen Null und jede andere Ziffer mit einer Eins verbunden. Zusammen mit dem folgenden indexierten Dies bedeutet fetch 'F'wird mit einem anderen gepaart , 'F'während '0', '8'und 'C'jedes Paar mit ein '0'.

Python 3, 134 129 125 108 91 90 Bytes

Ich denke, hier gibt es noch viel zu golfen. Golfvorschläge willkommen!

Edit: -9 Bytes und vielen Dank an Mego für die Hilfe bei der String-Formatierung. -17 Bytes, weil Sie herausgefunden haben, wie Sie die Zeichenfolge besser drucken können. -17 Bytes, weil Sie herausgefunden haben, wie Sie die for-Schleife besser schreiben können. -1 byte dank xnors tipp zu benutzen i%3//2*"\n"statt "\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

2 Bytes gespart, dank Neil

Dies ist 7 bis 9 Byte kürzer als nur die Rückgabe des Rohstrings in Backticks.

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

Prüfung

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 Bytes

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

Ja, ich habe nichts kürzeres gefunden, als nur den Literal-String zu drucken ... Vielen Dank an @ Martin Smith , der 7 Bytes mit einem einfachen Ersatz (den ich völlig übersehen habe) eingespart hat. Wir sind also mindestens 7 Bytes kürzer als nur das Hardcodieren. Yay!

Aber das ist langweilig!

Also stattdessen ...

PowerShell v4, 128 Byte

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

Der [system.consolecolor]Namespace definiert die Konsolenfarben, die (nativ) für die PowerShell-Konsole verfügbar sind . Wenn wir sie über ein ganzzahliges Array wie dieses referenzieren, ist der Standardwert der Name (z. B. Blackoder Whiteoder dergleichen). Wir kombinieren das mit einer Zeichenfolge, die sich -splitauf Leerzeichen befand, und haben jetzt eine Reihe von Zeichenfolgen mit Farbnamen.

Wir durchlaufen diese |%{...}und ziehen bei jeder Iteration den entsprechenden [system.windows.media.colors]Wert heraus. Die Standardstringifizierung für diese Objekte ist die Farbe im #AARRGGBBFormat als Hexadezimalwert. Wir nutzen diese Option , indem wir diesen Aufruf in einen String mit einem Skriptblock einkapseln "$(...)". Da wir aber weder die Alpha-Werte noch den Hash wollen, nehmen wir das hintere Ende [3..8]der Zeichenkette und müssen -joindas resultierende char-array wieder in eine Zeichenkette umwandeln. Dann einfach Sort-Objectin die richtige Reihenfolge bringen.

Pyth - 64 48 44 Bytes

Super einfache Basiskomprimierung.

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

Probieren Sie es hier online aus .

MATL , 39 Bytes

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

Probieren Sie es 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 Bytes

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

Probieren Sie es online!

Was wir ausgeben müssen, ist im Grunde (umgekehrt und aufgeteilt):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

Was in Dezimalzahl ist:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

Was in Base-214 ist:

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

Dies ist die einfachste Lösung, die ich mir vorstellen kann, weil ich Dennis auf keinen Fall besiege. Ich habe eine Stunde lang versucht und nichts hat seine Idee übertroffen.

PHP, 92 Bytes

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

Probieren Sie es online!

Ersetzen Sie einfach die Ziffern als Schlüssel im Array durch die Werte strtr

Batch, 137 Bytes

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

Ja, es ist so langweilig. Vorheriger 148-Byte-Versuch:

@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

Leider können Sie die Ausgabe eines foroder eines call:Befehls nicht weiterleiten , daher muss ich mich rekursiv aufrufen.

Pyke, 42 Bytes

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

Probieren Sie es hier aus!

Befunge, 83 69 Bytes

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

Probieren Sie es online!

Die Farben werden in der Zeichenfolge codiert, die Sie in der ersten Zeile sehen, zwei Bits pro Farbkomponente, wobei ein zusätzliches hohes Bit festgelegt wird, um jeden Wert in den ASCII-Bereich zu zwingen (außer im Fall von 63, der außerhalb des Bereichs von 127 liegt) ).

Die Liste der Farben auf dem Stapel wird dann wie folgt verarbeitet:

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 bytes

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

Sadly this beats, by a huge margin, the more interesting albeit incredibly convoluted (I had tons more fun writing it) C#, 270 bytes

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 bytes

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

Try it online!

After having made an attempt involving creating a list of numbers and outputting them while sorting, I compared to the naïve solution, which was sobering:

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

That one clocks in at 140 bytes compared to my try at 200 and change.

The solution was to think of it as text like any other, albeit with a small alphabet. Each colour could be thought of as a triplet of 2-bit indices into the alphabet {0xff, 0xc0, 0x80, 00}. The process of colour -> triplet -> number -> character (with offset +35 to make them all printable and avoid any need for escapes) can be illustrated as such:

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   #

Then it's just a matter of iterating over the resulting string and cutting out the appropriate parts of the alphabet string.