14

चुनौती: निम्नलिखित उत्पादन का उत्पादन संभव के रूप में कुछ वर्णों का उपयोग करते हुए:

 _   _      _ _                             _     _ _
| | | | ___| | | ___    __      _____  _ __| | __| | |
| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |
|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)
                    |/

नियम और प्रतिबंध:

आप FIGLet या किसी भी समान टूल का उपयोग नहीं कर सकते हैं । (अन्यथा, figlet Hello, world!एक तुच्छ और बहुत अधिक अपराजेय समाधान होगा।)
आपके कार्यक्रम में पूरी तरह से मुद्रण योग्य ASCII वर्ण शामिल होने चाहिए - विशेष रूप से, कोड अंक 9 (TAB), 10 (LF) और 32 - 126। (यदि आपकी भाषा / OS को CRLF लाइन ब्रेक की आवश्यकता है, तो आप सादे LF के बजाय उन का उपयोग कर सकते हैं।) , यह अपने सिंटैक्स के हिस्से के रूप में गैर-एएससीआईआई वर्णों (या गैर-पाठीय डेटा) की आवश्यकता वाले किसी भी भाषा को पछतावा करता है।
आउटपुट बिल्कुल ऊपर के उदाहरण की तरह दिखना चाहिए। हालाँकि, यदि आप चाहें तो आउटपुट के आसपास अतिरिक्त व्हाट्सएप भी शामिल कर सकते हैं। आप 8-वर्ण टैब रिक्ति (या आपके द्वारा चुने गए प्लेटफ़ॉर्म की मूल डिफ़ॉल्ट सेटिंग, यदि यह एक सुसंगत है) मान सकते हैं ।

Ps। बराबर सेट करने के लिए, मैं 199-चार्ट पर्ल समाधान के साथ आया। मैं इसे अभी तक पोस्ट नहीं करूंगा, हालांकि, अगर कोई इसके साथ स्वतंत्र रूप से आता है। (इसके अलावा, यह एक प्रकार का पनीर है।) बेशक, यह आपको अपना समाधान पोस्ट करने से हतोत्साहित नहीं करना चाहिए, भले ही यह लंबा हो।

अद्यतन: अब जब कि हान ने इसे एक चार से हराया है , तो यहां मेरा चीज़ 199-चार पर्ल समाधान है:

use Compress'Zlib;say uncompress unpack u,'M>-I]BT$*`S$,`^]YQ=R:0,&_Z<DP?8@?WVQJ]E2J"%E$$@)R(/(/MCJ*\U!OM`Z#=5`4Y>6M=L\L%DMP&DB0V.4GQL&OOGB$4:%`4TT4!R8O-Z(^BTZWNV?>F86K:9+""-35*-LNC:T^D:_$#%^`";"DD0'

यह डीसी के समाधान (और विभिन्न भाषाओं में सभी अन्य zlib / gzip- आधारित समाधानों) के समान है, सिवाय इसके कि मैंने संपीड़ित पाठ और कुछ अन्य मामूली गोल्फिंग ट्रिक्स के लिए बेस 64 के बजाय uuencoding का उपयोग किया ।

अद्यतन 2 : मुझे लगता है कि आधिकारिक तौर पर विजेता को स्वीकार करने का समय आ गया है। पहला स्थान konsolenfreddy के PHP कोड में जाता है, हालांकि, आप वर्णों की गणना करते हैं, यह अब तक का सबसे छोटा जमा है। वास्तव में, इसे मेरे 199-चार पर्ल कोड से अनुकूलित DEFLATE स्ट्रीम के साथ संयोजन करने से 176-char समाधान भी कम होता है:

<?=gzinflate(base64_decode("fYtBCgMxDAPvecXcmkDBv+nJMH2IH99savZUqghZRBICciDyD7Y6ivNQbwOg3VQFOXlrXbPLBZLcBpIkNjlJ8bBr754hFGhQFNNFAcmLzeiPotOt7tn3plq2mSwgjU1SjbLo2tPpGvxAxfgA"));

हालांकि, मुझे लगता है कि हान किसी भी पूर्व-लिखित अपघटन उपकरण का उपयोग किए बिना इतने करीब होने के लिए एक विशेष मानद उल्लेख के हकदार हैं। आप दोनों को बधाई, और सभी को नया साल मुबारक हो!

