维基百科上的真彩色（24位）在相关部分中描述为

24位几乎总是使用R，G，B中的每个8位。截至2018年，几乎每台计算机和电话显示器以及绝大多数图像存储格式都使用24位色深。几乎所有情况下每个像素有32位意味着使用24种颜色，其余8种是alpha通道或未使用。

2 ²⁴给出16,777,216种颜色变化。人眼最多可以辨别一千万种颜色^[10]，并且由于显示器的色域小于人眼的范围，因此这意味着该范围应覆盖比所能感知的更多的细节。...

...

Macintosh系统将24位颜色称为“数百万种颜色”。术语“真彩色”有时用来表示本文所说的“直接彩色”。^[13]通常也用于指所有大于或等于24的颜色深度。

全部16,777,216色

任务

编写一个程序，该程序在CSS rgb()函数中生成并返回数组中所有16,777,216个颜色变化作为字符串

5.1。RGB功能：rgb()和rgba()

该rgb()函数通过直接指定红色，绿色和蓝色通道来定义RGB颜色。其语法为：

rgb() = rgb( <percentage>{3} [ / <alpha-value> ]? ) |
        rgb( <number>{3} [ / <alpha-value> ]? )
<alpha-value> = <number> | <percentage>

前三个参数分别指定颜色的红色，绿色和蓝色通道。0%代表sRGB色域中该颜色通道的最小值，并100%代表最大值。A <number>等效于a <percentage>，但范围不同：0再次代表颜色通道的最小值，但255代表最大值。这些值来自以下事实：许多图形引擎在内部将颜色通道存储为单个字节，该字节可以容纳0到255之间的整数。实现应尽可能尊重创作或计算得出的通道精度。如果无法做到这一点，则应使用所使用的最高精度将通道四舍五入到最接近的值，如果两个值相等接近，则将四舍五入。

最后一个参数，<alpha-value>指定颜色的Alpha。如果指定为a <number>，则该值的有用范围是0 （表示完全透明的颜色）至1（表示完全不透明的颜色）。如果指定为，则0%表示完全透明的颜色，而100%表示完全不透明的颜色。如果省略，则默认为100%。

超出这些范围的值不是无效的，但是在计算值时将被限制为此处定义的范围。

出于遗留原因，rgb()它还支持另一种语法，该语法用逗号分隔所有参数：

