Étant donné 3 octets ou RVB en entrée, calculez les valeurs CMJN les plus proches et sortez-les.

• créer soit une fonction avec des paramètres et une valeur de retour, soit un programme qui fonctionne sur stdin / stdout
• utilisez le profil de couleur de votre choix, mais fournissez une référence
• l'entrée peut être soit des valeurs numériques distinctes dans la plage [0; 255] soit une chaîne hexadécimale à 6 chiffres
• la sortie doit être des valeurs numériques distinctes allant de [0; 1] ou [0; 100]
• golf à code standard: pas d'échappatoire , gain de code le plus court
• les idées extravagantes sont les bienvenues

exemples de données:

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

• La cartographie non étalonnée est fine et probablement la plus simple
• Aucune validation d'entrée requise; les flottants sont autorisés (de 0 à 255), mais peuvent également être arrondis
• Le format de sortie doit être clairement commenté ou évident; c'est à dire:
  1. CMJN dans cet ordre
  2. n'a pas d'importance si le pourcentage [0; 100] ou les nombres purs [0; 1]
• Les tests devraient inclure l'exemple trivial [0,0,0].

Ce site contient le plus de chiffres d'outils en ligne que j'ai pu trouver. Est-ce que quelqu'un connaît un outil qui donne plus de 4 chiffres?

Dyalog APL , 16 15 octets

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

1 moins 1-
 X divisé par ÷ Y , suivi de ,255 en divisant 255÷⍨ Y ⊢ , où
  X est lui-même ⊢(c'est-à-dire la liste des valeurs RVB) et
  Y est le maximum /⌈(des valeurs RVB).

TryAPL!

Crédits:
 ∘ -1 octet par ngn .

C # , 88 86 85 84 octets

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

sortie pour 108,174,106:

0.3793104
0
0.3908046
0.3176471

Puisque OP autorise la fonction, je n'ai soumis que le lambda. Vous pouvez trouver une démonstration en cours sur .NetFiddle . Je ne suis pas golfeur, je poste pour le plaisir. C'est aussi ma première réponse \ o /. N'hésitez pas à commenter toute amélioration :)

Félicitations à Leaky Nun pour la formule.

mise en garde: cela ne fonctionne pas pour [0,0,0] (merci Titus)

Python, 46 octets

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

Nécessite une entrée flottante en Python 2, assez sûr que non en 3.

JavaScript (ES6), 58 51 octets

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

Accepte un tableau [R, G, B](ajoutez 7 octets pour des paramètres distincts) et retourne un tableau [C, M, Y, K]à l'aide du mappage des couleurs non calibré.

Mathematica, 36 28 33 octets

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

Après la libéralisation des formats d'E / S, a continué à jouer: List@@#~ColorConvert~"CMYK"&

Fonction anonyme, qui fait ce qui est demandé.

L'ancienne fonction prend trois arguments de 0 à 255 (tout ce qui dépasse cette plage sera automatiquement coupé dans cette plage) et retourne un tableau de valeurs "CMJN" entre 0.et1.

Exemple (pour l'ancienne fonction):

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

{0.37931, 0., 0.390805, 0.320313}

Étant donné que les tableaux sont autorisés en entrée, 33 octets:

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

Bien sûr , les intégrés poignées de fonction {0, 0, 0}correctement et revient {0, 0, 0, 1}.

Bash + ImageMagick, 69 octets

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

Exemple:

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

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

Pourrait être beaucoup plus court.

Pyth, 24 21 18 24 21 octets

La vie est en effet un aller-retour.

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

Suite de tests.

Exemple d'entrée: 108,174,106

Exemple de sortie: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Exemple d'entrée: 0,0,0

Exemple de sortie: [0, 0, 0, 1.0]

Formule utilisée:

Ancienne formule: http://i.stack.imgur.com/ZtPD6.gif

Ancienne formule: http://i.stack.imgur.com/Nqi9F.gif

Lithp , 114 octets

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

Essayez-le en ligne!

• Enregistré 6 octets (oublié qui maxprend n'importe quel nombre d'arguments)

Je ne suis pas sûr que ce soit vrai. Les deux premiers résultats avec les exemples de données sont corrects, mais les autres ne le sont pas (voir la section Essayer en ligne .)

Utilise bien l'implémentation décrite comme suit:

PHP 7, 123 110 105 octets

Entrée en couleur RVB 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]);

Affiche les valeurs CMJN sous forme décimale dans la 0...1plage.

Beaucoup d'octets enregistrés grâce à Titus.

Exemple d'utilisation:

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

Testez en ligne

Entrée en couleur HEX #123456, 202 octets

$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 octets de fonction pour empêcher la division par zéro, probablement jouable au golf ou amovible.

Obtient comme couleur RVB d'entrée comme HEX #123456et sort CMJN comme décimal dans0...1 plage .

Exemple d'utilisation:

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, pas en compétition

J'étais trop tentée de poster la mienne.

Entrée RVB, 74 octets

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

ou 68 octets avec une virgule de fin dans la sortie: supprimer [$i>3].

Courez avec php -r '<code>' <red-value> <green-value> <blue-value>.

Entrée HEX, 100 octets

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

Courez avec php -nr '<code>' RRGGBB.

Cette approche prendrait 75 octets pour l'entrée RVB:
remplacer foreach($a=array_map...as$c)par foreach($a=$argv as$c)if($i++).

C, 155 octets

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

J'essaie de comprendre comment c'est plus possible de jouer au golf.

Usage:

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

Production:

0.379310
0.000000
0.390805
0.317647

Hoon , 110 octets

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

Utilisez la bibliothèque à virgule flottante simple précision. Créez une nouvelle fonction générique qui prend a. Prêt sà subcurry avec .1pour plus tard, et jà se replier aavecmax .

Cartographiez aen divisant chaque élément par j, en trouvant le minimum de 1 et 1 pour normaliser NaN, puis soustrayez 1 avec s. Ajoutez 1-j/255à la fin de cette liste.

> =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]]]