— इल्मरी करोनें
स्रोत

ठीक है, मुझे यह एक सी में करना है ...

— माइकल डोरगन

1

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

"9&BO]h>&)>3ieuCoKVKVnuOoT'E-^Z(1.3u[);h1[RTOGqTZkoQx?KMy&9ctG&*y~HxR9%GYn.rYMdMcOOq^wXc@%zy*P[*Q"90|E|B"0+1"{%",``_|\/()V'"@]}R.1 |t54/m

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

यह इस तरह काम करता है।

एक बड़े स्ट्रिंग शाब्दिक के साथ शुरू करें।
आधार -90 नंबर के रूप में डिकोड करके पूर्णांक में परिवर्तित करें।
उस नंबर को बाइनरी में बदलें।
एस के रन के 0बाद 1गैर-अंतरिक्ष वर्णों में अनुवाद किया जाता है ।
शेष सभी 1स्थान रिक्त स्थान से बदल दिए गए हैं।
परिणामस्वरूप स्ट्रिंग को 54-वर्ण रेखाओं में विभाजित किया गया है।

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

बधाई हो, ऐसा लग रहा है कि यह अब तक का सबसे छोटा समाधान है! :)

— इल्मरी करोनन

17

पर्ल 5.10 - 195 198 202 203 वर्ण

यहाँ एक प्रविष्टि है जिसे मूल regexp मिलान से परे किसी भी लाइब्रेरी की आवश्यकता नहीं है। एन्कोडेड स्ट्रिंग 131 अक्षर है, और कोड को डिकोड और प्रिंट करने के लिए 64 अक्षर लगते हैं (स्रोत के अंत में कोई नई पंक्ति नहीं मानते)। विचार निम्न केस पत्रों द्वारा सामान्य 3-वर्ण स्ट्रिंग्स का प्रतिनिधित्व करना है।

