Cho 3 byte hoặc RGB làm đầu vào, tính toán các giá trị CMYK gần nhất và xuất chúng.

• tạo một hàm với các tham số và giá trị trả về hoặc một chương trình hoạt động trên stdin / stdout
• sử dụng hồ sơ màu của sự lựa chọn của bạn, nhưng cung cấp một tài liệu tham khảo
• đầu vào có thể là các giá trị số riêng biệt trong phạm vi [0; 255] hoặc chuỗi hex 6 chữ số
• đầu ra phải là các giá trị số riêng biệt khác nhau, [0; 1] hoặc [0; 100]
• mã golf tiêu chuẩn: không có sơ hở , chiến thắng mã ngắn nhất
• ý tưởng ngông cuồng được chào đón

dữ liệu mẫu:

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

• Ánh xạ không hiệu chuẩn là tốt và có lẽ là dễ nhất
• Không yêu cầu xác nhận đầu vào; phao được cho phép (từ 0 đến 255), nhưng cũng có thể được làm tròn
• Định dạng đầu ra phải được bình luận rõ ràng hoặc rõ ràng; I E:
  1. CMYK theo thứ tự đó
  2. không quan trọng nếu tỷ lệ phần trăm [0; 100] hoặc số thuần [0; 1]
• Kiểm tra nên bao gồm ví dụ tầm thường [0,0,0].

Trang web này có hầu hết các chữ số của các công cụ trực tuyến mà tôi có thể tìm thấy. Có ai biết một công cụ cho hơn 4 chữ số không?

APL Dyalog , 16 15 byte

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

1 trừ 1-
 X chia cho ÷ Y , theo sau là ,255 chia 255÷⍨ Y ⊢ , trong đó
  X là chính nó ⊢(tức là danh sách các giá trị RGB) và
  Y là max /⌈(của các giá trị RGB).

Hãy thử!

Tín dụng:
 ∘ -1 byte bởi ngn .

C # , 88 86 85 84 byte

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

đầu ra cho 108,174,106:

0.3793104
0
0.3908046
0.3176471

Vì OP cho phép chức năng nên tôi chỉ gửi lambda. Bạn có thể tìm thấy một bản chạy thử trên .NetFiddle . Tôi không phải là một người chơi golf, tôi đăng cho vui. Ngoài ra, đây là câu trả lời đầu tiên của tôi \ o /. Hãy bình luận bất kỳ cải tiến :)

Kudos để Leaky Nun cho công thức.

báo trước: nó không hoạt động cho [0,0,0] (cảm ơn bạn Titus)

Python, 46 byte

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

Yêu cầu đầu vào phải nổi trong Python 2, khá chắc chắn rằng nó không có trong 3.

JavaScript (ES6), 58 51 byte

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

Chấp nhận một mảng [R, G, B](thêm 7 byte cho các tham số riêng biệt) và trả về một mảng [C, M, Y, K]bằng cách sử dụng ánh xạ màu không được hiệu chỉnh.

Toán học, 36 28 33 byte

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

Sau khi tự do hóa các định dạng I / O, đánh gôn thêm: List@@#~ColorConvert~"CMYK"&

Chức năng ẩn danh, đó là những gì được yêu cầu.

Hàm cũ lấy ba đối số từ 0 đến 255 (mọi thứ nằm ngoài phạm vi này sẽ được tự động cắt bớt đến phạm vi này) và trả về một mảng các giá trị "CMYK" giữa 0.và1.

Ví dụ (cho hàm cũ):

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

{0.37931, 0., 0.390805, 0.320313}

Vì các mảng được phép làm đầu vào, 33 byte:

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

Tất nhiên các built-in xử lý chức năng {0, 0, 0}đúng cách và lợi nhuận {0, 0, 0, 1}.

Bash + ImageMagick, 69 byte

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

Thí dụ:

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

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

Có thể ngắn hơn nhiều.

Pyth, 24 21 18 24 21 byte

Cuộc sống là một chuyến đi vòng, thực sự.

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

Bộ thử nghiệm.

Đầu vào mẫu: 108,174,106

Đầu ra mẫu: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Đầu vào mẫu: 0,0,0

Đầu ra mẫu: [0, 0, 0, 1.0]

Công thức sử dụng:

Công thức cũ: http://i.stack.imgur.com/ZtPD6.gif

Công thức cũ: http://i.stack.imgur.com/Nqi9F.gif

Tiếng Litva , 114 byte

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

Hãy thử trực tuyến!

• Đã lưu 6 byte (quên rằng max mất số lượng đối số)

Tôi không chắc chắn điều này là đúng. Hai kết quả đầu tiên với dữ liệu mẫu là chính xác, nhưng phần còn lại thì không (xem phần Thử trực tuyến .)

Sử dụng thực hiện được mô tả độc đáo như sau:

PHP 7, 123 110 105 byte

Nhập dưới dạng màu 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]);

Xuất ra các giá trị CMYK dưới dạng thập phân trong 0...1 phạm vi.

Đã lưu rất nhiều byte nhờ Titus.

Sử dụng mẫu:

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

Kiểm tra trực tuyến

Nhập dưới dạng màu HEX #123456, 202 byte

$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 byte cho chức năng để ngăn chia cho 0, có thể chơi được hoặc có thể tháo rời.

Lấy màu RGB đầu vào là HEX #123456và xuất CMYK dưới dạng thập phân trong 0...1phạm vi.

Sử dụng mẫu:

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, không cạnh tranh

Tôi đã quá cám dỗ để đăng bài của riêng tôi.

Đầu vào RGB, 74 byte

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

hoặc 68 byte với dấu phẩy ở đầu ra: remove [$i>3].

Chạy với php -r '<code>' <red-value> <green-value> <blue-value>.

Đầu vào HEX, 100 byte

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

Chạy với php -nr '<code>' RRGGBB.

Cách tiếp cận đó sẽ mất 75 byte cho đầu vào RGB:
thay thế foreach($a=array_map...as$c)bằng foreach($a=$argv as$c)if($i++).

C, 155 byte

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

Tôi đang cố gắng tìm hiểu làm thế nào nó có thể chơi golf nhiều hơn.

Sử dụng:

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

Đầu ra:

0.379310
0.000000
0.390805
0.317647

Hoon , 110 byte

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

Sử dụng thư viện dấu phẩy động chính xác duy nhất. Tạo một chức năng chung mới có a. Đặt sđể subcuộn lại .1cho sau này và jđể gấp lại avới max.

Ánh xạ qua abằng cách chia từng phần tử với j, tìm tối thiểu của phần tử đó và 1 để chuẩn hóa NaN, sau đó trừ đi 1 với s. Thêm 1-j/255vào cuối danh sách đó.

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