सीएमवाइके मूल्यों को आरजीबी में बदलें

9

सीएमवाईके में कलर कोड को देखते हुए, इसे RGB वैल्यू में बदलें।

इनपुट:
अंतरिक्ष द्वारा अलग किए गए 4 पूर्णांक (0-100 से लेकर) की स्ट्रिंग 

86 86 0 43
28 14 0 6
0 41 73 4

आउटपुट: 

#141592
#ABCDEF
#F49043

सबसे छोटा कोड जीतता है!

सुझाव: सीएमवाइके को आरजीबी में परिवर्तित करने के लिए आप सूत्र का उपयोग कर सकते हैं जैसे: 

Red   = 255 x (1 - Cyan/100)    x (1 - Black/100)   
Green = 255 x (1 - Magenta/100) x (1 - Black/100)   
Blue  = 255 x (1 - Yellow/100)  x (1 - Black/100)

और #RRGGBBप्रारूप में मूल्य प्राप्त करने के लिए इन तीन चर का उपयोग करें

code-golf  conversion  color 
— क्या मै था
स्रोत
1
हम ले जा सकते हैं CMYKसे दशमलव के रूप में मूल्यों 0के लिए 1या यह करने के लिए आवश्यक है 0करने के लिए 100?
— हाइपरनेत्रिनो
1
इसके अलावा, क्या हम एक या एक बार में कई CMYK कोड इनपुट करने और इसे परिवर्तित करने वाले हैं?
— हाइपरनेत्रिनो
7
क्या हम इनपुट को संख्याओं की सूची के रूप में ले सकते हैं या क्या इसे एक सीमांकित स्ट्रिंग होना चाहिए?
— व्यवसाय बिल्ली
7
आपके द्वारा प्रदान किया गया इनपुट / आउटपुट सूत्र से मेल नहीं खाता है, हमें भी गोलाई को कैसे संभालना चाहिए?
— रॉड
2
@Rod यह थोड़ा अस्पष्ट है कि फ़्लोटिंग पॉइंट अशुद्धि को कैसे नियंत्रित किया जाना चाहिए।
— एर्ग आउटफोलर जूल

जवाबों:

2

जेली , 24 बाइट्स

ḲV÷ȷ2ạ1×Ṫ$×255ḞṃØHṙ1¤ṭ”#

एक पूर्ण कार्यक्रम जो परिणाम प्रिंट करता है।

इसे ऑनलाइन आज़माएं!

नोट: फर्श के बजाय गोलाई कोड के दो बाइट्स डालने से इस्तेमाल किया जा सकता +.के बीच 255और Ḟ।

कैसे?

ḲV÷ȷ2ạ1×Ṫ$×255ḞṃØHṙ1¤ṭ”# - Main link: list of character, s
Ḳ                        - split at spaces (makes a list of lists of characters)
 V                       - evaluate as Jelly code (makes a list of the decimal numbers)
   ȷ2                    - literal 100
  ÷                      - divide (vectorises to yield [C/100, M/100, Y/100, K/100])
     ạ1                  - absolute difference with 1 -> [1-(C/100),...]
         $               - last two links as a monad:
        Ṫ                -   tail (this is 1-(K/100))
       ×                 -   multiply (vectorises across the other three)
          ×255           - multiply by 255 (vectorises)
              Ḟ          - floor to the nearest integer
                    ¤    - nilad followed by link(s) as a nilad:
                ØH       -   hex-digit yield = "0123456789ABCDEF"
                  ṙ1     -   rotate left by 1 -> "123456789ABCDEF0"
               ṃ         - base decompress (use those as the digits for base length (16))
                      ”# - literal character '#'
                     ṭ   - tack
                         - implicit print
— जोनाथन एलन
स्रोत
गोल करने का एक और तरीका ... के _.Ċबजाय होगा +.Ḟ... लेकिन बाद वाला शायद अधिक व्यापक रूप से उपयोग किया जाता है।
— आउटगोल्फ जूल
2

रेटिना , 103 बाइट्स

\d+
$*1;100$*
(1*);\1

1(?=.* (1*))|1
$1
1
51$*
(1{32000})*(1{2000})*1*.
;$#1;$#2
T`d`L`1\d
;B\B|;

^
#

इसे ऑनलाइन आज़माएं! नोट: यह कोड बहुत धीमा है, इसलिए कृपया डेनिस के सर्वर को हथौड़ा न दें। स्पष्टीकरण:

\d+
$*1;100$*
(1*);\1

प्रत्येक संख्या को unary में बदलें और 100 से घटाएं।

1(?=.* (1*))|1
$1

सभी संख्याओं को अंतिम संख्या से गुणा करें, जिन्हें हटा दिया गया है।

1
51$*

51 से गुणा करें, ताकि एक बार 2000 से विभाजित होने के बाद, हम 100 * 100 * 51 / 2000 = 255इच्छानुसार प्राप्त करें ।

(1{32000})*(1{2000})*1*.
;$#1;$#2

32000 से विभाजित करें और 2000 तक फर्श शेष को विभाजित करें, इस प्रकार आधार 16 मानों की एक जोड़ी का निर्माण होता है, हालांकि दुख की बात है कि अभी भी आधार 10 में लिखा गया है।

T`d`L`1\d
;B\B|;

बेस 10 से बेस 16 में कन्वर्ट करें।

^
#

अग्रणी डालें #।

— नील
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 106 बाइट्स