s!!xfefxxf\t\t\tf efyx
no| cnocfxefxceyxm|xmn
nm|wtnwtgt/uvy \\| 'ym|w`o|
pepyy/o| _ogrr/ _opn (ml
l lbyly|by( )fiihyjm lb,y_
\t\tf |/!;s!\w!substr'(_)\___   \_/|_| |  V \ / _',-95+ord$&,3!eg;say

एनकोडर बहुत लंबा है और दुर्भाग्य से अभी बहुत पठनीय नहीं है। मूल विचार स्ट्रिंग प्रतिस्थापन के एक निश्चित सेट को देखते हुए, प्रत्येक पंक्ति के लिए सबसे छोटी एन्कोडिंग खोजने के लिए गतिशील प्रोग्रामिंग का उपयोग करना है। अंतिम पंक्ति पर प्रतिस्थापन की स्ट्रिंग को परीक्षण और त्रुटि द्वारा बनाया गया था, और यह संभव है कि प्रतिस्थापन की एक और स्ट्रिंग ऊपर की तुलना में एक छोटे कार्यक्रम को जन्म दे सकती है।

यहाँ एक चाल यह है कि कुछ प्रतिस्थापन 3 वर्णों से कम लंबे होते हैं: जिस तरह से पर्ल के substrकाम करने के कारण , xउसे ' _' और ' ' द्वारा प्रतिस्थापित किया yजाता है _। उत्तरार्द्ध आवश्यक है क्योंकि \wरेगेक्स मैचों में ' _', जिसे बाद में ' (_)' द्वारा बदल दिया जाता है ।

— हान
स्रोत

+1, बहुत अच्छा। आप की जगह 2 वर्ण बचा सकता printद्वाराsay

— टोटो

@ M42: जहां तक मैं समझ सकता हूं, पर्ल 5.10 पर sayआपको use 5.010;एक-लाइनर के रूप में स्क्रिप्ट को या तो करने या चलाने की आवश्यकता है perl -E 'script here'। पूर्व कोड को लंबा बनाता है और बाद वाला मल्टी-लाइन स्क्रिप्ट के लिए उपयुक्त नहीं है। क्या मैं कुछ भुल गया?

— हन

-Eचार की संख्या में शामिल नहीं किये जाते।

— टोटो

1

Ps। आप s''...'इसके बजाय का उपयोग करके कुछ और आकर्षण बचा सकते हैं $_=q!...!; बस एक उद्धरण से बचने के लिए याद रखें। उसके साथ और sayइसके बजाय print(और अंतिम नई पंक्ति को छोड़ कर), मैं इसे 198 वर्णों तक ले जाता हूं।

— इल्मरी करोनें

2

BTW, मैंने व्हॉट्सएप #के लंबे रनों के बजाय टैब का उपयोग करने की कोशिश की और आपका समाधान 190 वर्णों तक पहुंच गया। मुझे आश्चर्य है कि अगर 184 चार्ट से नीचे जाना संभव है - जो अब तक के सभी ज़ालिब-संकुचित समाधानों को हरा देगा।

— इल्मरी करोनन

13

Brainfuck - 862 वर्ण:

>++++[<++++++++>-]>-----[<---->---]<+++>>--[<+>--]<---<<.>.<...>.<....
..>.<.>.<.............................>.<.....>.<.>.>>++++++++++.<.<<.
>>.<<.>>.<<.>>.<<.>...>.<<.>>.<<.>>.<<.>...<....>..<......>.....<..>.<
.>..>.<<.>>.<<.>..>.<<.>>.<<.>>.>.<.<<.>>.<.>.<<.>>.>>>-[<->+++++]<---
-.<<<<.>.<.>---.+++<.>>.<<.>>.>>.<<<<.>.<.>---.<...>.<.>.<.>>>>.<<<.<.
>>>>.<<<<.>>>>.<<<<.>+++.<.>---.>.<<.>>>>>>---[<+>+++++++]<++.<<<<+++.
.>.<<.>>.>>.<<<<.>.+.-<.>>.<<.>>.>.<.<<..>.<..>>.<<..>..>>>.<<<<.>>.<<
.>>.<<.>>>>>+.<<<<.>>>>+.<<<<<.>>.<<...>---.<.>------.<..>.<.>>>>.<<<<
.>>>>>-.<<<<+++++++++.>>>>+.<<<<<.>>.<<.>>.<<..>>.<<.>>.<<.>>>>>-.<<<<
.>.<<.>>.<.>.>.<.<.>.<<.>>.<.>.<---.+++...>.<.>.<.>.<---.+++...>>>>.<<
<<<.>>>>>+.<<<<<...>---.+++.>>>.<<<---.+++.>>>.<<<<.>---.+++...>>>.<<.
<.>.<<..>>.<.>.<---.+++..>>>>+++.<<<<.>>>>----.<<<<.>>>>+.<<.<<<......
..............>>.>>.<.

— captncraig
स्रोत

ध्यान दें कि यह कोड स्पष्ट रूप से 8-बिट कोशिकाओं को मानता है; मैंने पहली बार 32-बिट कोशिकाओं के साथ एक दुभाषिया पर इसकी कोशिश की, और यह [<---->---]पहली पंक्ति में अटक गया । (संभवत: यह अंततः समाप्त हो गया होगा, लेकिन मैं उसके लिए लंबे समय तक इंतजार नहीं करता था।)

— इल्मरी करोनें

24

आपने इसे दो घंटे में कैसे लिख दिया?

— जॉय एडम्स

ऐसा लगता है कि आप पहले कोशिकाओं को सहेजते हैं (), (/ | V_ \ n पहली कोशिकाओं पर और आप बस आगे पीछे जाते हैं और आवश्यक

— चार्ट

यह 8 बिट रैपिंग सेल पर निर्भर करता है। आपके जैसे कुछ सामान्य पात्रों को संग्रहीत करता है, लेकिन सभी नहीं। एक सेल में '\' और '_' के बीच स्विच भी करता है, जहाँ वे ऐसा करने के लिए पर्याप्त हैं।

— captncraig

@ जेबरनार्डो, बीएफ देव पाठ जनरेटर ने कोड को इससे बहुत बड़ा दिया। यह मुझे लगता है कि यह हरा करने के लिए एक बहुत अधिक जटिल जनरेटर ले जाएगा।

— captncraig

9

पायथन (2.x), 194 वर्ण

print'eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'.decode('base64').decode('zip')

— tzot
स्रोत

2

इस जवाब ने मेरा दिन सिर्फ एक्सडी कर दिया। मैंने कभी नहीं सोचा होगा कि मैं एक कोडगुल्ला देखूंगा जो वास्तव में स्ट्रिंग आकार को कम करने के लिए ज़िप और बेस 64 का उपयोग करता है

— daboross

4

जावास्क्रिप्ट, 273 265 264 वर्ण

" _2_22_ _2222222226_26_ _10 0 3_0 | 3_2 32233_6_ 30 30 |10_0/ _ 4 0/ _ 424 4 /4 / / _ 4| '30/ _` 01|6_6|63/ 0 (_) |24 V6V / (_) 060 (_0_|1|_0_|43_|_543_( )24_/4_/ 43_/56543,_(_)12222226|/".replace(/\d/g,function(a){return'| |,\n,   ,__,\\,|_|,  '.split(',')[a]})

:(

— JiminP
स्रोत

अंतरिक्ष को बचाने के बाद return, -1 चार :)

— pimvdb

4

यह उत्तर केवल स्ट्रिंग को प्रिंट करने से ज्यादा लंबा है; हालाँकि, इसके मज़े के लिए, यहाँ यह है:

पायथन, 485 वर्ण 85

import sys

data= ',C6UBKq.)U^\\ 8[hHl7gfLFyX6,;p\'SlYpN@K-`Kbs#fSU+4o~^_h\\dJDy{o9p?<GnLTgG{?ZM>bJE+"[kHm7EavoGcS#AQ^\\>e_'
table= " _|\\/(\n)V'`,"
key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2)))

