23

आपको एक रंग का RGB मान दिया जाता है। आपका कार्य सरल है: ह्यू की गणना करने के लिए, सरलतम परिभाषा में।

उच्चतम, मध्यम और निम्नतम मान वाले चैनल X, Y, Z (जो या तो लाल, हरे या नीले) हैं और उनके मान x, y, z हैं। इस रंग का वर्ण (h (X) -h (Y)) * (1 + (xy) / (xz) / 2 + h (Y) है, जहां:

h(red) = 0 (or 360 if one of X or Y is blue)
h(green) = 120
h(blue) = 240

इनपुट में 0 से 255 तक 3 पूर्णांक होते हैं जो किसी भी सुसंगत क्रम में सभी समान नहीं होते हैं। आउटपुट फ्लोट हो सकता है, या पूर्णांक या तो ऊपर या नीचे गोल हो सकता है, जो लगातार नहीं होना चाहिए। यदि आउटपुट का पूर्णांक भाग 0 या 360 है, तो आप उनमें से कोई भी प्रिंट कर सकते हैं।

आप रंग अंतरिक्ष रूपांतरणों के लिए बिलिंस को नहीं बुला सकते हैं, जिसमें निहित रूपांतरण जैसे कि छवि में हेरफेर करना शामिल है।

यह कोड-गोल्फ है। सबसे छोटा कोड जीतता है।

उदाहरण

Input:  0 182 255
Output: 197 (or 198)

Input:  127 247 103
Output: 110

Input:  0 0 1
Output: 240

Input:  255 165 245
Output: 307 (or 306)

संपादित करें

आपको सटीक सूत्र का पालन नहीं करना है, लेकिन केवल उपरोक्त सूत्र के समान परिणाम देना है। मैं भी कुछ जवाब देखना चाहता हूँ सूत्र ही गोल्फ।

code-golf

— jimmy23013
स्रोत

क्या हमें पहले sRGB से लीनियर स्केल में बदलना चाहिए? मुझे लगता है कि हमें करना चाहिए, लेकिन किसी को भी ऐसा नहीं लगता है।

— जॉन ड्वोरक

@JDDvorak कार्य को सरलतम परिभाषा में, गणना करना है । इस मामले में, "सरलतम" का मतलब है कि आपको यह मान लेना चाहिए कि इनपुट पहले से ही सही पैमाने पर है, और प्रश्न या किसी भी चीज़ में दिए गए सटीक सूत्र का उपयोग करें जो समान परिणाम देता है।

— jimmy23013

लेकिन ... 24 bpp का मतलब आमतौर पर sRGB होता है। यदि नहीं, तो प्रारूप विनिर्देश (आप) को अन्यथा निर्दिष्ट करना चाहिए।

— जॉन ड्वोरक

@JDDvorak आपको RGB और ह्यू के लिए इस परिभाषा का उपयोग करना चाहिए ।

— jimmy23013

9

यह कहना होगा: ह्यूहुएहुए।

— TheDoctor

6

पायथ, 27 बाइट्स

*60%+c-Ft.<QJxQKeSQ-KhSQyJ6

प्रदर्शन। दोहन परीक्षण।

फोमुला विकिपीडिया से लिया गया है ।

अनिवार्य रूप से, चरण हैं:

.<QJxQKeSQ: सूची के सामने सबसे बड़ा मूल्य रोस्ट करें।
-Ft: अन्य दो मूल्यों के अंतर को लें।
-KhSQ: अधिकतम मूल्य से न्यूनतम मूल्य घटाएं।
c: 2 को 3 से भाग दें।
+ ... yJ सूची में अधिकतम मूल्य के दो बार सूचकांक जोड़ें (0 यदि आर, 2 यदि जी, 4 यदि बी)।
% ... 6: मॉड 6, नकारात्मक के साथ मुद्दों को ठीक करने के लिए।
*60: डिग्री में बदलने के लिए 60 से गुणा करें और प्रिंट करें।

— isaacg
स्रोत

9

सी #, 188 210 206 197 191 बाइट्स

int H(int r,int g,int b){int[]a={r,g,b};System.Array.Sort(a);int x=a[2],y=a[1],c=x==g?1:(x==b?2:(y==b?3:0)),d=y==g?1:(y==b?2:(x==b?3:0));return(int)((c-d)*120*(1+(x-y)*1D/(x-a[0]))/2+d*120);}

4 बाइट बचाने के लिए और 15 बचाने के लिए SLuck49 के लिए सोक को धन्यवाद!

— ProgramFOX
स्रोत

जैसा कि आप केवल zआउटपुट गणना में एक बार उपयोग करते हैं , और आप पूर्ववर्ती गणना में इसका उपयोग नहीं करते हैं, आप चर के साथ दूर करते हैं और आउटपुट को बदलकर return(int)((c-d)*(1+(x-y)/(double)(x-a[0]))/2+d);, आपको 4 बाइट्स बचाते हैं।

— Sok

आप 120 में से cऔर dअसाइनमेंट को इस तरह से लौटा सकते हैं c=x==g?1:(x==b?2:(y==b?3:0)),d=y==g?1:(y==b?2:(x==b?3:0))और फिर return(int)((c-d)*120*(1+(x-y)/(double)(x-a[0]))/2+d*120);4 बाइट बचा सकते हैं।

— SLuck49

इसके अलावा क्या आपको वास्तव में कलाकारों की जरूरत है double? यदि आप करते हैं तो आप इसके बजाय (x-a[0])*1Dएक और 5 बाइट्स को बचाने के लिए उपयोग कर सकते हैं ।

— SLuck49

@ SLuck49 धन्यवाद! हां, मुझे वास्तव में कलाकारों की आवश्यकता है, यह अन्यथा गलत परिणाम देता है, लेकिन यह *1Dगुणा एक अच्छी चाल है!

— ProgramFOX

इसके अलावा (सिर्फ गौर किया) आप एक साथ System.Array6 बाइट्स के लिए पूरी तरह से क्वालीफाई करके सभी को एक साथ छोड़ सकते हैं ।

— SLuck49

8

Pyth, 41 55 53 51 बाइट्स

A.)JohN,VQ*L120?qeQhSQ3j312T+/*-HKeeJhc-GheJ-GhhJ2K

फॉर्म में इनपुट अपेक्षित है r,g,b। यहाँ एक स्पष्टीकरण है:

                                                        Implicit: Q=eval(input()), evaluates to (r,g,b)
               ?qeQhSQ                                  Is b the smallest?
                      3j312T                            Choose [0,1,2] or [3,1,2] based on above
          *L120                                         Convert to [0,120,240] or [360,120,240]
       ,VQ                                              Pair -> [[r,0/360],[g,120],[b,240]]
   JohN                                                 Order by 1st element in each pair, store in J
A.)J                                                    Pop biggest from J, set G = x, H = h(X)
                                                        Output calculation:
                                       -GheJ                x - y
                                            -GhhJ           x - z
                                     hc                     Divide and increment
                                 KeeJ                       Set K = h(Y)
                              *-HK                          Multiply by (h(X) - h(Y))
                             /                   2          Integer division by 2
                            +                     K         Add h(Y)

4 बाइट्स सहेजे, @Jakube और @isaacg की बदौलत

— सोक
स्रोत

@ jimmy23013 फिक्स्ड, अतिरिक्त परीक्षण मामले के लिए धन्यवाद

— सोक

1

गोल्फ की एक जोड़ी: m*120d-> *L120, एक और बाइट को बचाने के eeJलिए Kइनलाइन को बचाएं।

— isaacg

@ आईआईएसएसीजी मुझे नहीं पता था कि Lऑपरेटर ने एक इंट पर स्वचालित रूप से एक रेंज उत्पन्न की है, हर दिन एक शकुल दिन है जो ऐसा लगता है: ओ) धन्यवाद!

— सोक

8

जावास्क्रिप्ट (ईएस 6), 145 115 108 100 97 90 बाइट्स

लौटता है तैरता है। उपयोग करने के लिए एक फ़ंक्शन को असाइन करें।

(r,g,b)=>([x,y,z]=[r,g,b].sort((a,b)=>b-a),m=x-z,(x-r?x-g?r-g+4*m:b-r+2*m:g-b+6*m)/m%6*60)

30 बाइट्स को एकल टर्नरी ऑपरेटर अनुक्रम में सब कुछ शामिल करके और 0-360 तक सामान्य करने के लिए अंत तक इंतजार किया।

और भी बाइट्स बचाने के लिए edc65, वासु अडारी, और ETHproductions के लिए धन्यवाद।

परीक्षण के साथ JSFiddle । फ़ायरफ़ॉक्स में प्रयास करें।

यदि फ़ंक्शन को हटाने की घोषणा h=कानूनी नहीं है, तो 2 बाइट्स जोड़ें।

— DankMemes
स्रोत

आप 'var' और कुछ बाइट्स निकाल सकते हैं।

— वासु अडारी

ES6Field को किसी कारण के लिए var घोषणापत्र की आवश्यकता है और मुझे एहसास नहीं हुआ कि जब तक मैंने फ़ायरफ़ॉक्स में ES6 की कोशिश नहीं की, तब तक यह आवश्यक नहीं था

— DankMemes

1

आप कोष्ठक के साथ घुंघराले ब्रेसिज़ की जगह, अल्पविराम के साथ अर्धविराम और हटाकर 6 बाइट्स बचा सकते हैं return। मैं समारोह घोषणा को हटाने विश्वास ( h=), भी कानूनी है करने के लिए 100 के कुल नीचे ला

— ETHproductions

यह जुनूनी हो सकता है (तब फिर से, सभी अच्छे गोल्फर नहीं हैं?)), लेकिन %6)*60दूसरी तरफ कोष्ठक और उसके साथी से छुटकारा पाकर आप दो और बाइट्स बचा सकते हैं । इसके अलावा, इसके अलावा जानवर बल का उपयोग करना (अंत में 6 जोड़ने के बजाय) वास्तव में आपके वर्तमान सेटअप पर एक बाइट बचाएगा। (((x==r?(g-b)/m:x==g?2+(b-r)/m:4+(r-g)/m)+6)%6)*60बन जाएगा (x==r?6+(g-b)/m:x==g?8+(b-r)/m:10+(r-g)/m)%6*60।

— ETHproductions

1

सॉर्ट के लिए +1, बहुत चालाक, यह 90 (या 92) है(r,g,b)=>([m,_,M]=[r,g,b].sort((a,b)=>a-b),C=M-m,(M-r?M-g?r-g+4*C:b-r+2*C:g-b+6*C)/C%6*60)

— edc65

6

ऑक्टेव, 65 60 50 बाइट्स

संपादित करें: pawel.boczarski के लिए धन्यवाद 10 बाइट्स सहेजे गए

एक अनुमानित समाधान ...

@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)

परीक्षण चालन

@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)
ans([0   182   255])
ans =  196.14

@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)
ans([127   247   103])
ans =  111.05

@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)
ans([0   0   1])
ans =  240.00

@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)
ans([255   165   245])
ans =  305.82

ऑक्टेव, 107 बाइट्स

मेरा मूल (सटीक-ईश) समाधान ...

कोड:

function H=r(c) [b,i]=sort(c);h=60*[6*(i(1)~=3),2,4](i);H=(h(3)-h(2))*(1+(b(3)-b(2))/(b(3)-b(1)))/2+h(2);

व्याख्या की:

function H=r(c)
   [b,i]=sort(c);
   h=60*[6*(i(1)~=3),2,4](i);
   H=(h(3)-h(2))*(1+(b(3)-b(2))/(b(3)-b(1)))/2+h(2);

यह फ़ंक्शन इनपुट के रूप में R, G, B मान युक्त एक वेक्टर लेता है cऔर आरोही क्रम में इनपुट को सॉर्ट करता है

b इसमें क्रमबद्ध मान शामिल हैं [z, y, x]
i b में प्रत्येक मान से जुड़ा RGB विमान शामिल है

सदिश hमानों से आबाद है

60*[6, 2, 4]= [360, 120, 240](लेकिन 3 बाइट्स कम)
जब तक निम्नतम मूल्य ब्लू ( i(1) == 3) में नहीं होता है, उस स्थिति में पहला ह्यू मूल्य शून्य हो जाता है
फिर क्रम में (i)पुनर्व्यवस्थित करने के लिए उपयोग करेंh[h(Z), h(Y), h(X)]

वहाँ से यह सूत्र का सिर्फ एक सीधा प्रतिलेखन है। आप इसे यहाँ आज़मा सकते हैं ।

— बीकर
स्रोत

संकेत: अधिक बाइट्स को निचोड़ने के लिए अनाम फ़ंक्शन नोटेशन का उपयोग करें: कीवर्ड के @(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360)साथ परिभाषा की तुलना में दस बाइट्स कम है function।

— pawel.boczarski

@ pawel.boczarski मैं सोच रहा था कि क्या मैं फ़ंक्शन हेडर के साथ पूरी तरह से कर सकता हूं, लेकिन मुझे नहीं पता कि क्या यह वैध है। लेकिन टिप के लिए धन्यवाद! : D

— बीकर

@ pawel.boczarski इस पर पीछे मुड़कर देखें, मुझे अभी भी r=अनाम फ़ंक्शन से पहले इसे कॉल करने की आवश्यकता है, है ना?

— बीकर

ऐसे कई समाधान हैं जहां अनाम फ़ंक्शन पोस्ट किए गए हैं। इसके अलावा, आप इस तरह से भी परिभाषित फ़ंक्शन को कॉल कर सकते हैं: (@(c)mod(atan2d(.866*c*[0;1;-1],c*[2;-1;-1]/2),360))([127 247 103])या तर्क देते हैं कि ansअनाम फ़ंक्शन के परिभाषित होने के बाद आप चर का सही उपयोग कर सकते हैं , ताकि फ़ंक्शन की परिभाषा पूरी होने के लिए असाइनमेंट आवश्यक नहीं है। एक चुनौती ( codegolf.stackexchange.com/questions/54945 ) में मौजूदा मैटलैब लाइब्रेरी फ़ंक्शन का एक हैंडल पूर्ण समाधान के रूप में पोस्ट किया गया था।

— pawel.boczarski

@ pawel.boczarski वाह, यह ... बस ... दुष्ट: DI को पता होना चाहिए कि लुइस इसमें शामिल होंगे। मैं मूल कोड में वापस आऊंगा और ansनमूने में उपयोग करूंगा । एक बार फिर धन्यवाद!

— बीकर

5

पायथ, ५५

मुझे पता है कि @ सोक का जवाब मेरी धड़कन है, लेकिन जब से मैंने उसे / उसके पोस्ट करने के बाद मेरा काम पूरा किया, मुझे लगा कि मैं अभी भी पोस्ट करूंगा। यह मेरी पहली बार पाइथ का उपयोग कर रहा था इसलिए मुझे यकीन है कि मैंने कुछ स्पष्ट गलतियाँ की हैं।

DlZK*120ZRKJSQFNJ=Y+YxQN)=kl@Y1+k/*-leYk+1c-eJ@J1-eJhJ2

इनपुट होने की उम्मीद है r, g, b। आप इसे यहाँ आज़मा सकते हैं ।

— Rhyzomatic
स्रोत

के लिए काम नहीं करता है 255,165,245।

— jimmy23013

5

पॉवरशेल, 232 226 222 161 बाइट्स

_{पिछले संस्करणों के लिए संशोधन इतिहास देखें}

$z,$y,$x=($r,$g,$b=$args)|sort
$c=((2,(0,3)[$y-eq$b])[$x-ne$b],1)[$x-eq$g]
$d=((2,(0,3)[$x-eq$b])[$y-ne$b],1)[$y-eq$g]
(($c-$d)*120*(1+($x-$y)/($x-$z))/2+$d*120)

हू बॉय, देखते हैं कि क्या मैं इसके माध्यम से चल सकता हूं। के बाद से \nमायने रखता है के रूप में ही ;मैं स्पष्टता के लिए में पंक्ति विराम छोड़ दिया है।

पहली पंक्ति तीन के रूप में इनपुट लेती है $args और उन्हें स्टोर करती है $r, $g, $b। हम वास्तव में केवल $bबाद में उपयोग करने जा रहे हैं , लेकिन हमें इन तीनों की आवश्यकता है ताकि |sortकाम उचित रूप से हो सके। यह $z, $y, $xइनपुट तर्कों का सबसे छोटा-से-सबसे बड़ा बनाता है।

अगली दो पंक्तियाँ सेटअप $cऔर $dसंख्याओं का उपयोग करके एक-एक- ए -सरणी कॉलों को उचित रूप से सेट करने के लिए। , में बाहर से कार्य करता है, तो $xहै -eqUAL के लिए $g(यानी, हरी सबसे बड़ा था), हम सेट $c=1... वरना, अगर $xहै -nOT equal के लिए $b(यानी, नीला नहीं सबसे बड़ा था)$c है या तो 0या 3अगर नीले दूसरा सबसे बड़ा था निर्भर करता है ... वरना, $c=2। इसी तरह के तर्क सेट $d।

हम फिर निम्न के साथ आउटपुट की गणना और प्रिंट करते हैं, जो कि थोड़े से गोल्फ को चुनौती देने से सिर्फ एल्गोरिदम है।

(($c-$d)*120*(1+($x-$y)/($x-$z))/2+$d*120)

— AdmBorkBork
स्रोत

1

मैं PowerShell को नहीं जानता, इसलिए मुझे सही करें अगर मैं गलत हूं ... आप $zगणना करते समय उपयोग नहीं करते हैं $cया $d, और आप इसे केवल एक बार आउटपुट गणना में उपयोग करते हैं, तो क्या आप $zपूरी तरह से छुटकारा पा सकते हैं और इसे बदल सकते हैं $a[0]?

— सोक

4

रूबी, 117 96 94 बाइट्स

कोड:

h=->r,g,b{z,y,x=[r,g,b].sort;v=x-z.to_f;({r=>(g-b)/v,g=>2+(b-r)/v,b=>4+(r-g)/v}[x]%6*60).to_i}

()आर, जी, बी चर को हटाकर और उपयोग करके 21 बाइट्स बचाए।
नकारात्मक मान को परिवर्तित करने के लिए 6 का मापांक लेना और इसे 2 बाइट्स से बचाने वाली डिग्रियों में परिवर्तित करने के लिए 60 से गुणा करना।

उदाहरण:

irb(main):274:0> h.call 0,182,255
=> 197
irb(main):275:0> h.call 127,247,103
=> 110
irb(main):276:0> h.call 0,0,1
=> 240
irb(main):277:0> h.call 255,165,245
=> 306

— वासु अडारी
स्रोत

3

एसडब्ल्यूआई-प्रोलॉग, 133 बाइट्स

a(L,H):-L=[R,G,B],max_list(L,X),min_list(L,Y),member(X:I:J:U,[R:G:B:0,G:B:R:2,B:R:G:4]),Z is 60*(U+(I-J)/(X-Y)),(Z<0,H is Z+360;H=Z).

उदाहरण: a([255,165,245],Hue).आउटपुटHue = 306.666666666666 .

यह निम्न सूत्र का उपयोग करता है:

Max = max(R,G,B), Min = min(R,G,B)।
तो Max = R, U = 0। वरना अगर Max = G, U = 2। एल्स U = 4।
तो Max = R, I = Gऔर J = B। और अगर Max = G, I = Bऔर J = R। वरना I = Rऔर J = G।
Z = U + (I - J)/(Max - Min)
HueZया तो है या Z + 360अगर है Z < 0।

— Fatalize
स्रोत

गोलाई वैकल्पिक है।

— jimmy23013

@ jimmy23013 अपडेट किया गया, धन्यवाद।

— घातक

3

पर्ल 5, 138 132 119 बाइट्स

कोड:

($m,$c,$M)=sort@A=($R,$G,$B)=@ARGV;print 60*(6+$M>$m?($G>$c?$B-$R:$B>$c?$R-$G:$G-$B)/($M-$m)+($G>$c?2:$B>$c?4:0):0)%360

टिप्पणियों:

निश्चित रूप से पर्ल सभी पायथोर्स गोल्फिंग के साथ ऐसी चुनौती नहीं जीत सकते। लेकिन मुझे आश्चर्य है कि क्या यह केवल 1 गणना कदम के साथ करना संभव था। न्यूक्लियस से काम करने के लिए धन्यवाद। :)

परीक्षा:

$ perl hue.pl 0 182 255
197
$ perl hue.pl 127 247 103
110
$ perl hue.pl 0 0 1
240
$ perl hue.pl 255 165 245
307

— LukStorms
स्रोत

अधिकतम बाइट्स के बजाय मध्य मूल्य की तुलना करना। (== बनाम>)

— LukStorms

1

सी ++ 276 बाइट्स

#include <iostream>
int H(int r,int g,int b){int m,n=120,o=240,l=r>g?r>b?g>b?m=r-b,o=n,n=-n,r-g:m=r-g,r-b:m=b-g,o+=n,n=-n,b-r:g>b?r>b?(m=g-b,o=0,g-r):m=g-r,n=-n,g-b:(m=b-r,o-=n,b-g);return (int)n*((float)l/m+1)/2+o;}int main(){int r,g,b;std::cin>>r>>g>>b;std::cout<<H(r,g,b);}

— EvgeniyZh
स्रोत

एक संकेत: आप Hजवाब में अकेले फ़ंक्शन छोड़ सकते हैं, क्योंकि कोड-गोल्फ में एक स्टैंडअलोन फ़ंक्शन एक वैध जवाब है, एक पूर्ण कार्यक्रम के बराबर, मेटा चर्चा: मेटा acodegolf.stackexchange.com/questions/2419/… । यह आपके उत्तर को और अधिक प्रतिस्पर्धात्मक बना देगा (आपके मामले में 100 बाइट्स को बचा लेगा)। परीक्षण को सरल बनाने के लिए आपको अभी भी कार्यक्रम के "पूर्ण" संस्करण को छोड़ने के लिए प्रोत्साहित किया जाता है।

— pawel.boczarski

दूसरा परीक्षण मामला इसके बजाय 127 247 103अमान्य मान प्राप्त -120करता है 110।

— pawel.boczarski

1

आर, 125 बाइट्स

बीकर के ऑक्टेव समाधान के समान। फ्लोटिंग पॉइंट आउटपुट।

कोड:

h=function(x){
  o=seq(3)[order(-x)];
  y=c(60*c(6*(o[3]!=3),2,4)[o],x[o]);
  return((y[1]-y[2])*(1+(y[4]-y[5])/(y[4]-y[6]))/2+y[2]);
}

उदाहरण:

> h(c(0,182,255))
[1] 197.1765
> h(c(127,247,103))
[1] 110
> h(c(0,0,1))
[1] 240
> h(c(255,165,245))
[1] 306.6667

— popojan
स्रोत

1

पायथन, 154 बाइट्स

def h(c):r=c[:];c.sort();c=c[::-1];x,y,z=c;i,j=[120if n==r[1]else 240if n==r[2]else 0if z==r[2]else 360for n in[x,y]];print ((i-j)*(1+(x-y+0.)/(x-z))/2)+j

मूल्यों की एक सूची को स्वीकार करता है। यकीन नहीं तो आगे भी टूट सकता है। यहाँ यह अपुष्ट है:

def hue(color):
 rgb=color[:]  # copy list
 color.sort()  # sort list
 color=color[::-1]  # reverse sort
 x,y,z=color   # pull out x,y,z

 # The line 
 #   i,j=[120if n==r[1]else 240if n==r[2]else 0if z==r[2]else 360for n in[x,y]]
 # is basically the following, twice, once for x/hx and the second time for y/hy

 if x==rgb[1]: # if x is green
  hx = 120
 else:
  if x==rgb[2]: # if x is blue
   hx = 240
  else:
   if z==rgb[2]: # if z is blue and x is red
    hx = 0
   else:       # if x is red and y is blue
    hx = 1

 print ((hx-hy)*(1+(x-y+0.)/(x-z))/2)+hy  # calculate, print

— Zaxvo
स्रोत

0

जावास्क्रिप्ट 108

वैकल्पिक विधि।

function H(r,g,b){a=[r,g,b].sort(),M=a[2],c=M-a[0],h=M==r?(g-b)/c%6:M==g?(b-r)/c+2:(r-g)/c+4
return h*60|0;}

जावास्क्रिप्ट 194

उदाहरण विधि का उपयोग करना।

Array.prototype.i=[].indexOf
function H(r,g,b,a){a=[r,g,b].sort(),i=[a.i(r),a.i(g),a.i(b)],x=[i[2]?360:0,120,240],hx=x[i.i(2)]|0,hy=x[i.i(1)]|0
return (hx-hy)*(1+(a[2]-a[1])/(a[2]-a[0]))/2+hy|0}

var input = document.getElementById("input").innerHTML;
var output = document.getElementById("output");
var html = "";

input.replace(/(\d+)\,(\d+)\,(\d+)/g, function(m, r, g, b) {
  html += H(r, g, b) + "\n";
});

output.innerHTML = html;

<pre id="input">
0,182,255
127,247,103
0,0,1
255,165,245
</pre>

<pre id="output">

</pre>

स्निपेट का विस्तार करें

— wolfhammer
स्रोत

एक रंग का रंग

उदाहरण

संपादित करें

पायथ, 27 बाइट्स

सी #, 188 210 206 197 191 बाइट्स

Pyth, 41 55 53 51 बाइट्स

जावास्क्रिप्ट (ईएस 6), 145 115 108 100 97 90 बाइट्स

ऑक्टेव, 65 60 50 बाइट्स

संपादित करें: pawel.boczarski के लिए धन्यवाद 10 बाइट्स सहेजे गए

एक अनुमानित समाधान ...

परीक्षण चालन

ऑक्टेव, 107 बाइट्स

मेरा मूल (सटीक-ईश) समाधान ...

कोड:

व्याख्या की:

पायथ, ५५

पॉवरशेल, 232 226 222 161 बाइट्स

रूबी, 117 96 94 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 133 बाइट्स

पर्ल 5, 138 132 119 बाइट्स

कोड:

टिप्पणियों:

परीक्षा:

सी ++ 276 बाइट्स

आर, 125 बाइट्स

कोड:

उदाहरण:

पायथन, 154 बाइट्स

जावास्क्रिप्ट 108