A cor verdadeira (24 bits) na Wikipedia é descrita em parte pertinente como

24 bits quase sempre usa 8 bits de R, G, B. A partir de 2018, a profundidade de cores de 24 bits é usada por praticamente todos os monitores de computadores e telefones e pela grande maioria dos formatos de armazenamento de imagens. Quase todos os casos em que existem 32 bits por pixel significam que 24 são usados ​​para a cor e os 8 restantes são o canal alfa ou não utilizados.

2 ²⁴ fornece 16.777.216 variações de cores. O olho humano pode discriminar até dez milhões de cores ^[10] e, como a gama de uma tela é menor que o alcance da visão humana, isso significa que isso deve cobrir esse alcance com mais detalhes do que se pode perceber. ...

...

Os sistemas Macintosh referem-se às cores de 24 bits como "milhões de cores". O termo "cor verdadeira" é usado em algum momento para significar o que este artigo chama de "cor direta". ^[13] Também é frequentemente usado para se referir a todas as profundidades de cor iguais ou superiores a 24.

Todas as 16.777.216 cores

Tarefa

Escreva um programa que gere e retorne todas as 16.777.216 variações de cores em uma matriz como seqüências de caracteres na rgb()função CSS

5.1 As funções RGB: rgb()ergba()

A rgb()função define uma cor RGB especificando diretamente os canais vermelho, verde e azul. Sua sintaxe é:

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

Os três primeiros argumentos especificam os canais vermelho, verde e azul da cor, respectivamente. 0%representa o valor mínimo para esse canal de cores na gama sRGB e 100%representa o valor máximo. A <number>é equivalente a <percentage>, mas com um intervalo diferente: 0novamente representa o valor mínimo para o canal de cores, mas255representa o máximo. Esses valores vêm do fato de que muitos mecanismos gráficos armazenam os canais de cores internamente como um byte único, que pode conter números inteiros entre 0 e 255. As implementações devem respeitar a precisão do canal como criada ou calculada sempre que possível. Se isso não for possível, o canal deve ser arredondado para o valor mais próximo com a maior precisão usada, arredondando para cima se dois valores estiverem igualmente próximos.

O argumento final, the <alpha-value>, especifica o alfa da cor. Se fornecido como a <number>, o intervalo útil do valor é 0 (representando uma cor totalmente transparente) a 1(representando uma cor totalmente opaca). Se dado como a, 0%representa uma cor totalmente transparente, enquanto 100%representa uma cor totalmente opaca. Se omitido, o padrão é 100%.

Os valores fora desses intervalos não são inválidos, mas são fixados nos intervalos definidos aqui no momento do valor calculado.

Por motivos legados, rgb()também suporta uma sintaxe alternativa que separa todos os seus argumentos com vírgulas:

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

Também por motivos legados, rgba()também existe uma função, com uma gramática e um comportamento idênticos rgb().

ou #RRGGBBformato de notação hexadecimal RGB

5.2 As notações hexadecimais RGB:#RRGGBB

A notação de cor hexadecimal CSS permite que uma cor seja especificada, fornecendo os canais como números hexadecimais, que é semelhante à maneira como as cores geralmente são escritas diretamente no código do computador. Também é mais curto do que escrever a mesma cor na rgb()notação.

