Dato 3 byte o RGB come input, calcola i valori CMYK più vicini e li emette.

• crea una funzione con parametri e valore di ritorno o un programma che opera su stdin / stdout
• usa il profilo colore di tua scelta, ma fornisci un riferimento
• l'input può essere valori numerici separati nell'intervallo [0; 255] o una stringa esadecimale a 6 cifre
• l'output dovrebbe essere valori numerici separati che vanno tra [0; 1] o [0; 100]
• codice standard golf: nessuna scappatoia , il codice più corto vince
• idee stravaganti sono benvenute

dati di esempio:

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 mappatura non calibrata va bene e probabilmente la più semplice
• Nessuna convalida di input richiesta; i float sono ammessi (compresi tra 0 e 255), ma possono anche essere arrotondati
• Il formato di output deve essere chiaramente commentato o ovvio; vale a dire:
  1. CMYK in questo ordine
  2. non importa se percentuale [0; 100] o numeri puri [0; 1]
• I test dovrebbero includere l'esempio banale [0,0,0].

Questo sito ha il maggior numero di strumenti online che ho potuto trovare. Qualcuno conosce uno strumento che fornisce più di 4 cifre?

Dyalog APL , 16 15 byte

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

1 meno 1-
 X diviso per ÷ Y , seguito da ,255 che divide 255÷⍨ Y ⊢ , dove
  X è esso stesso ⊢(ovvero l'elenco dei valori RGB) e
  Y è il massimo /⌈(dei valori RGB).

TryAPL!

Crediti:
 ∘ -1 byte per 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);};

uscita per 108,174,106:

0.3793104
0
0.3908046
0.3176471

Poiché OP consente la funzione, ho inviato solo lambda. Puoi trovare una demo in esecuzione su .NetFiddle . Non sono un giocatore di golf, invio per divertimento. Inoltre, è la mia prima risposta \ o /. Sentiti libero di commentare qualsiasi miglioramento :)

Complimenti a Leaky Nun per la formula.

avvertenza: non funziona per [0,0,0] (grazie Tito)

Python, 46 byte

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

Richiede che l'input sia float in Python 2, abbastanza sicuro che non lo sia in 3.

JavaScript (ES6), 58 51 byte

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

Accetta una matrice [R, G, B](aggiungi 7 byte per parametri separati) e restituisce una matrice [C, M, Y, K]usando la mappatura dei colori non calibrata.

Matematica, 36 28 33 byte

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

Dopo la liberalizzazione dei formati I / O, ho continuato a giocare a golf: List@@#~ColorConvert~"CMYK"&

Funzione anonima, che fa ciò che viene chiesto.

La vecchia funzione accetta tre argomenti da 0 a 255 (qualsiasi cosa al di fuori di questo intervallo verrà automaticamente tagliata a questo intervallo) e restituisce una matrice di valori "CMYK" tra 0.e1.

Esempio (per la vecchia funzione):

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

{0.37931, 0., 0.390805, 0.320313}

Poiché le matrici sono consentite come input, 33 byte:

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

Naturalmente i built-in maniglie funzioni {0, 0, 0}correttamente e ritorni {0, 0, 0, 1}.

Bash + ImageMagick, 69 byte

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

Esempio:

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

Potrebbe essere molto più breve.

Pyth, 24 21 18 24 21 byte

La vita è un viaggio di andata e ritorno, in effetti.

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

Suite di test.

Input di esempio: 108,174,106

Uscita campione: [0.3793103448275862, 0.0, 0.3908045977011494, 0.3176470588235294]

Input di esempio: 0,0,0

Uscita campione: [0, 0, 0, 1.0]

Formula utilizzata:

Vecchia formula: http://i.stack.imgur.com/ZtPD6.gif

Vecchia formula: http://i.stack.imgur.com/Nqi9F.gif

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

Provalo online!

• 6 byte salvati (dimenticato che maxaccetta un numero qualsiasi di argomenti)

Non sono del tutto sicuro che sia giusto. I primi due risultati con i dati di esempio sono corretti, ma il resto no (vedere la sezione Provalo online ).

Utilizza l'implementazione descritta come segue:

PHP 7, 123 110 105 byte

Input come colore 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]);

Emette valori CMYK come decimali 0...1nell'intervallo.

Hai salvato molti byte grazie a Titus.

Esempio di utilizzo:

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

Test online

Immettere come colore esadecimale #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 per la funzione per impedire la divisione per zero, probabilmente golfable o rimovibile.

Ottiene come colore RGB di input come HEX #123456e genera CMYK come decimale 0...1nell'intervallo.

Esempio di utilizzo:

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, non in competizione

Ero troppo tentato di pubblicare il mio.

Ingresso RGB, 74 byte

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

o 68 byte con una virgola finale nell'output: remove [$i>3].

Corri con php -r '<code>' <red-value> <green-value> <blue-value>.

Ingresso esadecimale, 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;  

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

Questo approccio richiederebbe 75 byte per l'ingresso RGB:
sostituirlo foreach($a=array_map...as$c)con 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));}

Sto cercando di capire come è possibile giocare a golf di più.

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

Produzione:

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

Utilizzare la libreria a virgola mobile di precisione singola. Crea una nuova funzione generica che accetta a. Impostare ssu subcurry con .1per dopo e jpiegare aconmax .

Mappare adividendo ogni elemento con j, trovando il minimo di quello e 1 per normalizzare NaN, quindi sottrarre 1 con s. Aggiungi 1-j/255alla fine di tale elenco.

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