number= 0
for char in data:
    number= number*95 + ord(char) - 32

mask= 1<<655
decoder= key
while mask:
    index= mask & number and 1
    try:
        decoder= decoder[index]
    except TypeError:
        sys.stdout.write(table[decoder])
        decoder= key[index]
    mask>>= 1

चूंकि मेरे पास संकुचित मूल पाठ का सबसे छोटा ASCII प्रतिनिधित्व है, इसलिए मुझे अपने कोड में सबसे लंबा स्क्रॉलबार होना चाहिए! यह एक जीत है! :)

— tzot
स्रोत

4

AKA "मेरा स्क्रॉलबार आपकी तुलना में लंबा है"

— tzot

इस समाधान को 254 वर्णों तक सीमित किया जा सकता है। क्या आपको बुरा लगता है अगर मैं छोटे संस्करण में संपादित करता हूं?

— हान

@han: बेशक चरित्र की गिनती कम की जा सकती है; हालाँकि, मैंने इसे एक गंभीर उम्मीदवार के रूप में नहीं लिखा था। तो इस एक को अपनी योग्यता के लिए वोट दिया जाए, और इस उत्तर का जितना हो सके उतना कम उपयोग करके एक और उत्तर लिखें :)

— tzot

धन्यवाद, मैं पास हो जाऊंगा जब तक कि कोई और वास्तव में दिलचस्पी नहीं लेता। मैं केवल यह बताना चाहता था कि इस समाधान को मूल पाठ की तुलना में काफी छोटा बनाया जा सकता है।

— हन

3

PHP, 194 189 वर्ण

php -r'=gzinflate(base64_decode("dU/BDcQgDPszhX+lUqVs0xeSb5AMf3ZI+7qDACa2EwABeNXR4M/goxqJPUm+oLinEishKTdbKtuMQsTCC6C1EApUInHIvOlP+9zbO6PaTZ6+ynZDEZ1INFuNRu5z+ZVsMHHax1DAibCqZRdVZ/z6esYX"));'

यह मूल रूप से पायथन और पर्ल के उत्तर के समान है, जो थोड़ा छोटा है

— konsolenfreddy
स्रोत

php -r'=...'चाल मेरे लिए काम नहीं लगता है, लेकिन आप केवल इस्तेमाल कर सकते हैं <?=...184 वर्ण के लिए। इसके अलावा, आपके आउटपुट में एक अतिरिक्त जगह है जहाँ rऔर lमिलते हैं।

— इल्मरी करोनन

OSX 5.3.6 के साथ ठीक काम करता है -r'=..'। करता है php -rगिनती नहीं? यह मेरे 189chars में शामिल है ...

