RGB से Xterm कलर कन्वर्टर

Question

256-रंग Xterm- संगत टर्मिनल सामान्य 16 सिस्टम रंगों के शीर्ष पर 240 रंग जोड़ते हैं। रंग 16-231 लाल, हरे और नीले रंग के 6 स्तरों (0, 95, 135, 175, 215, 255) का उपयोग करते हैं और नीले रंग से क्रमबद्ध होते हैं। रंग 232-255 ग्रे के 24 स्तर (8 ... 238 10 के स्तर पर) हैं। मैं किस बारे में बात कर रहा हूं इसका एक बेहतर विचार प्राप्त करने के लिए, इस तालिका को देखें ।

चुनौती

आपका लक्ष्य एक प्रोग्राम या फ़ंक्शन बनाना है जो इनपुट, आरजीबी मानों के रूप में लेता है, और उस आरजीबी मूल्य के निकटतम Xterm रंग के साथ इसी संख्या को आउटपुट करता है। चूंकि 16 सिस्टम रंग (0-15 रंग) अक्सर अनुकूलन योग्य होते हैं, इसलिए आप उन्हें इस रूपांतरण से बाहर कर देंगे।

बेहतर रूप से परिभाषित करने के लिए कि "निकटतम" रंग क्या है, लाल, हरे और नीले घटकों के साथ मैनहट्टन दूरी का उपयोग करें । उदाहरण के लिए, rgb(10, 180, 90)20 इकाइयों rgb(0, 175, 95)(रंग 35) से दूर है क्योंकि abs(10 - 0) + abs(180 - 175) + abs(90 - 95) == 20। यदि इनपुट रंग समान रूप से दो या अधिक Xterm रंगों के बीच है, तो उच्चतम सूचकांक के साथ Xterm रंग का उत्पादन करें।

उदाहरण

 R   G   B     Xterm
  0   0   0 ==> 16
 95 135   0 ==> 64
255 255 255 ==> 231
238 238 238 ==> 255

 90 133 140 ==> 66
218 215 216 ==> 188
175 177 178 ==> 249

175   0 155 ==> 127
 75  75  75 ==> 239
 23  23  23 ==> 234
115 155 235 ==> 111

नियम

