Dados 3 bytes ou RGB como entrada, calcule os valores CMYK mais próximos e faça a saída deles.

• crie uma função com parâmetros e valor de retorno ou um programa que opere em stdin / stdout
• use o perfil de cores de sua escolha, mas forneça uma referência
• entrada pode ser valores numéricos separados no intervalo [0; 255] ou uma sequência hexadecimal de 6 dígitos
• a saída deve ser valores numéricos separados, variando entre [0; 1] ou [0; 100]
• código de golfe padrão: sem brechas , o código mais curto vence
• idéias extravagantes são bem-vindas

dados de amostra:

input             output
108,174,106       [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]
0,0,0             0,0,0,1
170,255,238       33,0,7,0  
0x0088ff          1,0.4667,0,0
[250,235,215]     [0,6,14,1.96]  
#123456           .7907,.3953,0,.6627

• O mapeamento não calibrado é bom e provavelmente o mais fácil
• Nenhuma validação de entrada é necessária; flutuadores são permitidos (variando de 0 a 255), mas também podem ser arredondados
• O formato de saída deve ser claramente comentado ou óbvio; ou seja:
  1. CMYK nessa ordem
  2. não importa se a porcentagem [0; 100] ou os números puros [0; 1]
• O teste deve incluir o exemplo trivial [0,0,0].

Este site tem o maior número de ferramentas online que eu encontrei. Alguém conhece uma ferramenta que fornece mais de 4 dígitos?

Dyalog APL , 16 15 bytes

1-⊢(÷,255÷⍨⊢)⌈/

1 menos 1-
 X dividido por ÷ Y , seguido por ,255 dividindo 255÷⍨ Y ⊢ , onde
  X é ele próprio ⊢(ou seja, a lista de valores RGB) e
  Y é o máximo /⌈(dos valores RGB).

TryAPL!

Créditos:
 -1 byte por ngn .

C # , 88 86 85 84 bytes

(r,g,b)=>{float[]a={r,g,b,1};var j=a.Max();a[3]=j*j/255;return a.Select(x=>1-x/j);};

saída para 108,174,106:

0.3793104
0
0.3908046
0.3176471

Como o OP permite a função, enviei apenas o lambda. Você pode encontrar uma demonstração em execução no .NetFiddle . Eu não sou um jogador de golfe, eu posto por diversão. Além disso, é a minha primeira resposta \ o /. Sinta-se livre para comentar qualquer melhoria :)

Parabéns à Leaky Nun pela fórmula.

ressalva: não funciona por [0,0,0] (obrigado Titus)

Python, 46 bytes

lambda*c:[1-i/max(c)for i in c]+[1-max(c)/255]

Requer entrada para flutuar no Python 2, com certeza não no 3.

JavaScript (ES6), 58 51 bytes

a=>[...a.map(e=>1-e/m||1,m=Math.max(...a)),1-m/255]

Aceita uma matriz [R, G, B](adicione 7 bytes para parâmetros separados) e retorna uma matriz [C, M, Y, K]usando o mapeamento de cores não calibrado.

Mathematica, 36. 28. 33 bytes

