Получив 3 байта или RGB в качестве входных данных, рассчитайте ближайшие значения CMYK и выведите их.

• создайте либо функцию с параметрами и возвращаемым значением, либо программу, которая работает с stdin / stdout
• используйте цветовой профиль по вашему выбору, но предоставьте ссылку
• входными данными могут быть либо отдельные числовые значения в диапазоне [0; 255], либо 6-значная шестнадцатеричная строка
• выходные данные должны быть отдельными числовыми значениями в диапазоне [0; 1] или [0; 100]
• стандартный код гольф: без лазеек , выигрывает самый короткий код
• экстравагантные идеи приветствуются

образец данных:

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

• Некалиброванное отображение - это хорошо и, вероятно, самое простое
• Проверка ввода не требуется; Допускаются значения с плавающей точкой (от 0 до 255), но они также могут быть округлены
• Формат вывода должен быть либо четко прокомментирован, либо очевиден; то есть:
  1. CMYK в этом порядке
  2. не имеет значения, если процент [0; 100] или чистые числа [0; 1]
• Тестирование должно включать тривиальный пример [0,0,0].

На этом сайте есть большинство цифр онлайн-инструментов, которые я смог найти. Кто-нибудь знает инструмент, который дает более 4 цифр?

Дьялог АПЛ , 16 15 байт

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

1 минус 1-
 X делится на ÷ Y , а затем ,255 делит 255÷⍨ Y ⊢ , где
  X сам по себе ⊢(то есть список значений RGB), а
  Y - максимум /⌈(значений RGB).

TryAPL!

Кредиты:
 ∘ -1 байт по ngn .

C # , 88 86 85 84 байта

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

выход для 108,174,106:

0.3793104
0
0.3908046
0.3176471

Так как OP позволяет функцию, я представил только лямбду. Вы можете найти работающую демонстрацию на .NetFiddle . Я не игрок в гольф, я публикую для удовольствия. Также это мой первый ответ \ о /. Не стесняйтесь комментировать любые улучшения :)

Слава Leaky Nun для формулы.

предостережение: это не работает для [0,0,0] (спасибо, Титус)

Python, 46 байт

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

Требует, чтобы ввод был плавающим в Python 2, точно уверен, что в 3 нет.

JavaScript (ES6), 58 51 байт

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

Принимает массив [R, G, B](добавляет 7 байтов для отдельных параметров) и возвращает массив [C, M, Y, K]с использованием некалиброванного цветового отображения.

Mathematica, 36 28 33 байта

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

После либерализации форматов ввода / вывода, игра в гольф дальше: List@@#~ColorConvert~"CMYK"&

Анонимная функция, которая делает то, что просят.

Старая функция принимает три аргумента от 0 до 255 (все, что находится за пределами этого диапазона, автоматически обрезается до этого диапазона) и возвращает массив значений «CMYK» между 0.и1.

Пример (для старой функции):

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

{0.37931, 0., 0.390805, 0.320313}

Поскольку массивы допустимы в качестве входных данных, 33 байта:

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

Конечно , эти встроенные функции ручки {0, 0, 0}правильно и возвращается {0, 0, 0, 1}.

Bash + ImageMagick, 69 байт

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

Пример:

$ ./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 байта

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

Может быть намного короче.

Pyth, 24 21 18 24 21 байт

Жизнь - это путешествие в оба конца.

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

Тестирование.

Пример ввода: 108,174,106

Пример вывода: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Пример ввода: 0,0,0

Пример вывода: [0, 0, 0, 1.0]

Используемая формула:

Старая формула: http://i.stack.imgur.com/ZtPD6.gif

Старая формула: http://i.stack.imgur.com/Nqi9F.gif

Lithp , 114 байт

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

Попробуйте онлайн!

• Сохранено 6 байт (забыл, что maxпринимает любое количество аргументов)

Я не совсем уверен, что это правильно. Первые два результата с примерами данных верны, а остальные - нет (см. « Попробуйте онлайн» ).

Использует реализацию, описанную красиво следующим образом:

PHP 7, 123 110 105 байт

Введите как цвет 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]);

Выводит значения CMYK в виде десятичного числа в 0...1диапазоне.

Благодаря Titus удалось сэкономить много байтов.

Пример использования:

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

Тест онлайн

Ввод как HEX цвет #123456, 202 байта

$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 байта для функции, чтобы предотвратить деление на ноль, вероятно, пригодный для игры в гольф или съемный.

Получает в качестве входного цвета RGB как HEX #123456и выводит CMYK как десятичный в 0...1диапазоне.

Пример использования:

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, не конкурирующий

Я был слишком соблазнен, чтобы опубликовать свой собственный.

Вход RGB, 74 байта

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

или 68 байтов с запятой в выводе: удалить [$i>3].

Беги с php -r '<code>' <red-value> <green-value> <blue-value>.

Шестнадцатеричный ввод, 100 байт

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

Беги с php -nr '<code>' RRGGBB.

Этот подход занял бы 75 байтов для ввода RGB:
заменить foreach($a=array_map...as$c)на foreach($a=$argv as$c)if($i++).

C 155 байт

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

Я пытаюсь понять, как можно больше играть в гольф.

Применение:

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

Вывод:

0.379310
0.000000
0.390805
0.317647

Хун , 110 байт

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

Используйте библиотеку с плавающей точкой одинарной точности. Создайте новую универсальную функцию, которая принимает a. Набор sдля subдубления с .1на потом, и jскладывание над aс max.

Нанесите на карту a, разделив каждый элемент на j, найдя минимум этого и 1, чтобы нормализовать NaN, затем вычтите 1 с s. Добавьте 1-j/255в конец этого списка.

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