26

#rrggbbहेक्स प्रारूप में एक रंग के इनपुट को देखते हुए , उसी प्रारूप में इसके आरजीबी पूरक को आउटपुट करें।

RGB किसी भी रंग R ₁ G ₁ B _{1 के} R ₂ G ₂ B ₂ को R ₂ मान 255 - R ₁ , B ₂ मान 255 - B ₁ , और G ₂ मान 255 - G _{1 के} साथ रंग के रूप में परिभाषित किया गया है ।

हेक्स अंक या तो अपरकेस (# FFAA20) या लोअरकेस (# ffaa20) में हो सकते हैं। इनपुट और आउटपुट का मामला सुसंगत नहीं है (इसलिए आप लोअरकेस में इनपुट ले सकते हैं लेकिन अपरकेस में आउटपुट, और इसके विपरीत)।

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

टेस्ट केस (ध्यान दें कि आपका प्रोग्राम / फंक्शन देने के बाद से उसका खुद का आउटपुट मूल इनपुट में होना चाहिए (यह अचूक है ), टेस्ट केस दोनों दिशाओं में काम करना चाहिए):

In/Out   Out/In
----------------
#ffffff  #000000
#abcdef  #543210
#badcab  #452354
#133742  #ecc8bd
#a1b2c3  #5e4d3c
#7f7f80  #80807f

code-golf

— Doorknob
स्रोत

2

मुझे खेद है, लेकिन sRGB उस तरह से काम नहीं करता है। आपको पहले रैखिक स्थान में बदलना चाहिए, जो हेक्स-कोड में नहीं हैं।

— जॉन ड्वोरक

2

@JDDvorak ओह अच्छा। चुनौती की स्थिति मेरी अज्ञानता को दर्शाती है, फिर, क्योंकि मैं वास्तव में इसे अब बदल नहीं सकता हूं। : पी

— दरवाज़े

हालांकि sRGB में दो मूल्यों का लाभ उठाना एक अलग चुनौती हो सकती है। sRGB = RGB ^ 0.45 अधिकांश रेंज में, लेकिन रेंज के निचले हिस्से के पास रैखिक।

— जॉन ड्वोरक

17

अजगर, ९ 9 बाइट्स

-1 बाईट के लिए @isaacg को धन्यवाद!

sXz.HM16

255 से एक निश्चित रंग का मूल्य घटाना प्रत्येक हेक्साडेसिमल अंकों में से प्रत्येक को 15 से घटाने के बराबर है। कहो कि एक संख्या 16a + b है । फिर 15 से अपने अंकों को घटाकर बनाई गई संख्या का मूल्य 16 (15-a) + (15-b) = 255 - (16a + b) है ।

sXz.HM16     implicit: z=input()
      16      
   .HM        map hex representation over range
   .HM16     '0123456789abcdef'
  z           the input string
 X            Translate characters in x1 present in x2 to reversed x2
              that is, '0' becomes f, '1' becomes 'e', and so on.
              The initial '#' is unchanged.
s             That produced a list, so join into a string by reducing +

इसे यहाँ आज़माएँ । परीक्षण सूट।

— lirtosiast
स्रोत

अच्छा जवाब! मैंने '0123456789abcdef'हेक्स में कनवर्ट करने के लिए ( dec2hexफ़ंक्शन के बजाय ) का उपयोग करने के अपने विचार को उधार लिया

— लुइस मेंडो

मुझे लगता है कि आपका लिंक गलत है। ( कॉपी-पेस्ट FTW। )

— पुरकाकूदरी

@ Pietu1998 वूप्स; मैं इसे ठीक कर दूंगा।

— lirtosiast

Uअनावश्यक है - यह परोक्ष द्वारा भरा है M।

— इसहाक

6

रेटिना, 13 10 बाइट्स

T`w`G-A9-0

कोड के तीन भाग हैं, जो बैकटिक्स द्वारा अलग किए गए हैं ( `): Tट्रांसपेरेट मोड को निर्दिष्ट करता है, जो दूसरे भाग में प्रत्येक चरित्र को तीसरे भाग में उसके संबंधित वर्ण के साथ बदल देता है।

wपारंपरिक रेगेक्स के रूप में ही है \w, या _0-9A-Za-z, जिसका विस्तार किया जाता है _0123456789ABCDEFGH...।

दूसरे भाग का विस्तार किया गया है GFEDCBA9876543210, रेटिना की निफ्टी को रिवर्स ऑर्डर में विस्तार करने की क्षमता के लिए धन्यवाद। इन्हें एक-दूसरे के ऊपर रखें और हम प्राप्त करें:

_0123456789ABCDEFGH...
GFEDCBA987654321000...
 ^^^^^^^^^^^^^^^^

ध्यान दें कि अंतिम वर्ण, 0लंबी स्ट्रिंग की लंबाई को फिट करने के लिए दोहराया जाता है, लेकिन हम केवल हेक्साडेसिमल वर्णों के बारे में परवाह करते हैं, जो कैरेट्स द्वारा दिखाए जाते हैं।

इस दृष्टिकोण का सुझाव देने के लिए मार्टिन ब्यूटनर को धन्यवाद।

ऑनलाइन परीक्षण सूट का प्रयास करें।

— NinjaBearMonkey
स्रोत

4

मारबेलस, 41 बाइट्स

00@0
\\]]\/
-W/\@0
-W
~~
<A+700
+O//]]
+O

यहां ऑनलाइन इंटरप्रेटर। इनपुट अपरकेस में होना चाहिए।

व्याख्या

00और ]]निचले भाग में (प्रथम चरित्र लायेगा #) है और यह नीचे करने के लिए आते हैं और कुछ और करने से पहले outputted हो।

शेष सभी वर्णों को लाने के लिए पहली 3 पंक्तियाँ एक लूप हैं।

पहले हमें हेक्स अंक वर्णों को 0-15 में परिवर्तित करने की आवश्यकता है, करके x -= 48, x -= x > 9 ? 7 : 0(चूंकि 'A' - '9'8 है)।

पूरक खोजने के लिए, हमें बस हर अंक xको बदलने की जरूरत है 15-x। यह (8-बिट मान के लिए) के बराबर है (~x)+16 = ~(x-16)।

अंत में, हमें इन नंबरों को वापस करके hex digits में बदलना होगा x += x > 9 ? 7 : 0, x += 48।

तो अब हमारे पास है x -= 48, x -= x > 9 ? 7 : 0, x = ~(x - 16), x += x > 9 ? 7 : 0, x += 48।

ध्यान दें कि यदि हम पहले टर्नरी ऑपरेटर के साथ अभिव्यक्ति को हटाते हैं, तो इनपुट अंक A- Fपरिणाम के बाद ऋणात्मक x होगा।

इस प्रकार हम पिछली अभिव्यक्ति को बदल सकते हैं: x -= 48, x -= 16, x = ~x, x += (x > 9 || x < 0) ? 7 : 0, x += 48जो के बराबर है x -= 64, x = ~x, x += (x > 9 || x < 0) ? 7 : 0, x += 48।

उपरोक्त कोड अंतिम अभिव्यक्ति का सिर्फ एक कार्यान्वयन है। -Wहै x -= 32और +Oहै x += 24। चूंकि Marbelous अहस्ताक्षरित 8 बिट गणित, हालत का उपयोग करता <Aकवर दोनों के मामले x > 9और x < 0।

— es1024
स्रोत

क्या आपने मारबेलस बनाया?

— R

@RikerW Marbelous को खुद सहित कई PPCG उपयोगकर्ताओं द्वारा बनाया / बनाया गया था: यहाँ देखें ।

— es1024

ठीक है। मुझे बताने के लिए धन्यवाद।

— Rɪᴋᴇʀ

4

जावास्क्रिप्ट ईएस 6, 61 बाइट्स 66 68 48 53 64

@ C quite O'B @, @NinjaBearMonkey, और @nderscore की बदौलत काफी कुछ बाइट्स बचाता है

s=>"#"+(1e5+(8**8+~('0x'+s.slice(1))).toString(16)).slice(-6)

ऑटो-टाइप-कास्टिंग का लाभ उठाता है। शून्य को ठीक करते हुए बाइट काउंट को मार दिया

— Downgoat
स्रोत

eval(`0x${s.slice(1)}`)इसके बजाय का उपयोग करेंparseInt

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ यही लंबाई है?

— पुरकाकूदरी

@ C @O'Bʀɪᴇɴ धन्यवाद, मैंने - eval के बजाय इस्तेमाल किया जिसने और भी अधिक बाइट्स

— बचाए

ओह, ऑटो टाइप कास्टिंग के बारे में भूल गए: डी

— कॉनर ओ'ब्रायन

इसे इनपुट के साथ आज़माएं #FFFFFF। लौटता है #0।

— कोनोर ओ ब्रायन

4

जावास्क्रिप्ट ईएस 6, 63 58 52 49 बाइट्स

c=>c.replace(/\w/g,x=>(15-`0x${x}`).toString(16))

11 बाइट बचाने के लिए nderscore का धन्यवाद !

— nicael
स्रोत

-5 बाइट्स:c=>"#"+[...c].map(x=>"fedcba9876543210"[+('0x'+x)]).join``

— अंडरस्कोर

@ और वास्तव में, इसके बारे में पहले से ही सोचा था :) धन्यवाद। इसका उपयोग करने जा रहा था, लेकिन "eval" के साथ।

— निकेल

1

आह, मुझे एक और मिल गया है -6:c=>c.replace(/\w/g,x=>"fedcba9876543210"[+('0x'+x)])

— nadcore

3

जोल्फ, 17 बाइट्स

pq#-w^88C Li1~560
pq                pad
         _Li1     the input, w/out the first char
        C    ~5   parsed as a base-16 integer (~5 = 16)
    w^88          8 ^ 8 - 1 (the magic number)
   -              subtract the parsed input from said number
  #               convert result to hexadecimal
               60 pad the result with 6 0's

यहाँ कोशिश करो! , टेस्ट सूट (पूर्ण रन का उपयोग करें, जो अब काम करता है।)

— कोनोर ओ ब्रायन
स्रोत

3

जूलिया, 74 49 बाइट्स

h->"#"join([hex(15-parse(Int,i,16))for i=h[2:7]])

इस समय बहुत लंबा है लेकिन यह एक शुरुआत है। यह एक लंबोतरा फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। आउटपुट लोअरकेस में होगा लेकिन इनपुट या तो हो सकता है।

जैसा कि थॉमस ने उल्लेख किया है , प्रत्येक 2-अंकीय रंग घटक को 255 से घटाकर हेक्साडेसिमल इनपुट में प्रत्येक व्यक्ति अंक को 15 से घटाना के बराबर है। इनपुट स्ट्रिंग पर लूपिंग, प्रमुख को छोड़कर #, हम 15 - पार्स किए गए अंक को हेक्साडेसिमल में बदलते हैं। हम इन सब से जुड़ते हैं और फिर इसका सामना करते हैं #और इसे अच्छा कहते हैं।

— एलेक्स ए।
स्रोत

3

जाप , 35 32 22 20 16 15 बाइट्स

¡Y?(F-XnG)sG :X

स्पष्टीकरण:

¡                 //Take input and map (shortcut to "Um@"). Input should in the form of "#123456"
 Y?               //if Y is not 0, then return (F-XnG)sG, otherwise last step...
    F-XnG           //Subtract X, converted from hexadecimal (G is 16) to decimal, from 15
          sG        //convert decimal to hexadecimal
             :X   //...otherwise return X unchanged (happens only with #, the first char)

— nicael
स्रोत

अच्छा है! मैंने कल रात इसे देखा और खुद से कहा, "कल मैं इसे नीचे लाने में मदद करूँगा।" लेकिन अब तक आपने इसे जितना संभव समझा था, उससे अधिक आगे बढ़ा दिया है। :)

— ETHproductions

2

पर्ल, 30 बाइट्स

के लिए +1 शामिल है -p

s/\w/sprintf"%x",15&~hex$&/eg

उपयोग: echo #000000 | perl -p file.pl
या echo #000000 | perl -pe 's/\w/sprintf"%x",15&~hex$&/eg'।

— केनी
स्रोत

2

MATL , 21 बाइट्स

35,5Y216,j6L)!16ZA-)h

यह भाषा / संकलक के 6.0.0 का उपयोग करता है , जो चुनौती से पहले है।

इनपुट अंक अपरकेस होना चाहिए।

उदाहरण

यह ओक्टेव पर निष्पादित किया गया है:

>> matl
 > 35,5Y216,j6L)!16ZA-)h
 >
> #FFAA20
#0055DF

संपादित करें (12 जून, 2016)

कोड अब ऑनलाइन कोशिश की जा सकती है । अल्पविराम को बदला जाएगा रिक्त स्थान से, और जरूरत 6Lसे 4L, भाषा में परिवर्तन के अनुरूप।

व्याख्या

35,             % number literal: ASCII code of '#'
5Y2             % '0123456789ABCDEF'
16,             % number literal
j               % input string
6L)             % remove first element
!               % transpose
16ZA            % convert from hex to dec
-               % subtract from 16
)               % index into '0123456789ABCDEF' to convert back to hex
h               % prepend 35, which gets automatically converted into '#'

— लुइस मेंडो
स्रोत

1

पायथ, 20 19 बाइट्स

1 बाइट एक्सनोर के लिए धन्यवाद ।

%"#%06x"-t^8 8itz16

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

z इनपुट है
tz निकालता है #
itz16 हेक्साडेसिमल संख्या के रूप में पर्स
t^8 88 ⁸ - 1 की गणना करता है
-t^8 8itz168 ⁸ - 1 - इनपुट की गणना करता है
%"#%06x"-t^2 24itz16 इसे शून्य-गद्देदार 6-वर्ण हेक्स स्ट्रिंग में स्वरूपित करता है और जोड़ता है #

— PurkkaKoodari
स्रोत

2 ^ 24 के लिए 8 ^ 8 के बारे में कैसे?

— xnor

1

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

मेरा पहला सबमिशन, यह शायद सबसे लंबा (85 बाइट्स) होगा लेकिन हे, आपको कहीं शुरू करना था। हास्केल में:

import Numeric;f=('#':).concatMap((flip showHex)"".(15-).fst.head.readHex.(:[])).tail

यह 15 से एक ही घटाव का उपयोग कर रहा है मैंने देखा कि अन्य लोग उपयोग करते हैं।

मैंने अन्य ट्रिक (8 ^ 8 - 1 घटाएं) के साथ-साथ प्रिंटफ का उपयोग करने की भी कोशिश की और यह ghci में काम करता है लेकिन किसी कारण से यह संकलित नहीं होता है:

g=printf "#%06x" .(8^8-1-).fst.head.readHex.tail

अगर कोई ऐसा काम कर सकता है जो बहुत अच्छा होगा!

— lpapez
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। ये बहुत अच्छे उत्तर हैं (हास्केल में मैं जितना बेहतर कर सकता था!)। हालाँकि, कोड-गोल्फ चुनौतियों के लिए एक सामान्य उत्तर प्रारूप है जो लीडरबोर्ड स्निपेट को आपके उत्तर को लीडरबोर्ड में डालने देता है। मैं इसे आपके लिए संपादित करूँगा; आप संपादन को स्वीकार या अस्वीकार कर सकते हैं।

— wizzwizz4

अन्य उपयोगकर्ताओं की टिप्पणियों का जवाब देने के लिए, टाइप करें @username।

— wizzwizz4

@ wizzwizz4 आपकी सहायता के लिए बहुत धन्यवाद।

— lpapez

किसी भी समय! क्या आप मेरी कुछ चुनौतियों का सामना करना चाहते हैं? हिल्बर्ट कर्व के लिए अपनी कुर्सी और मैप स्ट्रिंग का विश्लेषण करें , मेरा पसंदीदा है, हालांकि हिल्बर्ट वक्र एक बहुत कठिन है।

— wizzwizz4

@ wizzwizz4 निश्चित रूप से, मैं देखूंगा कि मैं क्या कर सकता हूं।

— lpapez

1

गणितज्ञ, 69 60 बाइट्स

"#"<>IntegerString[8^8-#~StringDrop~1~FromDigits~16-1,16,6]&

एक बार फिर, यह स्ट्रिंग प्रसंस्करण है जो मुझे यहां मारता है।

— LegionMammal978
स्रोत

1

सी, 94 बाइट्स

t(char*b){for(int i;i=*b;++b)*b=i>96&i<103?150-i:i>64&i<71|i>47&i<54?118-i:i>53&i<58?111-i:i;}

फ़ंक्शन एक चार सरणी में लेता है, उलटा मान देता है। प्रतिक्रिया के लिए बड़े अक्षरों का निर्माण करता है। कोड प्रत्येक ASCII हेक्स वर्ण को इसके व्युत्क्रम में फ़्लिप करता है यदि यह मान्य है, तो इसे अन्यथा अनदेखा करता है।

— डेव पी।
स्रोत

आप iसमारोह से पहले विश्व स्तर पर घोषणा करके कुछ जगह बचा सकते हैं :i;

— लियाम

1

𝔼𝕊𝕄𝕚𝕟 2, 18 वर्ण / 34 बाइट्स

ïē/\w⌿,↪(ḏ-`ᶍ⦃$}”ⓧ

Try it here (Firefox only).

चुनौती के बाद बनाए गए संस्करण का उपयोग करना।

व्याख्या

ïē/\w⌿,↪(ḏ-`ᶍ⦃$}”ⓧ // implicit: ï=input, ḏ=15
ïē/\w⌿,             // replace all alphanumeric chars in ï with:
       ↪(ḏ-`ᶍ⦃$}”ⓧ // (15 - char's decimal form) converted to hex
                    // implicit output

गैर-प्रतिस्पर्धी समाधान, 15 चार्ट / 29 बाइट्स

ïē/\w⌿,↪(ḏ-`ᶍ⦃$}”ⓧ

लिप्यंतरण का उपयोग करता है।

— मामा फन रोल
स्रोत

क्या आप एक प्रतिस्पर्धी संस्करण भी जोड़ सकते हैं, इसलिए हम देख सकते हैं कि भाषा कैसे ढेर हो जाती है?

— lirtosiast

ज़रूर। नया संपादन देखें।

— मामा फन रोल

एपीएल प्रतीक का अच्छा उपयोग ⌿।

— lirtosiast

हेहे, वह प्रतीक वह था जिसने सबसे अधिक समझ बनाई /g।

— मामा फन रोल

1

पायथन, 96

x=input()
print("#")
for i in range(3):
    print(hex(255-int(x[(1+2*i)]+x[(2+2*i)],16))[2:4])

पहला कोड गोल्फ, कृपया राय दें :)

— मेव मिक्स
स्रोत

आपको इनपुट "quotes"btw में होने की आवश्यकता है , इसलिए input()काम करता है। आपको लूप के लिए न्यूलाइन और इंडेंट की आवश्यकता नहीं है, और rangeबस ठीक काम करता है। कुछ जोड़े भी हैं जिन्हें आप हटा सकते हैं।

— R

int("ff", 16)बस के साथ बदला जा सकता है 255।

— दरवाज़े

क्या आपको प्रत्येक x के बाद कोष्ठक के अंदर कोष्ठक की आवश्यकता है?

— ब्लू

0

सीजेएम, 16 बाइट्स

qA,'G,65>+s_W%er

यह काफी लंबा है क्योंकि CJam आधार परिवर्तन को अलग तरीके से संभालता है, इसलिए यह सिर्फ ट्रांसलिटरेशन करने के लिए छोटा था। लिप्यंतरण पर अधिक के लिए मेरा रेटिना उत्तर देखें ।

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

व्याख्या

q      e# Get the input
A,     e# Push [0 1 ... 8 9]
'G,65> e# Push "ABCDEF"
+s     e# Combine and convert to string
_W%    e# Make a copy and reverse it
er     e# Replace each character in the first string with
       e# the corresponding character in the second

— NinjaBearMonkey
स्रोत

0

पायथन 3, 44 बाइट्स

मूल रूप से मैंने 256^3तब उपयोग किया था 16^6। तब मैंने Pietu1998 का देखा 8^8और अब यह समाधान इसके बजाय इसका उपयोग करता है।

"#{:06x}".format(8**8-1-int(input()[1:],16))

— Sherlock9
स्रोत

0

जावा, 95 90 बाइट्स

String f(String v){return v.format("#%06x",0xFFFFFF^Integer.parseInt(v.substring(1),16));}

बिटवाइज़ XOR।

— SuperJedi224
स्रोत

0

बैश + ट्रे, 35 बाइट्स

tr 0-9A-Fa-f fedcba9876543210543210

आउटपुट हमेशा लोअरकेस होता है।

दुर्भाग्य से "ट्र" उल्टे क्रम में पर्वतमाला नहीं लेता है इसलिए मुझे उन्हें बाहर निकालना पड़ा।

— ग्लेन रैंडर्स-पीरसन
स्रोत

0

सी, 147 बाइट्स

void p(char s[]){char c[3];int i=1;printf("#");while(i<6){strncpy(c,s+i++,2);i++;int x=255-strtol(c,NULL,16);x<10?printf("0%x",x):printf("%x",x);}}

हेक्स स्ट्रिंग से इंट में बदलने के लिए स्ट्रैटोल का इस्तेमाल किया गया, फिर मूल पोस्ट की तरह तारीफ पाने के लिए संख्या 255 से घटा दी गई। मैं, हालांकि, सोच रहा था कि वहाँ एस से strtol करने के लिए वर्णों की एक श्रृंखला को पारित करने का एक तरीका है तो मुझे बाइट्स का एक गुच्छा एक नए स्ट्रिंग की नकल करने की ज़रूरत नहीं है?

— Danwakeem
स्रोत

मुझे नहीं लगता कि कंपाइलर आमतौर पर फंक्शन रिटर्न लागू करते हैं और डिफ़ॉल्ट रूप से इंट्रस्ट करते हैं, इसलिए आप शायद voidरिटर्न टाइप छोड़ देते हैं?

— लियाम

0

आर, 62 बाइट्स

f=function(a)sprintf('#%06x',(8^8-1)-strtoi(substr(a,2,7),16))

— mnel
स्रोत

0

sed, 48 बाइट्स

y/0123456789ABCDEFabcdef/fedcba9876543210543210/

या 36 बाइट्स यदि आपको केवल एक मामले का समर्थन करने की आवश्यकता है।

— नील
स्रोत

आपको लोअरकेस और अपरकेस दोनों का समर्थन करने की आवश्यकता नहीं है।

— मार्टिन एंडर

@ मार्टिनबंटनर को इस सवाल का इनपुट में दोनों मामलों के लिए समर्थन की आवश्यकता है, लेकिन आउटपुट में नहीं। मेरे bash + tr समाधान की तरह, यह समाधान इनपुट पर दोनों का समर्थन करता है, लेकिन केवल लोअर-केस आउटपुट लिखता है।

— ग्लेन रैंडर्स-पीरसन 13

आपको 0अपने कोड में एक अतिरिक्त मिला है , 9और A(बाइट गिनती सही है, हालांकि, एक प्रतिलिपि त्रुटि होनी चाहिए)।

— hobbs

प्रश्न कहता है कि आप चुन सकते हैं कि आपका इनपुट और आउटपुट किस स्थिति में हैं।

— lirtosiast

0

पॉवरशेल, 48 बाइट्स

param($a)"#{0:x6}"-f(16MB-1-("0x"+$a.Trim('#')))

आवश्यक param($a)रूप से इनपुट के माध्यम से एक स्ट्रिंग के रूप में लेता है , के साथ सीमांकित 'या ", क्योंकि C:\Tools\Scripts\Golfing> .\complementary-colors #a1b2c3PowerShell कमांड लाइन पर #a1b2c3एक टिप्पणी के रूप में माना जाएगा और संक्षेप में इसे अनदेखा करेंगे।

बाएं-से-दाएं, "#{0:x6}"-f(...)हमारे आउटपुट की गणना एक गारंटीकृत 6 वर्णों (इनपुट के लिए खाते में #ffffff) के साथ हेक्साडेसिमल में वापस आ जाती है । Parens के अंदर, हम अपने इनपुट नंबर को घटाते हैं 0xffffff। हम इस तथ्य का लाभ उठाते हैं कि पावरशेल प्रारूप में हेक्साडेसिमल संख्याओं को पार्स करता है 0xNNN, इसलिए हम अपने इनपुट नंबर से एक उचित प्रारूप हेक्स संख्या का निर्माण करते हैं $a। (ध्यान दें कि संघनन प्लस एक बाइट की .Trim()तुलना में .Replace()यहाँ कम है ।) हम इसके बजाय निर्माण करने के लिए MBयूनिरी ऑपरेटर का भी लाभ उठाते हैं ।16MB-1167772150xffffff

— AdmBorkBork
स्रोत

0

टीस्क्रिप्ट, 24 बाइट्स

"#"+S(8**8-1-xS1)t16))x6

दुभाषिया में कीड़े मुझे यह छोटा होने नहीं दे रहे हैं :(

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

— Downgoat
स्रोत

डाउनवोट स्पष्टीकरण? यह सभी परीक्षण मामलों के लिए काम करता है

— डाउनगैट

सहायक रंग

अजगर, ९ 9 बाइट्स

रेटिना, 13 10 बाइट्स

मारबेलस, 41 बाइट्स

व्याख्या

जावास्क्रिप्ट ईएस 6, 61 बाइट्स 66 68 48 53 64

जावास्क्रिप्ट ईएस 6, 63 58 52 49 बाइट्स

जोल्फ, 17 बाइट्स

जूलिया, 74 49 बाइट्स

जाप , 35 32 22 20 16 15 बाइट्स

पर्ल, 30 बाइट्स

MATL , 21 बाइट्स

उदाहरण

संपादित करें (12 जून, 2016)

व्याख्या

पायथ, 20 19 बाइट्स

व्याख्या

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

गणितज्ञ, 69 60 बाइट्स

सी, 94 बाइट्स

𝔼𝕊𝕄𝕚𝕟 2, 18 वर्ण / 34 बाइट्स

व्याख्या

गैर-प्रतिस्पर्धी समाधान, 15 चार्ट / 29 बाइट्स

पायथन, 96

सीजेएम, 16 बाइट्स

व्याख्या

पायथन 3, 44 बाइट्स

जावा, 95 90 बाइट्स

बैश + ट्रे, 35 बाइट्स

सी, 147 बाइट्स

आर, 62 बाइट्स

sed, 48 बाइट्स

पॉवरशेल, 48 बाइट्स

टीस्क्रिप्ट, 24 बाइट्स