• मानक खामियों को मना किया जाता है
• आपके प्रोग्राम या फ़ंक्शन को किसी भी उचित प्रारूप में आरजीबी मान लेने की अनुमति है, जिसमें शामिल हैं:
  • लाल, हरे और नीले रंग के लिए अलग-अलग तर्क
  • एक सूची, टपल, शब्दकोश, या इसी तरह की
  • सीमांकित-पृथक स्ट्रिंग या स्टड
  • हेक्स रंग (जैसे #ff8000)
• आप मान सकते हैं कि सभी r, g, और b, मान 0 और 255 के बीच पूर्णांक होंगे।
• चूंकि 16 सिस्टम रंगों को मैपिंग से बाहर रखा जाना है, सभी आउटपुट 16 ... 255 की सीमा में होने चाहिए।

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

Answer 1

हास्केल , 132 बाइट्स

v=0:[95,135..255]
f c=snd$maximum[(-sum(abs<$>zipWith(-)c x),i)|(i,x)<-zip[16..]$[[r,g,b]|r<-v,g<-v,b<-v]++[[g,g,g]|g<-[8,18..238]]]

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

पूर्णांकों की सूची के रूप में इनपुट लेता है [red, green, blue]।

बहुत ही सीधा कार्यान्वयन। पहले मैं Xterm रंगों की एक सूची बनाता हूँ जिसका उपयोग हम एक साथ दो सूची समझ के साथ कर रहे हैं। जिनमें से पहला रंग ट्रिपल तिरछा करके 16-231 रंग संभालता है vजिसमें उन रंगों का उपयोग करने वाले मूल्य शामिल हैं। दूसरा केवल ग्रे मानों पर निर्भर करता है और उन्हें तीनों स्लॉट्स में डालता है। फिर मैं इसे ज़िप (16 से शुरू) के साथ सूचकांक करता हूं और मैनहट्टन दूरी (उपेक्षित) और उस सूचकांक के साथ एक जोड़ी बनाता हूं और अधिकतम लेता हूं। मैंने अधिकतम उपयोग किया क्योंकि हम सबसे बड़े सूचकांक पर टाई-ब्रेक कर रहे हैं और इस तरह से मुझे एक अतिरिक्त बचत होती है -।

Answer 2

रूबी , 280 180 166 164 155 बाइट्स

->c{d=0,95,135,175,215,255
a=(0..239).map{|n|n<216?[d[n/36],d[(n%36)/6],d[n%6]]:[n*10-2152]*3}.map{|t|t.zip(c).map{|a,b|(a-b).abs}.sum}
a.rindex(a.min)+16}

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

पूर्णांक की एक सरणी के रूप में इनपुट रंग लेने वाला एक लंबोदर।

मुझे अपेक्षा से अधिक Xterm रंग बनाने में अधिक परेशानी हुई! मैं उस क्षेत्र में शर्मनाक ढंग से शर्मिंदा होने के लिए तैयार हूं । मैंने एक प्रकार के संपीड़न के रूप में आधार रूपांतरण का उपयोग किया, लेकिन रूबी में ऐसा करने का एकमात्र तरीका मुझे पता है,Integer#to_s जिसके माध्यम से थोड़ा अजीब है।

-100 बाइट्स: समस्या को अधिक ध्यान से पढ़ें, और 16 सिस्टम रंगों ^ _ ^ को अनदेखा करें;

-14 बाइट्स: इसके बजाय हाथ आधार रूपांतरण का उपयोग करें .to_s(6)

-2 बाइट्स: सरणी घोषित करते समय वर्गाकार कोष्ठक छोड़ें

-9 बाइट्स: केवल एक के साथ एक्सटरम रंगों की सूची बनाएं map; यह एक प्लस चिन्ह और एक जोड़ी पार्न भी बचाता है।

->c{
  d=0,95,135,175,215,255                 # d is the set of possible RGB values
  a=(0..239).map{|n|                     # Create the array of Xterm triplets
    n<216 ? [d[n/36],d[(n%36)/6],d[n%6]] # Convert x from base 6 to base d, or
          : [n*10-2152]*3                #   create a uniform triplet
  }.map{|t|
    t.zip(c).map{|a,b|(a-b).abs}.sum     # Map from triplets to Manhattan distance
  }
  a.rindex(a.min) +                      # Find the last index of the lowest distance
  16                                     # Offset for the exluded system colors
}

Comments

BTW, आपको 16 सिस्टम रंगों में मैप करने की आवश्यकता नहीं है। शायद मुझे वर्णन में यह स्पष्ट करना चाहिए।

— बीफस्टर

ऊह, जो मुझे काफी मदद करेगा! मैं निश्चित रूप से याद किया कि मूल प्रश्न में शब्द।

— बेन्ज 2240

Answer 3

कोटलिन , 299 290 267 265 बाइट्स

(16..255).associate{it to if(it<232)(it-16).let{i->listOf(0,95,135,175,215,255).let{l->listOf(l[i/36],l[(i/6)%6],l[i%6])}}else(8..238 step 10).toList()[it-232].let{listOf(it,it,it)}}.minBy{(k,v)->(it.zip(v).map{(a,b)->kotlin.math.abs(a-b)}.sum()*256)+(256-k)}!!.key

सजा हुआ

(16..255).associate {
    it to if (it < 232) (it - 16).let { i ->
            listOf(0, 95, 135, 175, 215, 255).let { l ->
                listOf(
                        l[i / 36],
                        l[(i / 6) % 6],
                        l[i % 6])
            }
        } else (8..238 step 10).toList()[it - 232].let { listOf(it, it, it) }
}.minBy { (k, v) ->
    (it.zip(v).map { (a, b) -> kotlin.math.abs(a - b) }.sum() * 256) + (256 - k)
}!!.key

परीक्षा

data class Test(val r: Int, val g: Int, val b: Int, val out: Int)

val test = listOf(
        Test(0, 0, 0, 16),
        Test(95, 135, 0, 64),
        Test(255, 255, 255, 231),
        Test(238, 238, 238, 255),

        Test(90, 133, 140, 66),
        Test(218, 215, 216, 188),
        Test(175, 177, 178, 249),

        Test(175, 0, 155, 127),
        Test(75, 75, 75, 239),
        Test(23, 23, 23, 234),
        Test(115, 155, 235, 111)
)
fun z(it:List<Int>): Int =
(16..255).associate{it to if(it<232)(it-16).let{i->listOf(0,95,135,175,215,255).let{l->listOf(l[i/36],l[(i/6)%6],l[i%6])}}else(8..238 step 10).toList()[it-232].let{listOf(it,it,it)}}.minBy{(k,v)->(it.zip(v).map{(a,b)->kotlin.math.abs(a-b)}.sum()*256)+(256-k)}!!.key

fun main(args: Array<String>) {
    for (i in test) {
        val r = z(listOf(i.r, i.g, i.b))
        println("$i ${i.out} ==> $r")
    }
}

TIO

TryItOnline

Answer 4

बैच, 266 बाइट्स

@set/ax=15,m=999
@set s=for %%b in (0 95 135 175 215 255)do @
@%s:b=r%%s:b=g%%s%call:c %* %%r %%g %%b
@for /l %%g in (8,10,238)do @call:c %* %%g %%g %%g
@echo %n%
:c
@set/ax+=1,r=%4-%1,g=%5-%2,b=%6-%3
@set/ad=%r:-=%+%g:-=%+%b:-=%
@if %d% leq %m% set/an=x,m=d

Answer 5

स्टैक्स , 41 बाइट्स

¬ÿ▒ú╘Σt∙Æ9φ☻ùí&BQq═IÜH∩Å╧♥f⌠óH]╨⌡≤@■Q‼Hr¼

भागो और डिबग ऑनलाइन!

50 बाइट्स का ASCII संस्करण:

"4GOW_g"{52-5*m3|^24{A*vv]3*m+{;\{E:-m|+mc|m|IH16+

Answer 6

सी (जीसीसी), 202 192 157 150 (141 बग) 138 134 बाइट्स

l,m,t,i;a(c,x){x=abs(c-=i>215?i*10-2152:x*40+!!x*55);}f(r,g,b){for(i=l=240;i--;t=a(r,i/36)+a(g,i/6%6)+a(b,i%6),t<l?l=t,m=i:1);i=m+16;}

धन्यवाद @ceilingcat

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

Comments

समस्या को परीक्षणों द्वारा परिभाषित नहीं किया गया है (जो स्पष्ट रूप से उदाहरण के रूप में लेबल किए गए हैं), इसलिए कृपया इसके बजाय जोड़ा गया एक नया परीक्षण प्राप्त करें।

— टन हास्पेल

@ टॉन्होस्पेल मैंने अब बग को ठीक कर दिया और -3 बाइट्स काट दिए, लेकिन जवाब के लिए धन्यवाद

— प्रिंसपोल्का