rgb() = rgb( <percentage>#{3} , <alpha-value>? ) |
        rgb( <number>#{3} , <alpha-value>? )

同样由于遗留原因，rgba()也存在一个函数，其语法和行为与相同rgb()。

或RGB十六进制表示法#RRGGBB格式

5.2。RGB十六进制表示法：#RRGGBB

CSS 十六进制颜色表示法通过将通道指定为十六进制数字来指定颜色，这类似于通常直接在计算机代码中写入颜色的方式。它比用rgb()符号写相同的颜色还短。

a的语法<hex-color>是<hash-token>令牌，其值包含3、4、6或8个十六进制数字。换句话说，十六进制颜色写为井号字符“＃”，后跟一些数字0-9或字母af（字母的大小无关紧要- #00ff00与相同#00FF00）。

给定的十六进制数字的数量决定了如何将十六进制表示法解码为RGB颜色：

6位数

第一对数字（解释为十六进制数字）指定颜色的红色通道，其中00代表最小值，ff（十进制255）代表最大值。以相同方式解释的下一对数字指定绿色通道，最后一对数字指定蓝色。颜色的Alpha通道是完全不透明的。

实施例2
换句话说，#00ff00表示与rgb(0 255 0)（柠檬绿）相同的颜色。

请参阅CSS Color Module Level 4的编辑草稿

例子

CSS rgb()函数（可用空格代替逗号，例如rgb(0 255 0)）

// `rgb()` `<percentage>` as strings in resulting array
['rgb(0%,0%,0%)', ...,'rgb(0%,255%,0)', ...'rgb(255,255,255)']

// `rgb()` `<number>` as strings in resulting array
['rgb(0,0,0)', ...,'rgb(0,255,0)', ...'rgb(255,255,255)']

CSS RGB十六进制表示法 RRGGBB

// RGB hexadecimal notation as strings in resulting array
['#000000', ...,'#00ff00', ...'#ffffff']

获奖标准

用于编写程序的最小字节。

R，25个字节

sprintf("#%06X",1:2^24-1)

在线尝试！

Python 2中，77 40 39 37个字节

print['#%06X'%c for c in range(8**8)]

在线尝试！

_{-1字节归功于Digital Trauma}

_{-2字节感谢dylnan}

PowerShell的，28 26字节

1..16mb|%{"#{0:x6}"-f--$_}

在线尝试！

从循环1到16mb（16777216）。每次迭代时，我们都使用-format运算符，该运算符对--$_针对string 递减的当前数字起作用"#{0:x6}"。在这里，我们指定他的x值，将其填充到6数字，并#在前面加一个哈希。在TIO上，限制为60秒/ 128KiB的输出。更改1到(16mb-5)，看它是如何结束。

JavaScript（ES7），65 62 61字节

@tsh 节省了3个 4字节

返回#RRGGBB字符串数组。

_=>[...Array(n=8**8)].map(_=>'#'+(n++).toString(16).slice(1))

在线尝试！ （截断的输出）

Common Lisp，42个字节

(dotimes(i 16777216)(format t"#~6,'0x "i))

在线尝试！

Japt，14个字节

输出为#rrggbb。

G²³ÇsG ùT6 i'#

尝试一下（仅限前4096个元素）

说明

G                  :16
 ²                 :Squared
  ³                :Cubed
   Ç               :Map the range [0,result)
    sG             :  Convert to base-16 string
       ù           :  Left pad
        T          :   With 0
         6         :   To length 6
           i'#     :  Prepend "#"

Haskell，41个字节

l="ABCDEF"
mapM id$"#":(['0'..'9']++l<$l)

在线尝试！

05AB1E，15 14 10 字节

15Ýh6ãJ'#ì

在线尝试。

说明：

15Ý           # Create a list in the range [0, 15]
   h          # Convert each to a hexadecimal value
    6ã        # Create each possible sextuple combination of the list
      J       # Join them together to a single string
       '#ì    # And prepend a "#" before each of them

批次，87个字节

@set s= in (0,1,255)do @
@for /l %%r%s%for /l %%g%s%for /l %%b%s%echo rgb(%%r,%%g,%%b)

以CSS格式输出。变量替换发生在for分析语句之前，因此实际代码如下：

@for /l %%r in (0,1,255)do @for /l %%g in (0,1,255)do @for /l %%b in (0,1,255)do @echo rgb(%%r,%%g,%%b)

C＃（Visual C＃交互式编译器），47字节

Enumerable.Range(0,1<<24).Select(q=>$"#{q:X6}")

在线尝试！

C＃（.NET Core），75字节

()=>{int i=1<<24;var a=new string[i];for(;i-->0;)a[i]=$"#{i:X6}";return a;}

在线尝试！

具有C＃内插字符串格式的JAVA 10版本的端口

K（oK），19个字节

解：

$(3#256)\'!16777216

在线尝试！（仅限前500个数字）

说明：

转储RGB字符串。将0到16777216之间的每个数字转换为基数256，然后转换为字符串...

$(3#256)\'!16777216 / the solution
          !16777216 / range 0..16777215
 (     )\'          / split each both
  3#256             / 256 256 256
$                   / string

MATL，17 15字节

10W:q'#%06X,'YD

在线尝试！

TIO版本仅显示前2 ^ 10，以免超时。我在页脚中添加了最后的迭代，以表明它确实终止于 #FFFFFF。通过更改为fprintf而不是手动组装字符串来节省一个字节。输出以逗号分隔的列表。

说明

24W:q            % Range from 0 to 2^24-1
     '#%06X,'    % fprintf format spec (# followed by hexadecimal, zero-padded, fixed-width, followed by newline)
             YD  % Call fprintf. Internally loops over range.

APL（Dyalog Unicode），47 43 20字节

'#',(⎕D,⎕A)[↑,⍳6⍴16]

在线尝试！

$2^{24}-1$6⍴4⍴

感谢@Dzaima和@ngn提供了23个字节。

用途⎕IO←0。

怎么样：

'#',(⎕D,⎕A)[↑,⍳6⍴16] ⍝ Main function
               ⍳6⍴16  ⍝ Generate every possible 6 digit hex number in a matrix format
              ,       ⍝ Ravel the matrix (from a 16x16x16x16x16x16 matrix to a 16^6x2 list)
             ↑        ⍝ Mix; (turns the list into a 16^6x2 matrix)
    (⎕D,⎕A)[       ] ⍝ Use that matrix to index the vector of the digits 0-9 concatenated with the alphabet.
'#',                  ⍝ Then prepend a '#' to each.

红宝石，31个字节

$><<("#%06x\n"*d=2**24)%[*0..d]

在线尝试！

V，25个字节

8É00lrx16777215ñÄ<C-a>ñ0<C-v>Gls#

在线尝试！（替换16777215为31）

说明

8É0                                " insert 8 zeroes
   0l                              " move cursor to the second character
     rx                            " replace by x
       16777215ñ      ñ            " 16777215 times do ..
                Ä                  " .. duplicate line
                 <C-a>             " .. increment (leading 0x makes sure it uses hexadecimals)
                       0<C-v>      " move cursor to beginning of line and start selection
                             Gl    " select the column with 0x
                               s#  " replace by #

批次69 + 4 = 73

g.cmd，69

for /L %%A in (0,1,16777215)do cmd/kexit %%A&set #%%A=#!=exitcode:~2!

将带有格式的十六进制值保存#RRGGBB到“数组”中。

g.cmd被称为使用cmd /V/Q/K g.cmd。这就是+ 4的来源，/V/Q与just相比，它算作4个额外的字符cmd /K g.cmd。这将建立一个在内存中具有“阵列”的环境。它也永远需要运行，因此请使用非常低的值尝试使用Ctrl+C

分解

开票

• /V启用延迟扩展，但比短setlocal EnableDelayedExpansion，这就是为什么我们首先需要cmd致电的原因
• /Q 省略输出，等效于 @echo off
• /K使您可以执行表达式（在这种情况下为g.cmd），并且此后不会退出，因此您可以使用来检查“数组”set #

厘米

for /L %%A IN (0,1,16777215) DO (
    cmd /k exit %%A
    set #%%A=#!=exitcode:~2!
)

该位使用此处记录的技巧将普通数字转换为十六进制，然后将该值保存到“数组”中。

我一直称该存储结构为“数组”，但实际上并不正确，因为在批处理中不存在真正的数组。但是您可以命名变量，以便它们具有类似数组的名称，如下所示：

set elem[1]=First element
set elem[2]=Second one

或者，例如在这种情况下：

set #1=First element
set #2=Second one

您仍然可以通过访问它们 !#%position%!

Groovy，53个字节

c={a=[];(1<<24).times{a.add "".format("#%06x",it)};a}

功能定义。c（）返回一个ArrayList（我认为这很好，即使通过这个问题也需要数组）。

取消高尔夫，具有隐式类型：

ArrayList<String> c = {
    ArrayList<String> a = []
    (1 << 24).times { 
        a.add("".format("#%06x", it)) // add the hex-formatted number to the list.
    }
    return a
}

在线尝试！

Java 10，87 84字节

v->{int i=1<<24;var r=new String[i];for(;i-->0;)r[i]="".format("#%06X",i);return r;}

-3个字节，感谢@ archangel.mjj。

在线试用（仅限于前4,096几项）。

说明：

v->{                       // Method with empty unused parameter & String-array return-type
  int i=1<<24;             //  Integer `i`, starting at 16,777,216
  var r=new String[i];     //  Result String-array of that size
  for(;i-->0;)             //  Loop `i` in the range (16777216, 0]
    r[i]=                  //   Set the `i`'th item in the array to:
      "".format("#%06X",i);//   `i` converted to a hexadecimal value (of size 6)
  return r;}               //  Return the result-array

PHP，68 62字节

应该将其放置在文件内，最后返回数组，以使其可用。

<?foreach(range(0,1<<24)as$i)$a[]=sprintf('#%06x',$i);return$a;

要访问该数组，只需将include（例如：）的结果提供给$a = include 'xyz.php';变量。

感谢@manatwork为我节省了6个字节并修复了问题。

MATL，11个字节

'#'5Y26Z^Yc

在线尝试！（只有三个十六进制数字，而不是六个）

说明

'#'   % Push this character
5Y2   % Push '01234567890ABCDEF'
6     % Push 6
Z^    % Cartesian power. Gives a (16^6)×6 char matrix
Yc    % String concatenation. '#' is implicitly replicated
      % Implicitly display

Bash + Jot，22岁

jot -w\#%06X $[8**8] 0

在线尝试！

Perl 5，31个字节

printf"#%06X
",$_ for 0..8**8-1

在线尝试！

的Lua，47个 45字节

for i=1,8^8 do s='#%06X'print(s:format(i))end

在线尝试！

T-SQL，122个 117字节

返回一个16,777,216行的#RRGGBB字符串表。换行符仅供参考：

WITH t AS(SELECT 0n UNION ALL SELECT n+1FROM t WHERE n<16777215)
SELECT'#'+FORMAT(n,'X6')FROM t option(maxrecursion 0)

对从0到2 ^ 24-1的数字表使用递归CTE，然后使用内置FORMAT命令（在SQL 2012或更高版本中可用）将其转换为6位十六进制字符串。将附加#到前面，我们就完成了。

编辑1：删除POWER()功能，数字短一些：P

果冻，12字节

⁴ṖṃØHœċ6ṭ€”#

在线尝试！

果冻，8字节

ØHṗ6”#;Ɱ

在线尝试！（注：用途2，而不是6作为6超时的TIO）

函数提交（因为Jelly完整程序默认情况下将打印字符串列表，而字符串之间没有定界符，因此很难看到边界）。TIO链接包含一个包装器，该包装器使用换行符分隔字符串以打印字符串列表。

说明

ØHṗ6”#;Ɱ
ØH         All hex digits (“0123456789ABCDEF”)
  ṗ6       Find all strings of 6 of them (order relevant, repeats allowed)
    ”#;    Prepend “#”
       Ɱ     to each of the resulting strings

PHP，43字节

<?php for(;$i<1<<24;printf("#%06X ",$i++));

在线尝试！

Scala，40个字节

(1 to 1<<24).map(x=>println(f"#$x%06x"))

在线尝试！

Perl 6、26个字节

{map *.fmt("#%06X"),^8**8}

在线尝试！

使用与其他所有人相同的格式。在TIO上超时。

或者，以rgb格式：

31个字节

{map {"rgb($_)"},[X] ^256 xx 3}

在线尝试！