मेरे रास्ते में रंग पढ़ें

16

रंगों का वर्णन करने के लिए विभिन्न प्रणालियों के अलग-अलग तरीके हैं, भले ही वे सभी RGBA अंतरिक्ष में बोल रहे हों। सीएसएस से परिचित एक फ्रंट-एंड डेवलपर पसंद कर सकता है #RRGGBBAA। लेकिन Android डेवलपर्स पसंद कर सकते हैं #AARRGGBB। एएएस फ़ाइल प्रारूप को संभालते समय, #AABBGGRRइसकी आवश्यकता होती है। वह भी भ्रामक है। शायद हमें एक ऐसे कार्यक्रम की आवश्यकता है जो विभिन्न रंगों के स्वरूपों के बीच परिवर्तित हो सके।

इनपुट:

इनपुट में 3 भाग हैं:

  • रंग बदलने के लिए (जैसे #1459AC0F), एक तेज संकेत के साथ शुरू होने वाली स्ट्रिंग #जिसके बाद 8 हेक्स अंक होते हैं।
  • दिए गए रंग का प्रारूप (जैसे #RRGGBBAA), #8 अक्षरों के साथ शुरू होने वाली एक स्ट्रिंग जो 4 अलग-अलग समूहों में गिरती है और प्रत्येक समूह RR/ GG/ BB/ में से एक है AA।
  • में बदलने का प्रारूप।

आउटपुट:

  • परिवर्तित प्रारूप में रंग का उत्पादन

परीक्षण के मामलों:

Color, OriginalFormat, TargetFormat -> Result
#12345678, #RRGGBBAA, #AARRGGBB -> #78123456
#1A2B3C4D, #RRGGBBAA, #AABBGGRR -> #4D3C2B1A
#DEADBEEF, #AARRGGBB, #GGBBAARR -> #BEEFDEAD

इनपुट / आउटपुट केस असंवेदनशील हैं। आप किसी भी स्वीकार्य तरीके से इनपुट / आउटपुट कर सकते हैं।

नियम:

यह प्रत्येक भाषा की जीत का कोड गोल्फ, सबसे छोटा (बाइट में) कोड है

code-golf  string  color 
— TSH
स्रोत
AARRGGBBवास्तव में सबसे अच्छा रंग प्रारूप है। अगर कोई चीज 24 बिट की उम्मीद करती है RRGGBBऔर आप इसे 32 बिट AARRGGBBदेते हैं, तो यह सिर्फ ऊपरी बाइट को नजरअंदाज कर सकता है और फिर भी काम कर सकता है।
— 12Me21
2
रंग DEADBEEF थोड़ा सा सामन-वाई दिखता है।
— मैजिक ऑक्टोपस Urn
1
मैं अब सालों से फ्रंट एंड वेब देव हूँ और मैंने आज तक कभी #RRGGBBAA के बारे में नहीं सुना, काश और अधिक ब्राउज़र इसका समर्थन करते।
— दासबेटो
@ 12Me21 और अगला प्रश्न यह है कि कौन सा अंत बेहतर है।
— tsh

जवाबों:

10

एपीएल (Dyalog यूनिकोड) , 6 बाइट्स SBCS

पूरा कार्यक्रम। मूल के लिए STDIN पर संकेत, फिर लक्ष्य, फिर रंग। प्रिंट्स STDOUT का परिणाम है।

⍞[⍞⍋⍞]

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

  ⍞ मूल के लिए संकेत

 ⍞⍋ टारगेट के लिए संकेत दें और इंडेक्स को मूल में खोजें जो मूल को टारगेट में बना देगा

⍞[… ] रंग के लिए संकेत और रंग प्राप्त करने के लिए उपरोक्त प्राप्त सूचकांकों का उपयोग करें

— एडम
स्रोत
8

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

@ बाइट के लिए 1 बाइट का धन्यवाद सहेजा गया

3 अलग मापदंडों के रूप में इनपुट लेता है (Color, From, To):।

(C,F,T)=>T.replace(/\w/g,(x,i)=>C[F.search(x)-~i%2])

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

— Arnauld
स्रोत
(C,F,T)=>T.replace(/\w/g,(x,i)=>C[F.search(x)-~i%2])एक बाइट बचाओ
— tsh
@tsh अच्छा लगा। ^ ^
— अरनुलड
5

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

ç▼☺↔kàÅJ

इसे चलाएं और डीबग करें

यह कार्यक्रम इस प्रारूप में इनपुट लेता है।

"{Color}" "{OriginalFormat}" "{TargetFormat}"

यहाँ एक ही कार्यक्रम के ungolfed अनपैक्ड संस्करण पर टिप्पणी की गई है।

u       drop duplicated characters from target format
{       for each character remaining in target format, map using block...
  [     duplicate original format at second position in stack
  |I    get all indices of target character in original format
  xs@   retrieve characters from those indices from the color string
m       perform map
        output implicitly when complete

इसको चलाओ

— पुनरावर्ती
स्रोत
4

रेटिना 0.8.2 , 33 बाइट्स

(.)(?<=(..).{7}\1\1.*)\1
$2
.*#
#

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

(.)(?<=(..).{7}\1\1.*)\1
$2

समान वर्णों की प्रत्येक जोड़ी के लिए, उस जोड़ी की एक और प्रति देखें, और फिर उससे पहले 9 वें और 8 वें वर्णों को देखें, और उन वर्णों के साथ जोड़ी को बदलें। यह केवल लक्ष्य प्रारूप में वर्णों के जोड़े के लिए संभव है, और उन्हें वांछित परिणाम से बदल देता है।

.*#
#

रंग और स्रोत प्रारूप हटाएं।

— नील
स्रोत
3

हास्केल , 108 104 100 94 87 बाइट्स

(s,(r@(x,y):z))!c|x==c=(s++[y],z)|(p,q)<-(s,z)!c=(p,r:q)
c%i=fst.(foldl(!)("",zip i c))

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

पुराना संस्करण

उपयोग करने के लिए एक छोटा रास्ता खोजने के लिए 6 बाइट्स को छोटा करने के लिए लाइकोनी के लिए धन्यवाद lookup!

f(Just x)=x
p('#':z)=p z
p(x:y:z)=[x,y]:p z
p e=[]
c!i=('#':).(f.(`lookup`zip(p i)(p c))=<<).p

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

स्पष्टीकरण:

  • pसमारोह "पार्स करता है" प्रमुख की अनदेखी करके एक स्ट्रिंग #2 वर्ण की और लौटने समूहों (सूची)।
  • (!)ऑपरेटर इनपुट के रूप में रंग और इनपुट प्रारूप लेता है और एक समारोह है कि उत्पादन प्रारूप एक पैरामीटर के रूप लेता है और परिवर्तित रंग रिटर्न देता है। यह पता चला कि पॉइंटफ्री संस्करण कम था, लेकिन मैंने अधिक पठनीय संस्करण के साथ शुरुआत की:

f c i o='#':concat[x#zip(p<$>[i,c])|x<-p o]

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

— क्रिस्टियन लुपस्कू
स्रोत
3

पर्ल 5 -p , 33 32 27 बाइट्स

आदेश में इनपुट दें: लक्ष्य, मूल, संख्या

#!/usr/bin/perl -p
s%.%$2x/(..)+$&(.){10}/g%eg

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

इनपुट में प्रत्येक वर्ण के लिए समान वर्ण को आगे के स्थानों की एक समान संख्या ज्ञात करें, फिर वहां से 10 और वर्णों को आगे ले जाएं और उस वर्ण को प्रतिस्थापन के रूप में लें। यदि आप इन कदमों को कुछ नहीं द्वारा प्रतिस्थापित कर सकते हैं।

    +--even-+----10---+   
    |       |         |
#AARRGGBB #RRGGBBAA #12345678
    |    >-will get removed-<
    v
    2
— टन हास्पेल
स्रोत
2

05AB1E , 10 बाइट्स

2FI2ô™J}I‡

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

2F     }   # Loop twice...
  I        # First 2 inputs.
   2ô™     # Title case in pairs of 2.
      J    # Rejoin together.
        I  # Last input (The color).
         ‡ # Transliterate, put color in pattern from a into pattern from b.

यह काम करता है क्योंकि मैं इनपुट को इससे बदलता हूं:

AARRGGBB

सेवा:

AaRrGgBb

इसलिए प्रत्येक मान को विशिष्ट रूप से मैप किया जाता है, फिर मैं ट्रांसलेटर का उपयोग कर सकता हूं।

तर्क उलटे हैं।

— जादू ऑक्टोपस Urn
स्रोत
2

जावा 10, 179 105 102 बाइट्स

(a,b,c)->{var r="#";for(int i=1,t;i<9;)r+=a.substring(t=b.indexOf(c.substring(i,i+=2)),t+2);return r;}

व्होलिंग -77 बाइट्स @ ओलीवियरग्रेगोयर के लिए धन्यवाद ।

स्पष्टीकरण:

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

(a,b,c)->{            // Method with String as three parameters and return-type
  var r="#";          //  Result-String, starting at "#"
  for(int i=1,t;i<9;  //  Loop `i` from 1 to 9 (exclusive)
    r+=               //   Append the result with:
       a.substring(   //    A substring from the first input,
        t=b.indexOf(  //    where an index is determined in the second input
           c.substring(i,i+=2)),t+2);
                      //    based on a substring of the third input
    return r;}        //  Return the result-String
— केविन क्रूज़सेन
स्रोत
1
105 बाइट्स स्रोत प्रारूप में लक्ष्य तत्व को खोजकर लक्ष्य से स्ट्रिंग बनाता है।
— ओलिवियर ग्रेगोइरे
@ OlivierGrégoire मुझे पता था कि यह उस pesky मैप के बिना संभव होगा। बहुत बहुत धन्यवाद, -74 बाइट वहीं!
— केविन क्रूज़सेन 10
जावा 10 पर स्विच करके 102 बाइट्स , जो अब TIO पर समर्थित है।
— ओलिवियर ग्रेगोइरे
2

जे , 5 बाइट्स

/:i./

बाएं तर्क रंग है। सही तर्क एक वर्ण मैट्रिक्स है जहां पहली पंक्ति लक्ष्य प्रारूप है और दूसरी पंक्ति मूल प्रारूप है। इसे ऑनलाइन आज़माएं!

— FrownyFrog
स्रोत
1

CJam, 14 बाइट्स

{'#\1f>2f/~er}

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

इनपुट रिवर्स ऑर्डर में एक सरणी है।

{
 `#\      e# Push '#'+[input array] on to stack
  1f>     e# Remove the '#' symbol from each input string
  2f/     e# Split each input string into an array of substrings of length 2.
  ~       e# Dump the substring-arrays from the container array onto the stack
  er      e# Perform a string replace operation
}
— geokavel
स्रोत
0

पायथन 2, 62 बाइट्स

lambda c,s,e:[c[s.index(e[i]):][:2]for i in range(1,len(e),2)]
— sonrad10
स्रोत
0

स्माइलबासिक, 144 बाइट्स

DEF R C,I,O
C[0]="&H
A=R+G+B
RGBREAD VAL(C)OUT VAR(I[1]),VAR(I[3]),VAR(I[5]),VAR(I[7])?"#";RGB(VAR(O[1]),VAR(O[3]),VAR(O[5]),VAR(O[7]))END
— 12Me21
स्रोत
0

सी (क्लैंग) , 89 बाइट्स

char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x++]=a[y=index(i,o[x])-i],b[x++]=a[y+1]);}

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

aअंदर iऔर बाहर प्रारूप में , में इनपुट मूल्य लेता हैo । में मान लौटाता हैb

माइनर चीट: bबाइट्स को बचाने के लिए प्रिंटिंग के बजाय भंडारण परिणाम । प्रश्न इसे अस्वीकार नहीं करता है।

सी (क्लैंग) , 100 बाइट्स

char *a,b[10],*i,*o;f(x,y){*b=*a;for(x=1;x<8;b[x]=a[y=index(i,o[x])-i],b[x+1]=a[y+1],x+=2);puts(b);}

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

सी (जीसीसी) , 181 बाइट्स

char *a,*i,*o;c[4],x,y,z;g(x){x=x==82?0:x==71?1:x==66?2:3;}f(){a++;for(;z<2;z++){i=(z?o:i)+1;for(y=0;y<7;z?printf("%s%2X","#"+!!y,c[g(i[y])]):sscanf(a+y,"%2X",&c[g(i[y])]),y+=2);}}

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

प्रारूप के आधार पर सरणी RGBAमें मान बनाता है , फिर प्रारूप में प्रिंट करता है c[]io

— GPS
स्रोत
सुझाएँ char*a,b[10],*i,*o;f(x)बजाय char *a,b[10],*i,*o;f(x,y)और x+=2)bcopy(a+(long)index(i,o[x])-i,b+x,2);के बजायb[x++]=a[y=index(i,o[x])-i],b[x++]=a[y+1]);
— ceilingcat
0

क्लोजर 1.8, 156 बाइट्स

(fn[c o t](reduce #(str %(val %2))""(sort-by key(reduce-kv #(let[s(clojure.string/index-of t(nth o %2))](assoc %(if(contains? % s)(inc s)s)%3)){}(vec c)))))

Ungolfed

  (fn [c o t]
    (reduce
     #(str % (val %2))
     ""
     (sort-by key
              (reduce-kv
               #(let [s (clojure.string/index-of t (nth o %2))]
                  (assoc %
                         (if (contains? % s) (inc s) s)
                         %3))
               {}
               (vec c)))))

इसे ऑनलाइन आज़माएं इसमें क्लोजर 1.8 सपोर्ट नहीं है। बहुत अजीब!

— यहोशू
स्रोत
0

पर्ल 6 , 55 51 46 बाइट्स

{[~] %(@^b Z=>@^a){@^c}}o*.map(*.comb(/\w?./))

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

इनपुट के रूप में (रंग, मूल, लक्ष्य) सूची लेता है। प्रत्येक इनपुट स्ट्रिंग को घटकों में विभाजित करता है, रंग मानों के लिए हैश मैपिंग स्रोत कुंजियाँ बनाता है, लक्ष्य कुंजी क्रम में रंग मान दिखता है, फिर परिणाम स्वरूपित करता है।

— nwellnhof
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.