A sintaxe de a <hex-color>é um <hash-token>token cujo valor consiste em 3, 4, 6 ou 8 dígitos hexadecimais. Em outras palavras, uma cor hexadecimal é escrita como um caractere de hash, "#", seguido por um número de dígitos de 0 a 9 ou letras af (o caso das letras não importa - #00ff00é idêntico a #00FF00).

O número de dígitos hexadecimais fornecidos determina como decodificar a notação hexadecimal em uma cor RGB:

6 dígitos

O primeiro par de dígitos, interpretado como um número hexadecimal, especifica o canal vermelho da cor, onde 00representa o valor mínimo e ff(255 em decimal) representa o máximo. O próximo par de dígitos, interpretado da mesma maneira, especifica o canal verde e o último par especifica o azul. O canal alfa da cor é totalmente opaco.

EXEMPLO 2
Por outras palavras, #00ff00representa a mesma cor que rgb(0 255 0)(um verde limão).

Consulte o rascunho do editor do módulo de cores CSS, nível 4

Exemplos

rgb()Função CSS (o caractere de espaço pode ser substituído por vírgula, por exemplo, 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)']

Notação hexadecimal CSS RGB RRGGBB

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

Critérios de vitória

Menos bytes usados ​​para escrever o programa.

R , 25 bytes

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

Experimente online!

Python 2 , 77 40 39 37 bytes

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

Experimente online!

_{-1 byte graças ao Digital Trauma}

_{-2 bytes graças a dylnan}

PowerShell , 28 26 bytes

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

Experimente online!

Loops de 1até 16mb(16777216). A cada iteração, usamos o -foperador ormat que atua no número atual pré-decrementado em --$_relação à string "#{0:x6}". Aqui, estamos especificando os xvalores dele, preenchidos com 6dígitos, com um hash #na frente. No TIO, limitado a 60 segundos / 128KiB de saída. Mude 1para (16mb-5)para ver como termina .

JavaScript (ES7), 65 62 61 bytes

Guardado 3 4 bytes graças a @tsh

Retorna uma matriz de #RRGGBBstrings.

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

Experimente online! (saída truncada)

Lisp comum, 42 bytes

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

Experimente online!

Japonês, 14 bytes

Saídas como #rrggbb.

G²³ÇsG ùT6 i'#

Experimente (limitado aos primeiros 4096 elementos)

Explicação

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 bytes

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

Experimente online!

05AB1E , 15 14 10 bytes

15Ýh6ãJ'#ì

Experimente online.

Explicação:

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

Lote, 87 bytes

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

Saídas no formato CSS. A substituição da variável ocorre antes da foranálise ser analisada, portanto o código real é o seguinte:

@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 # (compilador interativo do Visual C #) , 47 bytes

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

Experimente online!

C # (.NET Core) , 75 bytes

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

Experimente online!

Porta da versão JAVA 10 com formato de cadeia interpolada em C #

K (oK) , 19 bytes

Solução:

$(3#256)\'!16777216

Experimente online! (limitado aos primeiros 500 números)

Explicação:

Despejar cordas rgb. Converta cada número entre 0 e 16777216 na base 256 e depois em seqüências de caracteres ...

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

MATL , 17 15 bytes

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

Experimente online!

A versão TIO exibe os primeiros 2 ^ 10 apenas para não atingir o tempo limite. Incluí a iteração final no rodapé para mostrar que ela realmente termina às #FFFFFF. Economizou um byte alterando para em fprintfvez de montar manualmente a sequência. Produz uma lista separada por vírgula.

Explicação

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 bytes

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

Experimente online!

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

Obrigado a @Dzaima e @ngn pelos 23 bytes.

Usos ⎕IO←0.

Quão:

'#',(⎕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.

Ruby , 31 bytes

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

Experimente online!

V , 25 bytes

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

Experimente online! (substituído 16777215por 31)

Explicação

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 #

Lote, 69 + 4 = 73

g.cmd, 69

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

Salva o valor hexadecimal com o formulário #RRGGBBem uma 'Matriz'.

g.cmddeve ser chamado usando cmd /V/Q/K g.cmd. É daí que o + 4 vem /V/Q, contando como 4 caracteres adicionais em comparação com apenas cmd /K g.cmd. Isso configura um ambiente que possui a 'Matriz' na memória. Também demora uma eternidade para executar, portanto, use valores muito baixos para tentar interromper a execução usandoCtrl+C

Demolir

Invokation

• /Vpermite expansão atrasada, mas é mais curto que setlocal EnableDelayedExpansion, e é por isso que precisamos da cmdchamada em primeiro lugar
• /Q omite a saída e é equivalente a @echo off
• /Kpermite executar uma expressão (neste caso g.cmd) e não sai depois, para que você possa verificar a 'Matriz' usandoset #

g.cmd

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

Este bit usa um truque documentado aqui para converter um número normal em um hexadecimal e, em seguida, salva esse valor em uma 'Matriz'.

Eu chamo essa estrutura de armazenamento de 'Matriz', mas isso não está certo, pois matrizes verdadeiras não existem no Lote. MAS você pode nomear variáveis ​​para que elas tenham nomes semelhantes a matrizes, assim:

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

ou, como neste caso:

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

Você ainda pode acessá-los via !#%position%!

Groovy , 53 bytes

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

Definição de função. c () retorna um ArrayList (presumo que esteja bem, mesmo com a pergunta solicitando um array).

Ungolfed, com tipos implícitos:

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

Experimente online!

Java 10, 87 84 bytes

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

-3 bytes thanks to @archangel.mjj.

Try it online (limited to the first 4,096 items).

Explanation:

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 bytes

This is supposed to be placed inside a file, the array is returned in the end, to be usable.

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

To have access to the array, simply give the result of the include (e.g.: $a = include 'xyz.php';) to a variable.

Thanks to @manatwork for saving me 6 bytes and fix a goof.

MATL, 11 bytes

'#'5Y26Z^Yc

Try it online! (with only three hex digits instead of six)

Explanation

'#'   % 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

Try it online!

Perl 5, 31 bytes

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

Try it online!

Lua, 47 45 bytes

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

Try it online!

T-SQL, 122 117 bytes

Returns a 16,777,216-row table of #RRGGBB strings. The line break is for readability only:

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

Uses a recursive CTE for a number table from 0 to 2^24-1, then uses the built-in FORMAT command (available in SQL 2012 or later) to turn it into a 6-digit hex string. Attach the # to the front, and we're done.

Edit 1: Removed POWER() function, the number was shorter :P

Jelly, 12 bytes

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

Try it online!

Jelly, 8 bytes

ØHṗ6”#;Ɱ

Try it online! (note: uses 2 rather than 6 as 6 times out on TIO)

Function submission (because Jelly full programs will, by default, print lists of strings with no delimiters between them, making it hard to see the boundaries). The TIO link contains a wrapper to print a list of strings using newlines to separate them.

Explanation

Ø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 bytes

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

Try it online!

Scala, 40 bytes

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

Try it online!

Perl 6, 26 bytes

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

Try it online!

Uses the same format as everyone else. Times out on TIO.

Or, in rgb format:

31 bytes

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

Try it online!