f=
(s,z=s.split` `,k=z.pop())=>'#'+z.map(x=>('0'+(.0255*(100-x)*(100-k)+.5|0).toString(16)).slice(-2)).join``
<input id=i value="28 14 0 6"/><button onclick="o.innerHTML=f(i.value)"/>Go</button>
<pre id=o></pre>
स्निपेट का विस्तार करें

— nderscore
स्रोत
2

C ++ (gcc) , 169 166 बाइट्स

#import<iostream>
#import<iomanip>
#define F(x)int(.0255*(100-x)*(100-k))
int main(){
int c,m,y,k;
std::cin>>c>>m>>y>>k;
std::cout<<"#"<<std::hex<<F(c)<<F(m)<<F(y);
}

इसे ऑनलाइन आज़माएं!

अनुकूलित सूत्र का उपयोग करना। जोड़ा गया +.5CMYK = 0 0 0 0RGB को सही =0xffffff जो आवश्यक नहीं है।

— कार्ल नेफ
स्रोत
1

पायथन 3 , 114 110 108 106 104 बाइट्स

  • @xnor ने 4 बाइट्स बचाए: अनावश्यक कोड हटा दिया
  • @rod ने 2 बाइट्स बचाए: छोटा फॉर्मूला
  • बचाया 2 + 2 बाइट्स: के range[3]रूप में [0,1,2], अवांछित []हटा दिया
n=input().split()
print('#'+''.join(hex(int(.0255*(100-int(n[i]))*(100-int(n[3]))))[2:]for i in[0,1,2]))

इसे ऑनलाइन आज़माएं!

— officialaimm
स्रोत
1

जावास्क्रिप्ट, 104 बाइट्स

s=>"#"+[0,1,2].map(n=>("0"+((255-2.55*s[n])*(1-s[3]/100)|0).toString(16)).slice(-2),s=s.split` `).join``

उदाहरण कोड स्निपेट:

f=

s=>"#"+[0,1,2].map(n=>("0"+((255-2.55*s[n])*(1-s[3]/100)|0).toString(16)).slice(-2),s=s.split` `).join``

console.log(f("86 86 0 43"))
console.log(f("28 14 0 6"))
console.log(f("0 41 73 4"))
स्निपेट का विस्तार करें

— हरमन एल
स्रोत
0

क्यू / केडीबी +, 55 बाइट्स

समाधान:

"#",raze{(last($)0x0 vs)each"h"$.0255*x[3]*x 0 1 2}100-

उदाहरण:

q)"#",raze{(last($)0x0 vs)each"h"$.0255*x[3]*x 0 1 2}100-86 86 0 43
"#141491"
q)"#",raze{(last($)0x0 vs)each"h"$.0255*x[3]*x 0 1 2}100-28 14 0 6
"#adcef0"
q)"#",raze{(last($)0x0 vs)each"h"$.0255*x[3]*x 0 1 2}100-0 41 73 4
"#f59042"

स्पष्टीकरण:

बहुत सीधा, 0.0255अन्य समाधान से चाल चुरा लिया (धन्यवाद!)। मूल्यांकन दाएं से बाएं किया जाता है।

"#",raze {(last string 0x0 vs) each "h"$ .0255 * a[3] * a 0 1 2}100- / ungolfed
         {                                                     }     / lambda function
                                                                100- / subtract from 100 (vector)
                                                        a 0 1 2      / index into a at 0, 1 and 2 (CMY)
                                                 a[3]                / index into at at 3 (K)
                                                      *              / multiply together
                                         .0255 *                     / multiply by 0.255
                                    "h"$                             / cast to shorts
          (                  ) each                                  / perform stuff in brackets on each list item
                       0x0 vs                                        / converts to hex, 1 -> 0x0001
                string                                               / cast to string, 0x0001 -> ["00", "01"]
           last                                                      / take the last one, "01"
    raze                                                             / join strings together
"#",                                                                 / prepend the hash

टिप्पणियाँ:

डिफ़ॉल्ट रूप से राउंड नंबर, (_)शॉर्ट करने के लिए कास्टिंग करने से पहले 3 बाइट फ़्लोर पर खर्च होंगे ।

— streetster
स्रोत
0

05AB1E , 18 बाइट्स

$#т/-¤s¨*255*hJ'#ì

इसे ऑनलाइन आज़माएं!

-1 कलसवरस को धन्यवाद ।

फ्लोटिंग-पॉइंट अशुद्धि है, इसलिए परिणाम एक-से-एक हो सकते हैं, लेकिन प्रश्न में सूत्र का उपयोग किया जाता है।

— आउटगोल्फ को एरिक करें
स्रोत
आप एक बाइट को बचा सकते हैं: $जैसे ही है1¹
— कलसोवरस
@kalsowerus ठीक है, बिल्कुल नहीं, लेकिन यह इस मामले में काम करेगा ...
— एरिक द आउटग्राफर
अरे ठीक है .. मुझे यकीन नहीं है कि कौन सा इनपुट है inputजब कई होगा
— कलासॉवरस
0

फोरट्रान, 156 बाइट्स

PROGRAM C
REAL,DIMENSION(4,3)::d
READ(*,*)((d(i,j),i=1,4),j=1,3)
WRITE(*,'((A,3(Z2)))')(35,(INT(.0255*(100-d(i,j))*(100-d(4,j))),i=1,3),j=1,3)
END PROGRAM C
— Zongor
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.