— konsolenfreddy

आम तौर पर, दुभाषिया का नाम नहीं गिनता। कमांड लाइन विकल्पों के लिए, मैं इस मेटा थ्रेड द्वारा जा रहा हूं ; PHP का -rस्विच एक बॉर्डरलाइन केस का कुछ है, हालाँकि, कोड को एक पैरामीटर के रूप में लेने और इसे चलाने के अलावा, यह फ़ाइल से कोड को चलाने की तुलना में पार्सिंग वातावरण को भी थोड़ा संशोधित करता है। मैं इसे 2 अतिरिक्त वर्णों के रूप में गिनना चाहूंगा - जो संयोगवश इसे साथ भी रखता है <?।

— इल्मरी करोनें

3

अन्य भाषाओं में: C (मूल संस्करण), 209 वर्ण ; पर्ल , 200 वर्ण ।

जे, 167 160 वर्ण (47 + 113)

एक और नो-बिलिन-संपीड़न सबमिशन। एक बहुत ही सीधी चर-लंबाई एन्कोडिंग का उपयोग करता है, प्रत्येक चरित्र को 1 बिट्स की श्रृंखला के रूप में एन्कोडिंग और 0 बिट्स द्वारा वर्णों को अलग करता है। संपीड़ित स्ट्रिंग मात्र 113 अक्षर है।

('a _|\/',CR,'()V`,'''){~#;.2,(6$2)#:40-~3&u:'8H1(((((H:f[4ZS4ZP2(RPMAMANf[>CZD[F;I[OVFF;TgfS5aGd[7T9JW4[eG[+Of7ddg?d[.AfT]WUASE=S>bSdgI]cS[RWBYSE?gSeG_X(()WG('

— जुगनू
स्रोत

2

पायथन (2.7.x), 218 वर्ण

import base64,zlib;
print zlib.decompress(base64.b64decode("eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc"))

बहुत सरल ... इस प्रयास से बहुत प्रसन्न नहीं।

— डिलन कॉवर
स्रोत

2

बैश, 199 196 193 वर्ण

base64 -d<<<H4sIAAAAAAAAAz1PQQ6AIAw7S+IfelMTk/3GE0l9CI+3HRPYoHQtAxCAMzduGliMiL0NzElygSz+LiYhLWc1VekzDFU6FoCyIxRIYuBgyd7f5+5eGdnv5OWjbA8UUcRAVbORfBN0v5MFTlw2MhQwEVaV7KYu2tv88IgPjUlb7QoBAAA=|zcat

पर्याप्त नजदीक...

संपादित करें: नीचे 193 करने के लिए!

— डिलन कॉवर
स्रोत

1

अच्छा लगा। आप की जगह तीन और वर्ण को बचा सकता है gzip -dके साथ zcat।

— इल्मरी करोनन

3

जहाँ-तहाँ का उपयोग करने से गूँज पर बचत होती।

— पीटर टेलर

2

बैश, 196 192

base64 -d<<<H4sIAO4SqFMCA3VPQQ7AIAi7+4re5pIl/GYnk+4hPH4U0dOmILUUUBCAPEOBn8Wlao65SW6QudWJSYSUM5sqlQlZJAY2QPiAhSEJx8GSPVWm0TppOa3z1DWqboRZEY7K5pzmMw49kgU6TtXRwiDCpCrZxejTvn7u1l5z59MGKQEAAA|zcat

— rpax
स्रोत

1

पर्ल, 230 अक्षर

use Compress::Zlib;
use MIME::Base64;
print uncompress(decode_base64('eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'));

यह मूल रूप से मेरे पायथन उत्तर के समान है। मैं 199-चरित्र संस्करण देखना चाहता हूं .. जादू की तरह लगता है।

— डिलन कॉवर
स्रोत

मैं इसे अभी तक पोस्ट नहीं करूंगा, लेकिन आप सही रास्ते पर हैं। बेशक, मैं उम्मीद कर रहा था कि कोई इसे पूरी तरह से अलग दृष्टिकोण के साथ हरा देगा।

— इल्मरी करोनें

1

पर्ल, 294 290 बाइट्स।

अकेले संकुचित स्ट्रिंग है ~~151~~ 130 बाइट्स।

यह छोटा नहीं है, लेकिन यह लिखने में वाकई मजेदार था।

@t=split//,"_|\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'Ph?`@Ooooo1l410````0066600?03l0001PP06600HHB1Q064L4D<8h8^::<DLL4@J0032>1D<90h<>00hHI@6QhYllLX3@`hHI@1Q04P@1Q04@002080R001I^80a074001Q07208P0B0X34ooo`ST';$b=~s/(1)|(0.{4})/$1?" ":$t[ord pack"B8","000$2"]/eg;print$b

@t=split//," _|x"x4 ."\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'4100A0000000001017:8R5HR5@1@05E15R5R;:9Ra4`8\\A<0<30a`<C4C2=URa7PRbP@PG4R<g@P<3D=C4cM288S=RK:HV`EVK1G<d0`LL74`EaV2K1Mg=db0000002ab';$b=~s/1(1.{4})|(..)/$t[ord pack"B8","000".($2?"000$2":$1)]/eg;print$b

— user2905252
स्रोत

1

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

अकेले संकुचित स्ट्रिंग, 111 बाइट्स है।

@t = split//, " _|\\/\n()V',`";
$k=[0,[1,[2,[[3,4],[[5,6],[7,[[8,9],[10,11]]]]]]]];

$b .= substr unpack("B8", chr(-48+ord)), 2, 6 for split//,'@P900000PBlc<b[<bX:0ZXUIUIVlcFKZLI^Y`LLMhjjW<oJcMGncNHS5MIW]l`ho3lMNgc<IW]V]i[=KUF]KUG[hL^l^^EMeSFiGmNggP001^Pl';

$d = $k;
$o.=$d=~/^\d/?$t[$s=$d,$d=$$k[$_],$s]:($d=$$d[$_],"")for split//,$b;
print $o

समझने की कोशिश कर रहा है कि अजगर क्या key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2))) कर रहा था, मैंने एक बहुत ही समान दिखने वाला पर्ल संस्करण बनाया।

