Biorąc pod uwagę 3 bajty lub RGB jako dane wejściowe, oblicz najbliższe wartości CMYK i wyślij je.

• utwórz funkcję z parametrami i wartością zwracaną lub program działający na stdin / stdout
• użyj wybranego profilu kolorów, ale podaj odniesienie
• dane wejściowe mogą być osobnymi wartościami liczbowymi z zakresu [0; 255] lub sześciocyfrowym łańcuchem szesnastkowym
• dane wyjściowe powinny być osobnymi wartościami liczbowymi w zakresie od [0; 1] lub [0; 100]
• standardowy kod golfowy: brak luk , wygrywa najkrótszy kod
• ekstrawaganckie pomysły są mile widziane

przykładowe dane:

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

• Nieskalibrowane mapowanie jest w porządku i prawdopodobnie najłatwiejsze
• Nie wymaga sprawdzania poprawności danych wejściowych; liczby zmiennoprzecinkowe są dozwolone (od 0 do 255), ale mogą być również zaokrąglane
• Format wyjściowy powinien być wyraźnie skomentowany lub oczywisty; to znaczy:
  1. CMYK w tej kolejności
  2. nie ma znaczenia, czy wartości procentowe [0; 100] czy czyste liczby [0; 1]
• Testy powinny obejmować trywialny przykład [0,0,0].

Ta strona zawiera najwięcej cyfr narzędzi online, jakie udało mi się znaleźć. Czy ktoś zna narzędzie, które daje więcej niż 4 cyfry?

Dyalog APL , 16 15 bajtów

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

1 minus 1-
 X podzielone przez ÷ Y , a następnie ,255 dzielące 255÷⍨ Y ⊢ , gdzie
  X jest sobą ⊢(tj. Listą wartości RGB), a
  Y jest wartością maksymalną /⌈(wartości RGB).

TryAPL!

Kredyty:
 ∘ -1 bajt przez ngn .

C # , 88 86 85 84 bajtów

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

wyjście dla 108,174,106:

0.3793104
0
0.3908046
0.3176471

Ponieważ OP pozwala na funkcję, przesłałem tylko lambda. Uruchomione demo można znaleźć na .NetFiddle . Nie jestem golfistą, zamieszczam posty dla zabawy. Jest to także moja pierwsza odpowiedź \ o /. Skomentuj wszelkie ulepszenia :)

Wyrazy uznania dla Dziurawej Zakonnicy za wzór.

zastrzeżenie: nie działa dla [0,0,0] (dziękuję Tytusowi)

Python, 46 bajtów

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

Wymaga, aby dane wejściowe były zmienne w Pythonie 2, dość pewne, że nie w 3.

JavaScript (ES6), 58 51 bajtów

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

Akceptuje tablicę [R, G, B](dodaj 7 bajtów dla oddzielnych parametrów) i zwraca tablicę [C, M, Y, K]za pomocą nieskalibrowanego odwzorowania kolorów.

Matematyka, 36 28 33 bajty

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

Po liberalizacji formatów I / O grał w golfa: List@@#~ColorConvert~"CMYK"&

Funkcja anonimowa, która wykonuje to, o co prosi.

Stara funkcja przyjmuje trzy argumenty od 0 do 255 (wszystko poza tym zakresem zostanie automatycznie przycięte do tego zakresu) i zwraca tablicę wartości „CMYK” pomiędzy 0.a1.

Przykład (dla starej funkcji):

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

{0.37931, 0., 0.390805, 0.320313}

Ponieważ tablice są dozwolone jako dane wejściowe, 33 bajty:

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

Oczywiście te wbudowane w uchwyty funkcja {0, 0, 0}działa poprawnie i powraca {0, 0, 0, 1}.

Bash + ImageMagick, 69 bajtów

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

Przykład:

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

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

Może być znacznie krótszy.

Pyth, 24 21 18 24 21 bajtów

Życie to rzeczywiście podróż w obie strony.

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

Zestaw testowy.

Przykładowe dane wejściowe: 108,174,106

Przykładowe dane wyjściowe: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Przykładowe dane wejściowe: 0,0,0

Przykładowe dane wyjściowe: [0, 0, 0, 1.0]

Zastosowana formuła:

Stara formuła: http://i.stack.imgur.com/ZtPD6.gif

Stara formuła: http://i.stack.imgur.com/Nqi9F.gif

Lithp , 114 bajtów

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

Wypróbuj online!

• Zapisano 6 bajtów (zapomniałem, że maxbierze dowolną liczbę argumentów)

Nie jestem pewien, czy to prawda. Pierwsze dwa wyniki z przykładowymi danymi są poprawne, ale pozostałe nie są (zobacz Wypróbuj online ).

Korzysta z implementacji opisanej poniżej:

PHP 7, 123 110 105 bajtów

Wprowadź jako kolor 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]);

Wyświetla wartości CMYK jako dziesiętne w 0...1zakresie.

Zaoszczędził wiele bajtów dzięki Titusowi.

Przykładowe użycie:

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

Przetestuj online

Wprowadź jako kolor HEX #123456, 202 bajty

$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 bajty dla funkcji zapobiegającej dzieleniu przez zero, prawdopodobnie grywalnej lub usuwalnej.

Pobiera wejściowy kolor RGB jako HEX #123456i wysyła CMYK jako dziesiętny w 0...1zakresie.

Przykładowe użycie:

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, nie konkuruje

Byłem zbyt kuszony, aby opublikować własne.

Wejście RGB, 74 bajty

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

lub 68 bajtów z końcowym przecinkiem na wyjściu: usuń [$i>3].

Uruchom z php -r '<code>' <red-value> <green-value> <blue-value>.

Wejście HEX, 100 bajtów

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

Uruchom z php -nr '<code>' RRGGBB.

Podejście to zajmie 75 bajtów dla wejścia RGB:
zamienić foreach($a=array_map...as$c)z foreach($a=$argv as$c)if($i++).

C, 155 bajtów

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

Próbuję dowiedzieć się, w jaki sposób golf jest bardziej możliwy.

Stosowanie:

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

Wynik:

0.379310
0.000000
0.390805
0.317647

Hoon , 110 bajtów

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

Użyj biblioteki zmiennoprzecinkowej pojedynczej precyzji. Utwórz nową funkcję ogólną, która zajmie a. Ustaw sna subcurry z .1na później, a jna zagięciu az max.

Odwzoruj a, dzieląc każdy element j, znajdując minimum tego i 1, aby znormalizować NaN, a następnie odejmij 1 za pomocą s. Dodaj 1-j/255na końcu tej listy.

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