Dados 3 bytes o RGB como entrada, calcule los valores CMYK más cercanos y expórtelos.

• cree una función con parámetros y valor de retorno o un programa que opera en stdin / stdout
• use el perfil de color de su elección, pero proporcione una referencia
• la entrada puede ser valores numéricos separados en el rango [0; 255] o una cadena hexadecimal de 6 dígitos
• la salida debe ser valores numéricos separados que varían entre [0; 1] o [0; 100]
• golf de código estándar: sin lagunas , gana el código más corto
• ideas extravagantes son bienvenidas

Data de muestra:

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

• El mapeo sin calibrar está bien y probablemente sea el más fácil
• No se requiere validación de entrada; los flotadores están permitidos (de 0 a 255), pero también pueden redondearse
• El formato de salida debe ser claramente comentado u obvio; es decir:
  1. CMYK en ese orden
  2. no importa si el porcentaje [0; 100] o los números puros [0; 1]
• Las pruebas deben incluir el ejemplo trivial [0,0,0].

Este sitio tiene la mayor cantidad de herramientas en línea que pude encontrar. ¿Alguien sabe una herramienta que da más de 4 dígitos?

Dyalog APL , 16 15 bytes

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

1 menos 1-
 X dividido por ÷ Y , seguido de ,255 dividiendo 255÷⍨ Y ⊢ , donde
  X es en sí mismo ⊢(es decir, la lista de valores RGB) e
  Y es el máximo /⌈(de los 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);};

salida para 108,174,106:

0.3793104
0
0.3908046
0.3176471

Como OP permite la función, envié solo la lambda. Puede encontrar una demostración en ejecución en .NetFiddle . No soy golfista, publico por diversión. Además, es mi primera respuesta \ o /. Siéntase libre de comentar cualquier mejora :)

Felicitaciones a Leaky Nun por la fórmula.

advertencia: no funciona para [0,0,0] (gracias Titus)

Python, 46 bytes

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

Requiere que la entrada sea flotante en Python 2, bastante seguro de que no lo hace en 3.

JavaScript (ES6), 58 51 bytes

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

Acepta una matriz [R, G, B](agregue 7 bytes para parámetros separados) y devuelve una matriz [C, M, Y, K]usando el mapeo de color no calibrado.

Mathematica 36 28 33 bytes

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

Después de la liberalización de los formatos de E / S, jugó más: List@@#~ColorConvert~"CMYK"&

Función anónima, que hace lo que se le pide.

La función anterior toma tres argumentos de 0 a 255 (todo lo que esté más allá de este rango se recortará automáticamente a este rango) y devuelve una matriz de valores "CMYK" entre 0.y1.

Ejemplo (para función antigua):

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

{0.37931, 0., 0.390805, 0.320313}

Como las matrices están permitidas como entrada, 33 bytes:

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

Por supuesto, los incorporados en las manijas de función {0, 0, 0}correctamente y regresa {0, 0, 0, 1}.

Bash + ImageMagick, 69 bytes

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

Ejemplo:

$ ./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

Podría ser mucho más corto.

Pyth, 24 21 18 24 21 bytes

La vida es un viaje redondo, de hecho.

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

Banco de pruebas.

Entrada de muestra: 108,174,106

Salida de muestra: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Entrada de muestra: 0,0,0

Salida de muestra: [0, 0, 0, 1.0]

Fórmula utilizada:

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

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

Lithp , 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))))

Pruébalo en línea!

• Guardado 6 bytes (olvidé que maxtoma cualquier número de argumentos)

No estoy muy seguro de que esto sea correcto. Los primeros dos resultados con los datos de la muestra son correctos, pero el resto no lo es (consulte la sección Pruébelo en línea ).

Utiliza la implementación que se describe muy bien de la siguiente manera:

PHP 7, 123 110 105 bytes

Entrada como color 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 decimales en el 0...1rango.

Ahorré muchos bytes gracias a Titus.

Uso de la muestra:

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

Prueba en línea

Entrada como color 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 la función para evitar la división por cero, probablemente golfable o extraíble.

Obtiene como entrada el color RGB como HEX #123456y genera CMYK como decimal en el 0...1rango.

Uso de la muestra:

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, no compitiendo

Estaba demasiado tentado a publicar el mío.

Entrada RGB, 74 bytes

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

o 68 bytes con una coma final en la salida: eliminar [$i>3].

Corre con 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;  

Corre con php -nr '<code>' RRGGBB.

Ese enfoque tomaría 75 bytes para la entrada RGB:
reemplace foreach($a=array_map...as$c)con 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));}

Estoy tratando de descubrir cómo es posible el golf más.

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

Salida:

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

Utilice la biblioteca de punto flotante de precisión única. Crea una nueva función genérica que tome a. Establecer sal subcurry con .1para más tarde y jdoblar acon max.

Haz un mapa adividiendo cada elemento con j, encontrando el mínimo de eso y 1 para normalizar NaN, luego resta 1 con s. Añadir 1-j/255al final de esa 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]]]