— user2905252
स्रोत

1

PHP 590

जाहिर है, मैं जीतने की कोशिश नहीं कर रहा हूं, बस एक और संपीड़न योजना की कोशिश करने में दिलचस्पी है, बिल्कुल यह भी कॉपी-पेस्टिंग के सरल 302 सादे पाठ PHP समाधान को हरा नहीं सकता है

यह 10 चैनलों पर बिटमैप के रूप में काम करता है

"Golfed"

<? $l=['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],'|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],'/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],'\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],'('=>[3=>'e8,b8lc','1s,4'],')'=>[3=>'3k,2t4w','g,1'],'V'=>[3=>'0,18y680'],'`'=>[2=>'0,g'],"'"=>[2=>'0,6bk'],','=>[4=>'0,g'],];$p=@str_pad;$b=@base_convert;$i=-1;while($i++<5){$h=' ';foreach($l as$c=>$r)if(@$r[$i]){$a=explode(',',$r[$i]);$d=str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));foreach($d as$j=>$v)$v&&$h[$j]=$c;}echo"$h\n";}

पठनीय

<?php
$l = ['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],
      '|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],
      '/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],
     '\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],
      '('=>[3=>'e8,b8lc','1s,4'],
      ')'=>[3=>'3k,2t4w','g,1'],
      'V'=>[3=>'0,18y680'],
      '`'=>[2=>'0,g'],
      "'"=>[2=>'0,6bk'],
      ','=>[4=>'0,g'],
      ];
$p=@str_pad;
$b=@base_convert;
$i=-1;
while($i++<5){
    $h = str_repeat(' ',54);
    foreach($l as $c=>$r)
        if(@$r[$i]){
        $a = explode(',',$r[$i]);
        $d = str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));
        foreach($d as$j=>$v)
            if ($v)
                $h[$j]=$c;
        }
    echo "$h\n";
}

— Einacio
स्रोत

1

पाइलॉन्गॉल्फ 2, 300 बाइट्स

" _   _      _ _                             _     _ _
| | | | ___| | | ___    __      _____  _ __| | __| | |
| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |
|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)
                    |/"~