List@@ColorConvert[{##}/255,"CMYK"]&

Após a liberalização dos formatos de E / S, jogou golfe ainda mais: List@@#~ColorConvert~"CMYK"&

Função anônima, que faz o que é solicitado.

A função antiga recebe três argumentos de 0 a 255 (qualquer coisa além desse intervalo será cortada automaticamente para esse intervalo) e retorna uma matriz de valores "CMYK" entre 0.e1.

Exemplo (para função antiga):

List @@ ColorConvert[{##}/255, "CMYK"] &[108, 174, 106]

{0.37931, 0., 0.390805, 0.320313}

Como matrizes são permitidas como entrada, 33 bytes:

List@@ColorConvert[#/255,"CMYK"]&

É claro que as built-in alças função {0, 0, 0}correctamente e volta {0, 0, 0, 1}.

Bash + ImageMagick, 69 bytes

convert "xc:$1[1x1]" -colorspace cmyk txt:-|grep -o '([^)]*)'|head -1

Exemplo:

$ ./rgb2cmyk.sh "#6CAE6A"
(38%,0%,39%,32%)

$ ./rgb2cmyk.sh "#000000"
(0%,0%,0%,100%)

$ ./rgb2cmyk.sh "#AAFFEE"
(33%,0%,7%,0%)

$ ./rgb2cmyk.sh "#0088ff"
(100%,47%,0%,0%)

$ ./rgb2cmyk.sh "#FAEBD7"
(0%,6%,14%,2%)

$ ./rgb2cmyk.sh "#123456"
(79%,40%,0%,66%)

SmileBASIC, 73 72 bytes

INPUT R,G,B
J=MAX(R,G,B)IF!J THEN?0,0,0,1 ELSE?1-R/J,1-G/J,1-B/J,1-J/255

Pode ser muito mais curto.

Pitão, 24 21 18 24 21 bytes

A vida é uma viagem de ida e volta.

= cR255Q + mc - 1dK-1JeSQJQK 
= cR255Q + mc-JeSQdJQ-1J 
+ mc-JeSQdJQ-1cJ255 
+ mc-JeSQd + J ^ T_15Q-1cJ255
+ m-1? JeSQcdJ1Q-1cJ255

Suíte de teste.

Entrada de amostra: 108,174,106

Saída de amostra: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Entrada de amostra: 0,0,0

Saída de amostra: [0, 0, 0, 1.0]

Fórmula utilizada:

Fórmula antiga: http://i.stack.imgur.com/ZtPD6.gif

Fórmula antiga: http://i.stack.imgur.com/Nqi9F.gif

Lit , 114 bytes

#R,G,B::((var J(max R G B))(if(!= 0 J)((list(- 1(/ R J))(- 1(/ G J))(- 1(/ B J))(- 1(/ J 255))))((list 0 0 0 1))))

Experimente online!

• 6 bytes salvos (esqueci que maxleva qualquer número de argumentos)

Não tenho certeza se isso está certo. Os dois primeiros resultados com os dados da amostra estão corretos, mas o restante não (consulte a seção Experimente online ).

Usa a implementação descrita bem da seguinte maneira:

PHP 7, 123 110 105 bytes

Entrada como cor RGB 100 240 75

$j=max($h=$argv);echo strtr(@(1-$h[1]/$j).",".@(1-$h[2]/$j).",".@(1-$h[3]/$j).",".(1-$j/255),["NAN"=>0]);

Emite valores CMYK como decimais no 0...1intervalo.

Economizou muitos bytes graças a Titus.

Uso da amostra:

php -r '$j=max($h=$argv...' 100 240 75
0.58333333333333,0,0.6875,0.058823529411765

php -r '$j=max($h=$argv...' 255 255 255
0,0,0,0

php -r '$j=max($h=$argv...' 0 255 0
1,0,1,0

php -r '$j=max($h=$argv...' 0 0 0 
0,0,0,1

Teste on-line

Entrada como cor HEX #123456, 202 bytes

$h=str_split(substr($argv[1],-6),2);$j=max($r=hexdec($h[0]),$g=hexdec($h[1]),$b=hexdec($h[2]));echo z($r,$j),",",z($g,$j),",",z($b,$j),",",1-$j/255;function z($c,$y){return is_nan(@($c/$y))?0:1-$c/$y;}

54 bytes para a função impedir a divisão por zero, provavelmente jogável ou removível.

Obtém a cor RGB de entrada como HEX #123456e gera CMYK como decimal no 0...1intervalo.

Uso da amostra:

php -r '$h=str_split...' '#000000'
0,0,0,1

php -r '$h=str_split...' '#ffffff'
0,0,0,0

php -r '$h=str_split...' '#123456'
0.7906976744186,0.3953488372093,0,0.66274509803922

php -r '$h=str_split...' '#ffff00'
0,0,1,0

PHP, não competindo

Eu estava muito tentado a postar o meu.

Entrada RGB, 74 bytes

for(;$i++<4;)echo$i<4?($j=max($argv))?1-$argv[$i]/$j:0:1-$j/255,","[$i>3];

ou 68 bytes com uma vírgula à direita na saída: remova [$i>3].

Corra com php -r '<code>' <red-value> <green-value> <blue-value>.

Entrada HEX, 100 bytes

foreach($a=array_map(hexdec,str_split($argv[1],2))as$c)echo($j=max($a))?1-$c/$j:0,",";echo 1-$j/255;  

Corra com php -nr '<code>' RRGGBB.

Essa abordagem levaria 75 bytes para a entrada RGB:
substitua foreach($a=array_map...as$c)por foreach($a=$argv as$c)if($i++).

C, 155 bytes

#define C(x) 1-x/(j>0?j:1)
#define F float
i=0;F j;f(F r,F g,F b){j=(r>g?r:g)>b?(r>g?r:g):b;for(;i++<4;)printf("%f\n",i>1?i>2?i>3?1-j/255:C(b):C(g):C(r));}

Estou tentando descobrir como é possível jogar mais golfe.

Uso:

#define C(x) 1-x/(j>0?j:1)
#define F float
i=0;F j;f(F r,F g,F b){j=(r>g?r:g)>b?(r>g?r:g):b;for(;i++<4;)printf("%f\n",i>1?i>2?i>3?1-j/255:C(b):C(g):C(r));}
main(){
    f(108,174,106);
}

Resultado:

0.379310
0.000000
0.390805
0.317647

Hoon , 110 bytes

=>
rs
|*
a/*
=+
[s=(cury sub .1) j=(roll a max)]
(welp (turn a |*(* (s (min .1 (div +< j))))) (s (div j .255)))

Use a biblioteca de ponto flutuante de precisão única. Crie uma nova função genérica que leva a. Defina spara subcurry com .1para mais tarde e jpara dobrar acom max.

Mapeie adividindo cada elemento com j, encontrando o mínimo disso e 1 para normalizar NaN e subtraindo 1 com s. Adicione 1-j/255ao final dessa lista.

> =f =>
  rs
  |*
  a/*
  =+
  [s=(cury sub .1) j=(roll a max)]
  (welp (turn a |*(* (s (min .1 (div +< j))))) (s (div j .255)))
> (f (limo ~[.108 .174 .106]))
[i=.3.7931037e-1 t=[i=.0 t=[i=.3.908046e-1 .3.1764704e-1]]]
> (f (limo ~[.0 .0 .0]))
[i=.0 t=[i=.0 t=[i=.0 .1]]]