मुझे कोई उत्तम दर्जे का एन्कोडिंग तरीका नहीं मिला, इसलिए मैं शायद प्रतिस्पर्धा नहीं कर रहा हूं ।

0

गोल्फ-बेसिक 84, 325

:"                     "_Str1t` _   _      _ _ "d`Str1d`Str1t`_     _ _"t`| | | | ___| | | ___    __      _____  _ __| | __| | |"t`| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |"t`|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|"t`|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)"t`                    |/"

मान लें कि एक कैलकुलेटर बैकटिक्स, बैकस्लैश, सिंगल पाइप और अंडरस्कोर प्रिंट कर सकता है।

— Timtech
स्रोत

0

HTML + JS (223 यूनिकोड वर्ण)

सिर्फ मनोरंजन के लिए:

<body onload=p.innerHTML=unescape(escape("𘁟𘀠𘁟𘀠𘀠𘀠𧰠𧰠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𧰠𘀠𘀠𧰠𧰊𯀠𯀠𯀠𯀠𧱟𧱼𘁼𘁼𘁟𧱟𘀠𘀠𧱟𘀠𘀠𘀠𧱟𧱟𧰠𘁟𘁟𧱼𘁼𘁟𧱼𘁼𘁼𒡼𘁼𧱼𘁼𛰠𧰠𧀠𯀠𯀯𘁟𘁜𘀠𘁜𘁜𘀯𧀠𛰠𛰠𧰠𧁼𘀧𧱟𯀠𯀯𘁟𨀠𯀠𯀊𯀠𘁟𘀠𯀠𘁟𧰯𘁼𘁼𘀨𧰩𘁼𘀠𘁜𘁖𘀠𥠠𛰠𚁟𚐠𯀠𯀠𘁼𘁼𘀨𧱼𘁼𧱼𒡼𧱼𘁼𧱼𧁟𧱟𯁟𯁟𯁜𧱟𧰨𘀩𘀠𘁜𧰯𧁟𛰠𧁟𧱟𛱼𧱼𘀠𯁟𯁜𧱟𛁟𚁟𚐊𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𯀯").replace(/uD./g,''))><pre id=p>

NB: आपको इसे "UTF-8 BOM" HTML फ़ाइल में सहेजना होगा।

— XEM
स्रोत

अच्छा लगा। BOM (फ़ायरफ़ॉक्स 26 / क्रोमियम 31) के बिना भी मेरे लिए काम करता है, जब तक कि एन्कोडिंग UTF-8 या ऑटो-डिटेक्ट पर सेट है। काश, यह बताए गए नियमों के तहत अर्हता प्राप्त नहीं करता ("प्रोग्राम में पूरी तरह से मुद्रण योग्य ASCII वर्ण शामिल होना चाहिए")। :-(

— इल्मरी करोनें

मुझे पता है, यह सिर्फ मनोरंजन के लिए था;)

— xem

0

PowerShell , 220 byes = स्क्रिप्ट: 9 + संग्रह: 211

tar xOf t

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

पुरालेख स्क्रिप्ट संग्रह बनाने के लिए t(TIO देखें):

(
" _   _      _ _                             _     _ _",
"| | | | ___| | | ___    __      _____  _ __| | __| | |",
"| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |",
"|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|",
"|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)",
"                    |/"
) | Set-Content f -Force
tar zcfo t f
Get-ChildItem t # output info about archive size

— Mazzy
स्रोत

ASCII कला में दुनिया को "हैलो" कहें

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

पर्ल 5.10 - 195 198 202 203 वर्ण

Brainfuck - 862 वर्ण:

पायथन (2.x), 194 वर्ण

जावास्क्रिप्ट, 273 265 264 वर्ण

पायथन, 485 वर्ण 85

PHP, 194 189 वर्ण

जे, 167 160 वर्ण (47 + 113)

पायथन (2.7.x), 218 वर्ण

बैश, 199 196 193 वर्ण

बैश, 196 192

पर्ल, 230 अक्षर

पर्ल, 294 290 बाइट्स।

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

PHP 590

पाइलॉन्गॉल्फ 2, 300 बाइट्स

गोल्फ-बेसिक 84, 325

HTML + JS (223 यूनिकोड वर्ण)

PowerShell , 220 byes = स्क्रिप्ट: 9 + संग्रह: 211