90

एडम वेस्ट का निधन हो गया, और मैं पीपीसीजी पर उनकी स्मृति का सम्मान करना चाहता हूं, हालांकि मुझे संदेह है कि उन्हें हमारे अस्तित्व का पता था। जबकि कई, कई अलग-अलग चीजें हैं जो इस आदमी के लिए जानी जाती हैं, ~~मूल~~ बैटमैन के रूप में उनकी भूमिका से कोई भी अधिक प्रमुख नहीं है । मैं हमेशा अपने सौतेले पिता को आज भी पुराने स्कूल के बैटमैन और रॉबिन को याद करता हूँ। यह चुनौती प्रकृति में सरलीकृत है, न कि उस जटिल आदमी के अनुरूप जो एडम वेस्ट था। हालाँकि, यह मेरे लिए सबसे अच्छा हो सकता है, क्योंकि यह आदमी के करियर की सबसे प्रतिष्ठित छवि है।

मैं यह पहले से पोस्ट करना चाहता था, लेकिन मैं किसी के बेहतर आने का इंतजार कर रहा था।

निम्नलिखित आउटपुट (रिक्त स्थान / नईलाइन्स के साथ या बिना):

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **

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

code-golf ascii-art kolmogorov-complexity

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

7

आपको एन्कोडेड स्ट्रिंग्स को मना करना चाहिए। यह वास्तव में मजेदार नहीं है!

— सर्गियोल

7

वह मूल बैटमैन नहीं था। वह सम्मान लुईस विल्सन का है।

— झबरा

42

जब मैंने शीर्षक देखा, तो मुझे लगा कि आउटपुट "ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना-ना" हो।

— डी क्रूगर

3

@Drueueger: इसे एक और प्रश्न में बनाएं :)

— ओलिवियर दुलक

4

पिछले साल यह क्यों नहीं शुरू हुआ? कैरी फिशर, प्रिंस, डेविड बॉवी और एलन रिकमैन!

— केयर्ड सिक्काहिंगाहिंग

47

जेली , 44 बाइट्स

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ßŒÆ@Ƥ’b25o99Jx$ị⁾ *s25ŒBY

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

यह काम किस प्रकार करता है

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ßŒÆ@Ƥ’

यह एक संख्यात्मक शाब्दिक है। सभी पात्रों को जेली के कोड पृष्ठ में उनके 1-आधारित सूचकांकों के साथ बदल दिया जाता है , जिसके परिणाम को एक आधारभूत 250 आधारांक, उपज के रूप में व्याख्या किया जाता है।

58616171447449697510361193418481584558895594063391402

इसके बाद, b25आधार के लिए कि पूर्णांक कन्वर्ट 25 और o99की जगह 0 से 99 , उपज

11 1 20 4 10 1 8 4 12 4 3 6 12 4 2 9 9 5 1 99 1 24 2 5 7 11 4 4 7 3 4 3 7 2 7 1 6 2

Jx$की जगह जे ^वें आधार -25 अंक n के साथ n की प्रतियां j , उपज

1 1 1 1 1 1 1 1 1 1 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 7 7 7 7 7 7 7 7 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 11 11 11 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 15 15 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 24 24 24 24 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 26 26 26 26 27 27 27 27 28 28 28 28 29 29 29 29 29 29 29 30 30 30 31 31 31 31 32 32 32 33 33 33 33 33 33 33 34 34 35 35 35 35 35 35 35 36 37 37 37 37 37 37 38 38

अब, ị⁾ *चरित्र जोड़ी में अनुक्रमित करता है। इंडेक्सिंग 1-आधारित और मॉड्यूलर है, इसलिए विषम संख्या को रिक्त स्थान के साथ बदल दिया जाता है, यहां तक कि तारांकन के साथ भी। यह प्रदान करता है

           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **

s2525 की लंबाई में परिणाम में चॉप करता है । यदि हम प्रत्येक लाइन को अपनी लाइन पर लिखते हैं, तो हम प्राप्त करते हैं

           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **

उछाल परमाणु ŒBअपनी पहली चरित्र के बिना एक उलट प्रतिलिपि संलग्न करके प्रत्येक हिस्सा palindromizes, उपज

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **

अंत में, Yवास्तविक लाइनफीड का परिचय देता है।

— डेनिस
स्रोत

1

और मुझे लगा कि “QƤḣọḲ£¿ẆịµñẒṢƊ¬ƒỤ2ỴÐ,ịṁ&Ḅ<ḋsḳn.⁷ṛḃṡ⁾6bḋeṁ’ṃ⁾ *s25ŒBY53 बाइट्स में काफी कम था ...

— एरिक आउटगोल्फर

मैंने 14 अलग-अलग चीजों की तरह कोशिश की, फिर अंत में परीक्षण और त्रुटि से यह मिला। समझ में नहीं आया कि "99 के साथ 0 की जगह" का क्या मतलब है जब तक मैंने खुद इसे आज़माया नहीं।

— मैजिक ऑक्टोपस Urn

156

वर्डफक , 5761 2686 बाइट्स

मुझे लगता है कि एक स्रोत कोड के रूप में उनके नाम का उपयोग करने से एडम वेस्ट को कुछ सम्मान मिलता है।

adam west adam west adam_wes t_a dam_we st_a dam_ west adam west adam west adam west_ad am_west_a dam_we st ad am we st ad am we st ad am west_a dam_we st_a dam_ west_ada m_w est ada m_w est ada m_west_ adam west_a dam_west_ adam_we st_ ad am_west ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_w est_ adam west adam west adam west adam west adam we st_adam west_ad am we st ad am we st adam_w es t_ ad am west_ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am west_a da m_ we st adam_w es t_adam_ west_ad am we st ad am west_a da m_ we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am_wes t_ adam_we st_adam we st ad am_wes t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st adam_w es t_adam_ west_ad am we st_ada m_ we st ad am we st ad am west_ad am we st ad am we st ad am west_a da m_ we st ad am we st ad am_west ad am we st ad am we st ad am_wes t_ ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am_west ad am west_a da m_ we st ad am_west ad am we st ad am we st_ada m_ we st ad am we st ad am we st ad am we st ad am we st ad am west_ad am we st ad am we st adam_w es t_ ad am we st_ada m_ west_ad am_west ad am we st adam_w es t_ ad am west_ad am we st ad am we st adam_w es t_ ad am_west ad am we st adam_w es t_ ad am we st_adam we st ad am west_a da m_ we st_adam we st ad am we st ad am_wes t_ ad am we st_ada m_ west_ad am_west ad am we st ad am we st_ada m_ we st_adam we st ad am we st ad am_wes t_ adam_we st ad am we st ad am_wes t_ ad am west_ad am we st ad am we st_ada m_ west_ad am we st ad am we st adam_w es t!

इसे ऑनलाइन आज़माएं! _{(ट्रांसप्लान्ड ब्रेनफक)}

एडम वेस्ट गायन _{(धन्यवाद @carusocomputing)}

— Uriel
स्रोत

69

यह भयानक है। मुझे यह पसंद है।

— द वेंडर

25

हम्म। हाँ। बहुत अच्छा है, लेकिन मुझे लगता है कि आप लाइन 1 पर एक अंडरस्कोर भूल गए थे

— मतीन उल्हाक

2

क्या कोई ऐसा तरीका है जिससे हम इसका परीक्षण कर सकते हैं?

— झबरा

4

पीसीसीजी में आपका स्वागत है! हम वास्तव में इस साइट पर प्रतिस्पर्धा नहीं करते हैं , निश्चित रूप से यह जीतने वाला समाधान नहीं है, लेकिन इसके प्रफुल्लित करने वाला और चुनौती देने वाला है, इसलिए यह ऊपर उठ जाता है ताकि अधिक लोग इसका आनंद ले सकें। जल्द ही आपके उत्तरों को उभारने की उम्मीद है!

— उरियल

3

@ शैगी इसे ऑनलाइन आज़माएं! (STDERR)

— अदम

67

पायथन, 530 529 528 524 बाइट्स

import zlib as Holy
B=list("NNAAAnAAnnAnaAannnaaaaNaAAnNanAaAanNNaNNaNaanNNANanNNANaAnAaANANAAnAaANNnAanAaNnAaAANNAaAnNANAaaANNAanAaNaNNNAaNNanAAnNNnaaaNANANANnnaaaNaaAAAANaNaNaNAnNAAAAaaaaANAaNnnAaAaNAAaANNnaaNnNnaannaaAaananannNnAAAAAanAananANAnaAAnANAAaaaAaaanaaAAaanNAnanAAnnnANAnNAnnAnnnanaNNaaaNaNNaAAnNAaaANNNANAnAaaAaNaANnNNNaaAanaaaanaaaaaAaAaNnNnnaAnANaNnnANanNA")
A=dict(N='11',A='01',n='10',a='00')   
T=""
POP=BIFF=POW=OOF=lambda:A[B.pop()]
while B:T+=chr(int(POP()+POW()+BIFF()+OOF(),2))
print Holy.decompress(T)

— rrauenza
स्रोत

5

हे भगवान, मैं थोड़ी देर में मुश्किल नहीं हँसे। NAANANANANANaNAANnAnaNANanaNA

— मैजिक ऑक्टोपस Urn

9

कोड गोल्फ में, हम कर रहे हैं चाहिए बाइट छोटे गिनती बनाने के लिए है, लेकिन अपनी प्रविष्टि नहीं बल्कि है भारी । ;)

— PM 2Ring

34

इस अवसर पर, अधिक से अधिक अच्छे लोगों के लिए बलिदान करना चाहिए।

— रुरान्जा

1

ऐसा लगता है कि बैटमैन कुछ कहेगा। ;) मुझे स्वीकार करना होगा कि मुझे B.pop(0)थोड़ा कष्टप्रद लगता है । क्यों नहीं उलटा Bताकि आप बहुत अधिक कुशल (और कम) का उपयोग कर सकें B.pop()? pop(0)एक स्लॉट नीचे सभी शेष सूची तत्वों को स्थानांतरित करने के लिए है। ज़रूर, यह सी गति से होता है, लेकिन यह स्ट्रिंग के अंत से पॉपिंग की तुलना में कम कुशल है।

— PM 2Ring

5

अन्य नामों पर POP, BIFF, POW, OOFमुझे बाहर थूक मैं अपने मॉनीटर पर क्या पी रहा था बनाया है। बहुत - बहुत धन्यवाद। +1।

— रेयिनेंग

21

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

_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))

डेमो

कोड स्निपेट दिखाएं

let f =

_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))

o.innerHTML = f()

<pre id=o></pre>

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

— Arnauld
स्रोत

12

पायथन, 149 142 बाइट्स

7 बाइट्स ने @ PM2Ring को धन्यवाद दिया

for l in"b1d 74a13 54c4 36c4 2995 1o 0p 0p 0p 1o 257b 447343 727162".split():x=''.join(s*int(k,36)for s,k in zip(' *'*3,l));print(x+x[-2::-1])

— Uriel
स्रोत

अच्छा लगा। आप 7 बाइट्स शेव कर सकते हैं:x=''.join(s*int(k,36)for s,k in zip(' *'*3,l))

— PM 2Ring

कोई चिंता नहीं। मैं एक और भी छोटा पायथन संस्करण लिखने में कामयाब रहा। ;)

— PM 2Ring

1

@ PM2Ring आप मेरी +1 मिला

— ऊरीएल

12

MATL , 61 59 बाइट्स

' *'60:'*u9|K9j[~F9R,>ejc4Q,7;F\1l_=7sFR'F11:ZaY"13e)25ZvZ)

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

यह काम किस प्रकार करता है

यह निम्नलिखित, मानक तकनीकों का उपयोग करता है:

चूंकि छवि क्षैतिज रूप से सममित है , केवल बाएं आधा (केंद्र स्तंभ सहित) एन्कोडेड है।
स्तंभ-प्रमुख क्रम (नीचे, तब) में छवि को रेखीयकृत किया जाता है और परिणामस्वरूप अनुक्रम रन-लंबाई एन्कोडेड होता है ।
जिसके परिणामस्वरूप रन लंबाई से मान लेने 1के लिए 11है, इसलिए रन लंबाई के अनुक्रम है आधार रूपांतरण से संकुचित आधार से, 11के आधार के लिए 94(एकल उद्धरण है, जो भागने की आवश्यकता होगी सिवाय प्रिंट योग्य ASCII वर्ण)।

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

1

स्तंभ-प्रमुख क्रम में 60 रन हैं, लेकिन पंक्ति-प्रमुख में केवल 38। कि किसी भी बाइट बचा सकता है?

— डेनिस

@ डेनिस समस्या यह है कि उस स्थिति में रन की लंबाई होती है [1:12 20 24 99], जो संपीड़न को अधिक कठिन बना देती है। मेरा सबसे अच्छा प्रयास 60 बाइट्स पर है

— लुईस मेन्डो

सटीक सेट का निर्माण करने के बजाय, क्या आपने बस बेस 25 का उपयोग करने की कोशिश की है और 0 को 99 के साथ बदल दिया है, जैसे Y|? मुझे पता नहीं है कि अगर वास्तव में छोटा है तो MATL atm का परीक्षण करें ...

— डेनिस

@ डेनिस जो आशाजनक लग रहा है। सेट का उपयोग करके [1:24 99]मैंने एक बाइट को हटा दिया । अगर मैं का उपयोग [0:24](आधार 25) मैं कैसे चालू करने के लिए पता नहीं है 0में 99कुछ बाइट्स में

— लुइस Mendo

1

राइट Y|MATL / ऑक्टेव में काम नहीं करता है जैसे कि यह जेली / पायथन में करता है। उत्तरार्द्ध में, 0 or 99उपज 99 ...

— डेनिस

7

05AB1E , 47 बाइट्स

„ *19×S•«M;Ó8ζ?èYÑ?½¨/Ž´.δòÈÖ<•25вт<19ǝ×J13ä€û»

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

— Emigna
स्रोत

पोर्ट डेनिस के एल्गोरिथ्म सही है?

— एरिक आउटगोल्फर

@EriktheOutgolfer: replace 99 trickउससे उधार लिया (सीधे आगे के रास्ते पर 4 बाइट्स को बचाया)। हालांकि अभी भी बेहतर तरीके की तलाश है।

— इमीना

-1 के .∞बजाय का उपयोग करके €û»(दर्पण स्पष्ट रूप से दर्पण को लागू करने से पहले, विरासत संस्करण में पहली बार newlines पर सूचियों में शामिल होते हैं)। मैंने भी ₂вइसके बजाय उपयोग करने की कोशिश की है 25в, लेकिन दुर्भाग्य से संपीड़ित पूर्णांक तब 1 बाइट लंबा होता है, इसलिए यह कुछ भी नहीं बचाता है •2Ø°×á[1∊Œ)’˜Àå<тIÞ‡p5ÉQ•₂в:।

— केविन क्रूजेसेन

7

vim, 168 156 बाइट्स

:nm N a <C-v><ESC>
:nm A a*<C-v><ESC>
:nm B aY<C-v><ESC>yyp!!rev<C-v><CR>kJh4xo<C-v><ESC>
11NA13NB7N4A10NA3NB5N4A12N4AB3N6A12N4AB2N9A9N5ABN24AB25ABkyyppjN24AB2N5A7N11AB4N4A7N3A4N3AB7N2A7NA6N2ABdd

यह एक यूनिक्स वातावरण को मानता है rev। मैं एक काफी (गिनती, चरित्र) एन्कोडिंग, सीधी एन और एक appending एक साथ उपयोग और *क्रमशः, और बी की नकल कर रहे हैं और रिवर्स।

वास्तविक फ़ाइल में, ब्रैकेटेड प्रविष्टियों को उनके प्रतिनिधित्व वाले शाब्दिक बाइट्स द्वारा बदल दिया जाता है। <C-v>0x16 है, <ESC>0x1b है, और <CR>0x0d है।

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

— रे
स्रोत

मुझे लगता है कि मैक्रोज़ को 'बी' और 'सी' बनाने की जहमत नहीं उठानी होगी, और इसके बजाय उन्हें सीधे रिमैप करना होगा। :nm N a <C-v><esc>और:nm A a*<C-v><esc>

— DJMcMayhem

@DJMcMayhem तो यह करता है। किसी कारण के लिए, मुझे लगा कि <C-v>फ़ाइल की तुलना में इसे स्टोर करना अधिक कठिन होगा , इसलिए मैंने राउंडअबाउट विधि का उपयोग किया ताकि मैं इसके साथ परीक्षण कर सकूं { cat foo.vim; echo ':wq'; } | vim out.txt। मुझे यकीन नहीं है कि यह <C-v><C-v>कल की कोशिश करने के लिए मेरे साथ क्यों नहीं हुआ ।

— रे

मुझे यह जानकर खुशी हुई कि आप इसे काम कर रहे हैं! एक और तरीका है कि आप सुविधा के लिए विम उत्तरों का परीक्षण कर सकते हैं इसे ऑनलाइन आज़माएं! , जो वास्तव में मेरे द्वारा लिखे गए एक एसोलैंग का उपयोग करता है, लेकिन यह (ज्यादातर) वैसे भी पीछे संगत है। -vझंडा आप (जैसे vim कुंजी विवरण का उपयोग करने देता <C-v>और whatnot)

— DJMcMayhem

@DJMcMayhem बहुत अच्छा। धन्यवाद।

— रे

क्या आप <NL>इसके बजाय नहीं लिख सकते <NEWLINE>?

— L3viathan

7

चारकोल , 69 54 52 48 बाइट्स

Ｅ⪪”｜↖y{{﹪yc›o”n↗πf>T≔Ｙ¿PN｜ωπＱβ” ⪫Ｅι×§* μ⌕βλω‖Ｏ←

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: @ ASCII- केवल के लिए, एक अलग ध्वज से सूचक पर स्विच करके 4 बाइट्स को बचाया, सूचकांकों पर लूपिंग ~~(7)⸿~~ , ~~बाइट्स का उपयोग करके (undocumented?)~~ ~~चरित्र,~~ और रनिंग एन्कोडिंग के लिए वर्णमाला का उपयोग करके एक और 4 बाइट्स। एक और 2 बाइट्स को सहेजा क्योंकि AtIndexस्वचालित रूप से मोड्यूलो लेता है। एक और 4 बाइट्स को सहेजा क्योंकि Mapस्वचालित रूप से एक सूचकांक चर बनाता है। स्पष्टीकरण:

Print(Map(

बाहरी Mapएक सरणी देता है। Printअपनी लाइन पर प्रत्येक तत्व को प्रिंट करके इसे संभालता है, इस प्रकार मैन्युअल रूप से Joinउनके साथ होने से बचा जाता है \n।

Split("anb adbke eme fjj y z z z y lhf dedhe cgbhc" " "),

स्ट्रिंग आउटपुट के सभी आधे-पंक्तियों को एन्कोड करता है। वैकल्पिक अक्षर *s और रिक्त स्थान की संख्या को संदर्भित करते हैं ( a=0इसका उपयोग एक पंक्ति को संभालने के लिए किया जाता है जो एक स्थान से शुरू होता है)। अंतरिक्ष सीमांकक का एक सुविधाजनक विकल्प है, लेकिन यह भी अच्छी तरह से संपीड़ित करने के लिए निकलता है (एक्स कुल मिलाकर 55 बाइट्स को संकुचित करता है)। प्रत्येक पंक्ति को अलग से संसाधित किया जाता है। (ध्यान दें: डिवर्बोसिफायर एक संपीड़ित और असम्पीडित स्ट्रिंग के बीच विभाजक को हटाने में विफल रहता है, अन्यथा कोड में एक ,अक्षमता होगी।)

Join(Map(i, Times(AtIndex("* ", m), Find(b, l))), w)));

हर अक्षर के ऊपर लूप करें, जो उचित *स्थान पर विस्तृत हो । चर mइसके लिए आंतरिक लूप सूचकांक है Map, जबकि lपत्र रखता है। परिणाम को Joinपूर्वनिर्धारित खाली स्ट्रिंग का उपयोग करके एक एकल स्ट्रिंग में एड किया जाता है w।

ReflectOverlap(:Left);

एक बार सभी पंक्तियों को मुद्रित करने के बाद, मध्य स्तंभ को ओवरलैप करते हुए, बाईं ओर सब कुछ प्रतिबिंबित करें।

मैंने सभी लूपों में नए सिरे, स्पेस और स्टार्स को संभालने की कोशिश की, लेकिन वास्तव में इस तरह से दो और बाइट्स हुए:

Print(Join(Map("anb adbke eme fjj y z z z y lhf dedhe cgbhc", Ternary(Equals(" ", i), "\n", Times(AtIndex("* ", k), Find(b, i)))), w));
ReflectOverlap(:Left);

— नील
स्रोत

1

+1 मुझे वास्तव में चारकोल सीखने की जरूरत है (साथ ही हेक्सागोनी और क्यूबिक्स भी)। मेरी पसंदीदा प्रोग्रामिंग भाषाओं में से तीन मैं यहां देख रहा हूं। Btw, मुझे लगता है कि आप पहले से ही योजना बना रहे थे, लेकिन क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— केविन क्रूज़सेन

@KevinCruijssen हम्म, मुझे लगता है कि क्रिया कोड को भी कुछ स्पष्टीकरण की आवश्यकता है ... क्या यह पर्याप्त है?

— नील

आह, मैंने देखा नहीं था कि TIO में वर्बोज़ संस्करण tbh समाहित है। लेकिन फिर भी, उत्तर में एक स्पष्टीकरण कभी भी दर्द नहीं करता है, इसलिए इसे लिखने के लिए समय निकालने के लिए धन्यवाद।

— केविन क्रूज़सेन

मैं चारकोल सीखना चाहता हूं, लेकिन इसके लिए 05AB1E जैसे पेज की जरूरत होती है, जो यह बताता है कि कोड-पेज के प्रत्येक चार कोड में गोता लगाने के बिना वास्तव में क्या करता है।

— मैजिक ऑक्टोपस Urn

2

@carusocomputing यह बहुत बुरा नहीं है: संपीड़ित स्ट्रिंग्स के अलावा, आपको सामान्य स्ट्रिंग्स (ASCII वर्ण और पाइलक्रो), संख्या (सुपरस्क्रिप्ट अंक), तीर (... तीर), कमांड (आमतौर पर फ़ुलऑर्डर कैपिटल अक्षर) और ऑपरेटर (सब कुछ) मिला है और), तो आप उन्हें विकी के उपयुक्त पृष्ठ पर देख सकते हैं।

— नील

6

क्लोजर, 833 437 बाइट्स

लगभग परिभाषा द्वारा Clojure संक्षिप्तता के लिए किसी भी पुरस्कार जीतने कभी नहीं होगा, लेकिन जैसा कि मैंने आगे दो (उन्हें गिनती - करने के लिए हर रफ़ू सप्ताह देखा दो ) (! एक ही बैट-समय, एक ही बैट-चैनल) बैटमैन के प्रकरणों यह स्पष्ट है है कि वहाँ खोने केलिए वक्त नहीं!

त्वरित, रॉबिन - चमगादड़- REPL को !!!

(defn r[c n](clojure.string/join(repeat n c)))(defn pl[col](loop[i 0 c " "](print(r c (nth col i)))(if(< i (dec (count col)))(recur (inc i) (if (= c " ") "*" " "))(println))))(defn p[](loop[lines [[11 1 25 1][7 4 10 1 5 1 10 4][5 4 12 7 12 4][3 6 12 7 12 6][2 9 9 9 9 9][1 47][0 49][0 49][0 49][1 47][2 5 7 21 7 5][4 4 7 3 4 5 4 3 7 4][7 2 7 1 6 3 6 1 7 2]] i 0] (pl (nth lines i))(if (< i (dec (count lines)))(recur lines (inc i))nil)))

गैर-गोल्फ संस्करण:

(defn repstr [c n]
  (clojure.string/join (repeat n c)))

(defn print-bat-signal-line [col]
  (loop [i  0
         c  " "]
    (print (repstr c (nth col i)))
    (if (< i (dec (count col)))
      (recur (inc i) (if (= c " ") "*" " "))
      (println))))

(defn print-bat-signal []
  (loop [lines [[11 1 25 1]  ; spaces asterisks spaces asterisks
                [7 4 10 1 5 1 10 4]
                [5 4 12 7 12 4]
                [3 6 12 7 12 6]
                [2 9 9 9 9 9]
                [1 47]
                [0 49]
                [0 49]
                [0 49]
                [1 47]
                [2 5 7 21 7 5]
                [4 4 7 3 4 5 4 3 7 4]
                [7 2 7 1 6 3 6 1 7 2]]
        i      0]
    (print-bat-signal-line (nth lines i))
    (if (< i (dec (count lines)))
      (recur lines (inc i))
      nil)))

एडम पश्चिम पश्चिम। कोई फर्क नहीं पड़ता कि उन शो कितने हास्यास्पद थे, हममें से जो बच्चे थे वे आपको सलाम करते हैं।

— बॉब जार्विस
स्रोत

जबकि गोल्फ नहीं, यह अभी भी बिल्ली का जवाब देता है हे।

— मैजिक ऑक्टोपस Urn

गोल्फ संस्करण जोड़ा गया। मैं इसे बग़ल में घुमाता हूँ ताकि यह दिख सके कि यह दीवार पर चढ़ रहा है अगर मैं कर सकता था। :-)

— बॉब जार्विस

6

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

#define x 16777215
char*b,*c,a[50];l[]={4096,122888,491535,2064399,4186143,x/2,x,x,x,x/2,4064255,983495,98435,0},*p=l;main(){for(;*p;p++,puts(a))for(b=c=a+23;b>=a;*p/=2)*b--=*c++=" *"[*p&1];}

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

— हेगेन वॉन एटिजन
स्रोत

6

RLE डेटा को एन्कोड करने के लिए विभिन्न तकनीकों के साथ, रन लेंथ एन्कोडिंग का उपयोग करते हुए विभिन्न समाधान।

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

यह संस्करण bytesडेटा संग्रहीत करने के लिए एक स्ट्रिंग का उपयोग करता है ।

s=''
for c in b'<)@4/:),0/>/,3>/*981(WYYY(W*14=./4-.-4+4)2+':s+=' *'[c%2]*(c//2-19);s*=len(s)<25or print(s+s[-2::-1])or 0

आज्ञा देना sसितारों की एक स्ट्रिंग या रिक्त स्थान हो। फिर बाइट nएन्कोडिंग sद्वारा दिया जाता है

n = 38 + 2*len(s) + (s[0]=='*')

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

यह संस्करण अल्फाबेटिक कोडिंग का उपयोग करता है। अक्षर मान आउटपुट स्ट्रिंग की लंबाई निर्धारित करता है, पत्र का मामला निर्धारित करता है कि क्या यह रिक्त स्थान या सितारों से बना है।

s=''
for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB':
 s+=' *'[c<'a']*(int(c,36)-9)
 if len(s)>24:print s+s[-2::-1];s=''

मेरा मूल 133 बाइट पायथन 2 समाधान।

यह संस्करण शून्य-लंबाई के तारों का उपयोग करता है, इसलिए यह आसानी से स्टार और स्पेस स्ट्रिंग्स के बीच वैकल्पिक कर सकता है।

s=''
for c,n in zip(24*' *','b1d074a13054c436c429951o0p0p0p1o257b447343727162'):
 s+=c*int(n,36)
 if len(s)>24:print s+s[-2::-1];s=''

बस मज़े के लिए, यहाँ अक्षर-कोडिंग का उपयोग करके एक-लाइनर है।

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

print'\n'.join(''.join(s+s[-2::-1])for s in zip(*[iter(''.join(' *'[c<'a']*(int(c,36)-9)for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB'))]*25))

और भी मज़ेदार के लिए, यहाँ कॉनवे के गेम ऑफ़ लाइफ में एक पैटर्न है जो बैटमैन लोगो का एक संस्करण उत्पन्न करता है। मुझे मोटे तौर पर टेक्स्ट संस्करण के समान पहलू अनुपात रखने के लिए प्रत्येक पंक्ति को दोगुना करना था। यह पैटर्न नहीं है वास्तव में लोगो की गणना (हालांकि यह है -, यह सिर्फ यह स्मृति छोरों से रिप्ले जीवन में संगणना करना संभव यह ट्यूरिंग-पूर्ण है), इसलिए मैं मैं एक कोड गोल्फ प्रविष्टि के रूप में यह पोस्ट नहीं कर सकते लगता है (हालांकि मैं किया Python स्क्रिप्ट मैं कुछ साल पहले लिखा था) का उपयोग कर इसे पैदा करते हैं। ;)

यह काफी मानक RLE प्रारूप में एन्कोडेड है जिसे अधिकांश Life इंजन लोड कर सकते हैं। यदि आपके पास GoL प्रोग्राम नहीं है (जैसे Golly ), तो आप इसे इस ऑनलाइन जीवन इंजन के साथ ऑनलाइन देख सकते हैं , जो Life RLE फ़ाइलों को आयात कर सकता है। यहाँ उस जीवन पद्धति का PNG संस्करण , कुछ जीवन कार्यक्रम (Golly सहित) PNG और विभिन्न अन्य छवि फ़ाइल स्वरूपों से जीवन पैटर्न लोड कर सकते हैं।

— दोपहर 2 बजे
स्रोत

6

टी-एसक्यूएल, 283 276 222 बाइट्स

SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAFNQgAMtBVxAi5cLxgICdB3IAkAAVYuqEsLHIgRWjV0KqxBIvZYWujQeEaAGLdIALxeJGuinhXSvQEMCPVSQAbIcJPJQReGSSHxU9WAeSppAqEMoBwCfudAGawIAAA=='as XML).value('.','varbinary(max)'))AS varchar(max))

यहां पोस्ट की गई विधि के माध्यम से , मूल बैटमैन स्ट्रिंग के GZIP संपीड़न को लागू करना । यह केवल SQL 2016 और बाद में काम करता है।

पहले के SQL संस्करणों के लिए, मेरी पूर्व विधि ( 276 बाइट्स ) का उपयोग करें:

DECLARE @ CHAR(999)=REPLACE(REPLACE(REPLACE('PRINT SPACE(11#1$25#1&$7#4$10#1$5#1$10#4&$5#4$12#7$12#4&$3#6$12#7$12#6&$2#9$9#9$9#9&$1#47&#49&#49&#49&$1#47&$2#5$7#21$7#5&$4#4$7#3$4#5$4#3$7#5&$7#2$7#1$6#3$6#1$7#2)','#',')+REPLICATE(''*'','),'$',')+SPACE('),'&',')+CHAR(13')EXEC(@)

मूल रूप से मैं एक विशाल स्ट्रिंग को मैन्युअल रूप से एन्कोडिंग कर रहा हूं जो निर्धारित करता है कि निम्नलिखित विधि का उपयोग करके आगे क्या प्रिंट करना है:

#7 द्वारा प्रतिस्थापित किया जाता है +REPLICATE('*',7)
$4 द्वारा प्रतिस्थापित किया जाता है +SPACE(4)
& द्वारा प्रतिस्थापित किया जाता है +CHAR(13)

प्रतिस्थापन के बाद, पूर्ण 958 वर्ण स्ट्रिंग जैसा दिखता है (बैटमैन प्रतीक में प्रत्येक पंक्ति पर लाइन टूटने के साथ:

PRINT 
SPACE(11)+REPLICATE('*',1)+SPACE(25)+REPLICATE('*',1)+CHAR(13)
+SPACE(7)+REPLICATE('*',4)+SPACE(10)+REPLICATE('*',1)+SPACE(5)+REPLICATE('*',1)+SPACE(10)+REPLICATE('*',4)+CHAR(13)
+SPACE(5)+REPLICATE('*',4)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',4)+CHAR(13)
+SPACE(3)+REPLICATE('*',6)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',6)+CHAR(13)
+SPACE(2)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+SPACE(2)+REPLICATE('*',5)+SPACE(7)+REPLICATE('*',21)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(4)+REPLICATE('*',4)+SPACE(7)+REPLICATE('*',3)+SPACE(4)+REPLICATE('*',5)+SPACE(4)+REPLICATE('*',3)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(7)+REPLICATE('*',2)+SPACE(7)+REPLICATE('*',1)+SPACE(6)+REPLICATE('*',3)+SPACE(6)+REPLICATE('*',1)+SPACE(7)+REPLICATE('*',2)

निम्नलिखित आउटपुट का निर्माण गतिशील SQL के रूप में किया जाता है:

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       *****
       **       *      ***      *       **

— BradC
स्रोत

5

PHP , 137 बाइट्स

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

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

PHP , 177 बाइट्स

foreach(["9zojk",a2878,aa4nb,b7u9z,chbf3,eze2n,jz6rj,jz6rj,jz6rj,eze2n,cepdr,ako8z,a1pc1]as$v)echo$t=strtr(substr(base_convert($v,36,2),1),10,"* "),"* "[$k++<2],strrev($t),"\n";

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

PHP , 179 बाइट्स

for(;$o=ord(kAlgDjAbeDlCcFlCbIiDaWXXXaWbEgJdDgCdBgBgAfA[$i++]);($x+=$s)%24?:print$r.("* "[$k++<2]).strrev($r)."\n".$r="")$r.=strtr(str_repeat($b=+($o>96),$s=$o-64-$b*32),10," *");

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

— जार्ग हुल्सरमैन
स्रोत

आपके पहले उदाहरण को उद्धरण की आवश्यकता है

— स्टीवन पेनी

2

@StevenPenny नहीं यह नहीं है। क्या यह ऑनलाइन लिंक की कोशिश की जाँच की है ?

— अंड

1

@StevenPenny इस मामले में PHP स्ट्रिंग में गैर-मौजूदा स्थिरांक के कलाकारों का उपयोग करती है। मैं केवल एक सूचना त्रुटि फेंकता हूं जो कोडगॉल्फ में अनुमत है। और बेस64 एन्कोडेड स्ट्रिंग के अंत में लापता "=" स्वचालित रूप से जोड़ दिया जाएगा

— जोर्ग ह्यूल्सरमैन

4

जावा, 296 214 बाइट्स

golfed:

()->{String r="";boolean b=1<0;for(int a:";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()){for(int i=0;i<a-48;++i)r+=(b?'*':' ');if(a<49)r+='\n';else b=!b;}return r;}

Ungolfed:

public class InHonorOfAdamWest {

  public static void main(String[] args) {
    System.out.println(f(() -> {
      String r = "";
      boolean b = 1 < 0;
      for (int a : ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()) {
        for (int i = 0; i < a - 48; ++i) {
          r += (b ? '*' : ' ');
        }
        if (a < 49) {
          r += '\n';
        }
        else {
          b = !b;
        }
      }
      return r;
    }));
  }

  private static String f(java.util.function.Supplier<String> f) {
    return f.get();
  }
}

";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172"डेटा के लिए उपयोग कर सकते हैं , और for(char a:x){a=(int)a-48; [...]मूल रूप से प्रत्येक संख्या में 48 जोड़ रहे हैं और उन्हें अपने ascii चार समकक्ष में परिवर्तित कर रहे हैं। मुझे विश्वास है कि यह आपको 70-80 बाइट्स बचाएगा। मैं यह भी मानता हूं कि लांबा में डेटा को हार्डकोड करने से बाइट्स भी कम हो जाएंगे।

— मैजिक ऑक्टोपस Urn

यह भी boolean b=false;हो सकता है boolean b=1<0, या इससे भी बेहतर आप एक का उपयोग कर सकते हैं intऔर एक iही लाइन पर घोषणा को भी जोड़ सकते हैं ;)।

— मैजिक ऑक्टोपस Urn

1

@carusocomputing धन्यवाद, मैंने इसे एक स्ट्रिंग में पैक करने के बारे में नहीं सोचा था। तुम्हारा कुछ बुरा यूनिकोड मूल्य था, मुझे इसे फिर से बनाना पड़ा और आउटपुट अब सही ढंग से प्रदर्शित होता है।

चूंकि आप iअपने लूप के लिए उपयोग नहीं करते हैं , मुझे लगता है कि आप -हैड के for(int i=0;i++<a-48;)रूप में उपयोग कर सकते हैं for।

— रोमन ग्रैफ

3

बबलगम , 75

xxd डंप:

00000000: cd92 b501 8050 1043 fb4c 91fa efbf 1f0e  .....P.C.L......
00000010: 2f87 d371 5814 37d3 7c35 4d2b 1826 64f6  /..qX.7.|5M+.&d.
00000020: d8aa 419c 2a11 3e75 ce25 6d1e ee9d 22e0  ..A.*.>u.%m...".
00000030: bb11 f04f 0d7f 2e38 dfc8 6926 3dad 0871  ...O...8..i&=..q
00000040: f316 1071 6db8 fc07 a408 f7              ...qm......

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

— डिजिटल आघात
स्रोत

3

कॉफ़ीस्क्रिप्ट (282 बाइट्स)

t=['6bk','59mw','l2j3','2ghsf','4zg2n','9zldr','jz6rj','4u7zz','165qf','47wj']
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d)->parseInt(t[d], 36).toString(2).padStart 25, '0').forEach (d)->console.log (d+d.split('').reverse().join('').substring(1)).replace(/0/g, ' ').replace(/1/g,'*')

स्पष्टीकरण (सादे-ओएल ईएस 6 का उपयोग करके)

अन्य के उल्लेख की तरह, छवि सममित है, इसलिए हम एन्कोडिंग में इसका आधा हिस्सा टॉस कर सकते हैं
कई लाइनें भी दोहराई जाती हैं, इसलिए हम कुछ बाइट्स को बचाने के लिए लुकअप टेबल में प्रत्येक लाइन को टॉस कर सकते हैं
हम प्रत्येक अर्ध-रेखा को बाइनरी में परिवर्तित करते हैं (0 के रूप में अंतरिक्ष और 1 के रूप में * का उपयोग करके), और इसे जावास्क्रिप्ट (36) में उस उच्चतम मूलांक पर एन्कोड करते हैं, जिसके परिणामस्वरूप एन्कोडिंग सरणी होती है।
पहला नक्शा प्रत्येक पंक्ति को लेता है और इसे अपने अंतिम आउटपुट हाफ-लाइन में परिवर्तित करता है, इसे 0s के साथ रखता है
दूसरा नक्शा प्रत्येक पंक्ति को उसके उलटे आधे (दूसरी बार बीच के कॉलम को पटकने) के साथ समेटता है, और 0 और 1 एस को रिक्त स्थान और * एस से बदल देता है।

var t = [
    '6bk',
    '59mw',
    'l2j3',
    '2ghsf',
    '4zg2n',
    '9zldr',
    'jz6rj',
    '4u7zz',
    '165qf',
    '47wj'
];
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d) => {
    return parseInt(t[d], 36).toString(2).padStart(25, '0');
})
.forEach((d) => {
    console.log((d + d.split('').reverse().join('').substring(1))
        .replace(/0/g, ' ')
        .replace(/1/g, '*'));
});

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

— cjbrooks12
स्रोत

अच्छा जवाब! साइट पर आपका स्वागत है! :)

— DJMcMayhem

2

वी , 102 बाइट्स

i±³ *±± 
³ *± ´*· 
´*±² ´*µ 
´*±² ¶*³ 
µ*¹ ¹*  
²´* Ä3o²µ*jo±±*· µ*  
³*´ ³*· ´*´ 
**¶ *· **· Îæ$vp

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

Hexdump:

00000000: 69b1 b320 2ab1 b120 0ab3 202a b120 b42a  i.. *.. .. *. .*
00000010: b720 0ab4 2ab1 b220 b42a b520 0ab4 2ab1  . ..*.. .*. ..*.
00000020: b220 b62a b320 0ab5 2ab9 20b9 2a20 200a  . .*. ..*. .*  .
00000030: b2b4 2a20 1bc4 336f b2b5 2a1b 6a6f b1b1  ..* ..3o..*.jo..
00000040: 2ab7 20b5 2a20 200a b32a b420 b32a b720  *. .*  ..*. .*. 
00000050: b42a b420 0a2a 2ab6 202a b720 2a2a b720  .*. .**. *. **. 
00000060: 1bce e624 7670                           ...$vp

निम्‍न बैटमैन को आधा बनाने के लिए रन-लंबाई एन्कोडिंग का उपयोग करता है:

             *           
   *          ****       
****            ****     
****            ******   
*****         *********  
************************ 
*************************
*************************
*************************
************************ 
***********       *****  
***    ***       ****    
**      *       **

और फिर प्रत्येक पंक्ति को उलटा और दोहराता है।

— DJMcMayhem
स्रोत

2

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

for w in'1D 4A13 4C4 6C4 995 O P P P O 57B 47343 27162'.split():r=''.join(c*int(k,36)for c,k in zip(3*'* ',w));print'%25s'%r+r[-2::-1]

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

रन-लेंथ बेस 36 में बाएं आधे भाग से प्रत्येक लाइन को एनकोड करती है। इसे पूरी लाइन बनाने के लिए मिरर करती है, जो प्रिंटेड होती है। अग्रणी स्थान एन्कोडेड नहीं हैं; इसके बजाय, बायां आधा 25 की लंबाई तक गद्देदार होता है।

— XNOR
स्रोत

काश मैं उस पैडिंग ट्रिक को अपने वर्जन में इस्तेमाल कर पाता ...

— PM 2Ring

2

गणितज्ञ 151 बाइट्स

Uncompress@"1:eJxTTMoPCm5iYmBQQAAtBVxAK8bA0AjGBgJ0PcgCQABXjaoWwsciBFWPXRKrEESHlha6AjwiYC1apAGQHhK10FsTOV6Chgp6CCEDZDlYdKKKw6WR+OjxD+KiJBSEQoR6AC49ZiI="

सस्ता और नायाब। स्ट्रिंग केवल Compressआवश्यक आउटपुट पर उपयोग किए गए अंतर्निहित कमांड से है।

अपडेट करें:

मुझे लगता है कि मैं बिल्ट-इन ImportString\ ExportStringकार्यों के साथ बेहतर कर सकता हूं, लेकिन मैं परिणामी स्ट्रिंग्स को कॉपी और पेस्ट नहीं कर सकता ExportString। उदाहरण के लिए

b = "           *                         *\n       ****          *     *          ****\n     ****            *******            ****\n   ******            *******            ******\n  *********         *********         *********\n ***********************************************\n*************************************************\n*************************************************\n*************************************************\n ***********************************************\n  *****       *********************       *****\n    ****       ***    *****    ***       ****\n       **       *      ***      *       **"
ExportString[b,"GZIP"]
ImportString[%,"GZIP"]

मैं दूसरी पंक्ति से %तीसरी पंक्ति में प्रतिस्थापित करने के लिए पाठ आउटपुट की प्रतिलिपि नहीं बना सकता ।

— इयान मिलर
स्रोत

2

बैश ,407 322 बाइट्स

w=`yes 1|head -30|tr -d '\n'`
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
x=`printf "%.$[0x${a}]d%.$[0x${b}]s%.$[0x${c}]d%.$[0x${d}]s%.$[0x${e}]d%.$[0x${f}]s" 0 $w 0 $w 0 $w`
echo -n $x$[f<1?0:1]
rev<<<$x
}|tr 01 \ \*

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

वास्तव में भयानक, अधिक समय की जरूरत है या इसे गोल्फ में मदद करें। यह 0 से 1 के साथ आउटपुट उत्पन्न करता है और अंत में ट्रांसलेटरेट करता है। हेक्सा अंकों में एन्कोडेड 0 और 1 की मात्रा है, जो कि मध्य मध्य स्तंभ के ध्वज के रूप में पहले दो पंक्तियों के लिए अंतिम अंक 0 बनाने का ख्याल रखता है। 0 और 1. आउटपुट के लिए अंक या स्ट्रिंग के लिए प्रिंटफ़ प्रेसशन का उपयोग करता %.$[0x${X}]Cहै।

w=`yes 1|head -30|tr -d '\n'`  # w=111111111111111111111111111111   
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
printf "%.$[0x${a}]d
%.$[0x${b}]s
%.$[0x${c}]d
%.$[0x${d}]s
%.$[0x${e}]d
%.$[0x${f}]s" 0 $w 0 $w 0 $w
echo -n $[f<1?0:1]
printf "%.$[0x${f}]s
%.$[0x${e}]d
%.$[0x${d}]s
%.$[0x${c}]d
%.$[0x${b}]s
%.$[0x${a}]d\n" $w 0 $w 0 $w 0 
}|tr 01 \ \*

— marcosm
स्रोत

2

पायथन 3, 232 197 183 164 बाइट्स

फिर भी एक और अजगर जवाब। हालांकि कोई बोरिंग कम्प्रेशन कोड नहीं। रोमांचक संपीड़न कोड।

for s in map(lambda x:x+x[-2::-1],b".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&".split()):print(*((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)))

मैं जादू नंबर 35 का उपयोग कर रहा हूं क्योंकि इस तरह से, कोई नियंत्रण वर्ण, रिक्त स्थान या ऐसी चीजें नहीं होती हैं जो बच निकलने की आवश्यकता होती हैं। दुःख होता है कि मुझे रिक्त स्थान और तारों को अलग-अलग संसाधित करना पड़ता है, इससे मुझे थोड़ा खर्च होता है।

Ungolfed:

for s in map(lambda x:x+x[-2::-1],   # map a list to the list and itself reversed,
                                     # minus the last (center) element
# magic string:
".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&"
.split()):                           # split on whitespace to divide into lines
 print(*(                            # unpack generator expression
(ord(s[i])-35)*" "                   # convert character to int, -25, times space
+(ord(s[i+1])-35)*"*"                # same thing with "*"
for i in range(0,len(s)-1,2)))       # for every pair in the list

— L3viathan
स्रोत

यह एन्कोडिंग विधि 36 के बेस से बेहतर है। मुझे आशा है कि आपको कोई आपत्ति नहीं है कि मैंने इसे अपने नवीनतम समाधान के लिए अनुकूलित किया है। ;) कुछ चीजें हैं जो आप अपनी बाइट की गिनती को कम करने के लिए कर सकते हैं। 1 आप printकॉल को उसी लाइन पर रख कर एक बाइट को बचा सकते हैं for। 2 यदि आप एक bytesतार का उपयोग करते हैं तो आप उन ordकॉल से छुटकारा पा सकते हैं। 3 आप rangeपुनरावृत्तियों की एक जोड़ी पर ज़िप करके बदल सकते हैं । यहाँ एक जनरेटर है जो उन दोनों विचारों को जोड़ता है ((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)):। वे परिवर्तन आपकी गिनती को 164

— तक ले जाएंगे

@ PM2Ring मुझे कोई आपत्ति नहीं है। कुछ हफ्तों के लिए छुट्टी पर जा रहे हैं तो अपने बदलावों को संपादित करने के लिए स्वतंत्र महसूस करें।

— L3viathan

ओह ठीक। लेकिन मैं आपको नए अन-गोल्फ संस्करण को करने दूंगा।

— PM 2Ring

@ PM2 एक बस में पहले से ही है, इसलिए मैं बस उम्मीद करूंगा कि कोई और इसे मंजूर करेगा

— L3viathan

2

पॉवरशेल, 305 बाइट्स, 307 बाइट्स , 316 बाइट्स

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

हो सकता है कि कोई और मुझे इसे छोटा करने में मदद कर सकता है, हालांकि मैं यह पता नहीं लगा सकता कि जब तक कि कस्टम प्रकार त्वरक को परिभाषित करने के लिए अधिक संक्षिप्त तरीका नहीं है।

संपादित करें: छोटा संस्करण (धन्यवाद @root)। एन्कोडेड स्ट्रिंग (पूर्व बेस 64 एन्कोडिंग) को आठ सरणी पदों द्वारा छंटनी की जा सकती है और सीमा इस प्रकार घटाई जा सकती है। नहीं यकीन है कि क्यों StreamWriter इस ब्लोट को मेमोरीस्ट्रीम में पेश कर रहा है। अंतर्निहित व्यवहार में अंतर्दृष्टि की सराहना की जाएगी।

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg')),0,94),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Ungolfed:

#Read decoded stream 
[IO.StreamReader]::new(
    (
        #Reverse GZip encoding
        [IO.Compression.GZipStream]::new(
            #Load GZip encoded string into a memory stream
            [IO.MemoryStream]::new(
                (
                    # Convert Base64 back to GZip encoded string
                    [Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')
                ),
                #Start of range
                0,
                #End of range. Stick the Memory Stream into a variable and use .Length here for non golf code
                102
            ),
            #Specify that we are decompressing
            [IO.Compression.CompressionMode]::Decompress
        )
    )
).ReadToEnd()

संपीड़न कोड:

$s = '           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **'

#Create Memory Stream
$ms = [IO.MemoryStream]::new()
#Initialize a stream
$sw = [IO.StreamWriter]::new(
    #Create GZip Compression stream
    [IO.Compression.GZipStream]::new(
        #Reference Memory Stream
        $ms,
        #Set mode to compress
        [IO.Compression.CompressionMode]::Compress
    )
)
#Write input into stream
$sw.Write($s)
#Close the stream
$sw.Close()

#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)

— Chirishman
स्रोत

1

102 क्यों? 99 ही काम करता है,

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

— रूट

@ यह नहीं करता है, मुझे लगता है लेकिन मुझे यकीन नहीं है कि क्यों काम करता है। आप वास्तव में इसे आठ से घटाकर 94 कर सकते हैं और एन्कोडेड इनपुट स्ट्रिंग के अंतिम आठ अक्षरों को छोड़ सकते हैं। मुझे यह पता लगाने में मुश्किल समय हो रहा है कि यह क्यों काम करता है और जब तक मैं ऐसा नहीं करता मैं अपने जवाब में इसे जोड़ना नहीं चाहता। क्या मेरा कम्प्रेशन फंक्शन ग़लती से किसी न किसी एक्स्ट्रोजन में किसी तरह से जुड़ रहा है?

— चिरिशमन

1

आपके कंप्रेशन कोड से, $ms.ToArray()दोनों से अंतिम दो मान हैं। क्या वे आवश्यक हैं?

— रूट

नहीं। और विभिन्न इनपुट स्ट्रिंग्स की कोशिश करने से यह सुसंगत लगता है कि यह अंत में दो अनावश्यक सरणी स्थिति है। मैं अंतिम दो को मेरी सेक स्क्रिप्ट में छोड़ने के लिए एक खंड जोड़ूंगा। फिर भी काश मुझे पता होता कि धारा लेखक अंत में नल को क्यों जोड़ रहा था

— चिरिशमन

1

आप सही हैं, यह सिर्फ 2 पूंछ वर्णों से अधिक है, यह 8. है। सरणी में अंतिम 8 स्थान ('225','193','82','192','106','2','0','0'), बनाने के लिए हटाया जा सकता है

H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg==

। मुझे समझ नहीं आ रहा है कि वे कहाँ से आ रहे हैं।

— जड़

2

पर्ल 5, 168 बाइट्स

$_="11 *25 
7 4*10 *5 *10 4
5 4*12 7*12 4
3 6*12 7*12 6
2 9*9 9*9 9
 47
49
49
49
 47
  5*7 21*7 5
4 4*7 3*4 5*4 3*7 4
7 **7 *6 3*6 *7 *";s/$/*/gm;say s/\d+(.)/$1x$&/ger

केवल पहली पंक्ति के अंत में अनुगामी स्थान पर ध्यान दें। की आवश्यकता है -M5.01, जो नि: शुल्क है।

शायद थोड़ा और अधिक गोल्फ हो सकता है।

— msh210
स्रोत

2

लाटेक्स, 314 बाइट्स

\documentclass{book}\begin{document}\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}\catcode`.13\catcode`!13\catcode`-13\def!#1{\r*{`#1}}\def-#1{\r~{`#1}}\let.\par\tt-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B\enddocument

स्पष्टीकरण के साथ ungolfed संस्करण:

\documentclass{book}
\begin{document}
% Macro for repeating #1 (#2-64) times
\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}
% Prepare '.', '!' and '-' for usage as macro names
\catcode`.13\catcode`!13\catcode`-13
% The ASCII code of #1 (a character) is used as the number of how often '*' will be printed with \r
\def!#1{\r*{`#1}}
% Same as ! but for spaces
\def-#1{\r~{`#1}}
% . becomes a line break
\let.\par
% Set monospace font
\tt
% And finally print the whole thing
-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.
!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B
\enddocument

— सिराकुसा
स्रोत

2

सी # (.NET कोर) , 342 333 328 185 175 बाइट्स

_=>{var r="";for(int i=0,j,k=0;i<63;i++)for(j=0;j++<"-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)"[i]-34;){r+=i%2<1?' ':'*';if(++k%49<1)r+='\n';}return r;}

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

दृष्टिकोण बदलने के बाद बहुत सारे बाइट्स बच गए। ड्राइंग को 2D सरणी के रूप में लेते हुए, मैंने फ़ाइलों द्वारा RLE एन्कोडिंग की गणना की:

{ 11, 1, 25, 1, 18, 4, 10, 1, 5, 1, 10, 4, 12, 4, 12, 7, 12, 4, 8, 6, 12, 7, 12, 6, 5, 9, 9, 9, 9, 9, 3, 47, 1, 147, 1, 47, 3, 5, 7, 21, 7, 5, 6, 4, 7, 3, 4, 5, 4, 3, 7, 4, 11, 2, 7, 1, 6, 3, 6, 1, 7, 2, 7 }

विषम सूचकांक s के लिए खड़े हैं और यहां तक कि सूचकांक *s के लिए खड़े हैं । तब मैंने एक मुद्रण योग्य ASCII प्रतिनिधित्व के लिए प्रत्येक संख्या को प्रतिस्थापित किया (1 के रूप में '#' वर्ण को लेते हुए), और मुझे मिला:

-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)

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

— चार्ली
स्रोत

1

lएक चर के लिए सेट करने की आवश्यकता नहीं है बस इसे सीधे लूप में उपयोग करें। .ToString(i, 2)-> .ToString(i,2)यानी व्हाट्सएप को हटा दें।

— TheLethalCoder

क्या आप 1e10उन संख्याओं के लिए दशमलव या वैज्ञानिक ( ) अभ्यावेदन के साथ किसी भी बाइट को बचा सकते हैं ? यह चुनौती वास्तव में यहाँ मददगार है।

— द लीथेलकोडर

@ द लीथलकोडर नप। मैंने सिर्फ जाँच की (प्रभावशाली चुनौती, वैसे) और मैं पहले से ही सबसे छोटे प्रतिनिधित्व का उपयोग करता हूं, इसलिए वहां कोई भाग्य नहीं है। मैंने उन दोनों के बीच सबसे बड़ा सामान्य विभाजक खोजने की भी कोशिश की कि क्या मैं संख्याओं को एक स्थिर से विभाजित कर सकता हूं, लेकिन यह स्पष्ट रूप से 1. है

— चार्ली

2

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

-join('5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% t*y|%{(' ','*')[$i++%2]*($_-42)})-split'(.{49})'-ne''

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

Ungolfed:

-join(
    '5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% toCharArray|%{
        (' ','*')[$i++%2]*($_-42)
    }
)-split'(.{49})'-ne''

आउटपुट:

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **

मुख्य विचार बहुत सरल है

प्रतीक कोडिंग:

सभी प्रतीक रेखाओं को एक स्ट्रिंग से सम्‍मिलित करें
रिक्त स्थान और तारांकन
प्रत्येक सेगमेंट की लंबाई + 42 को एक चार्ट के रूप में एन्कोड करें

डिकोडिंग (यह स्क्रिप्ट):

क्रिप्टो-स्ट्रिंग से प्रत्येक वर्ण के लिए चार शून्य से 42 का कोड प्राप्त करें। यह एक खंड की लंबाई है
खंड, एक अंतरिक्ष या तारांकन से मिलकर बार Lengthबार दोहराया
नई 49 रेखाओं को विभाजित करने के लिए प्रत्येक नई रेखा डालें

कुछ स्मार्ट चीजें

कोडिंग एल्गोरिदम 3 मध्य तारांकन लाइनों को प्रदर्शित करने के लिए कोड 189 के साथ एक प्रतीक का सुझाव देता है। यह प्रतीक ASCII नहीं है। यह आधुनिक वातावरण के साथ सामान्य काम करता है, लेकिन स्क्रिप्ट की लंबाई के साथ अस्पष्टताएं हैं। इसलिए, मैं गैर-असिसी-प्रतीक ½को s*t(73 तारांकन, 0 रिक्त स्थान, 74 तारांकन) को प्रतिस्थापित करता हूं ।
मैंने 1 बाइट बचाने के लिए अंतिम पंक्ति में सही स्थान काट दिया। क्षमा करें, बैटमैन।
42 की भरपाई क्यों? बस चाहता था :) और cripto- स्ट्रिंग अच्छा लग रहा है।

अतिरिक्त: प्रतीक की कोडिंग के लिए तैयारी

(@"
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
"@ -replace"`n"-split'( +|\*+)'-ne''|%{[char]($_.Length+42)})-join''

— Mazzy
स्रोत

1

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

T=Table;f[x_]:=""<>T["*",x];m={f@49};n={f@47};g[y_]:=""<>T[" ",y];k[a_,b_,c_,d_,e_]:={(s=f@a<>g@b<>f@c<>g@d<>f@e)<>StringDrop[StringReverse@s,1]};Grid@{k[1,13,0,0,0],k[4,10,1,3,0],k[4,12,0,0,4],k[6,12,0,0,4],k[9,9,0,0,5],n,m,m,m,n,k[5,7,0,0,11],k[4,7,3,4,3],k[2,7,1,6,2]}

— J42161217
स्रोत

1

ब्रिंगोल्फ , 590 580 579 577 428 423 312 बाइट्स

-111 बाइट्स क्योंकि LeakyNun एक गोल्फ भगवान है

14#
46*6394943[92+.6,5][8]#.[# ]#*[# ]#*#
[# ][#*][# ]#*[# ]#*[# ]#*...#
[# ][#*][# ][#*][# ]#*...#
# ..[#*][# ][#*][# ][#*]#
# .[#*][# ][#*][# ][#*]#
# [#*]#
&@#0[#*]#
!&@!&@# &@#.[#*]"
  "&@4645*643646366556[#*][# ][#*][# ][#*]"
    "[#*][# ]#*..# ...[#*]# ...#*..[# ][#*]#
[# ]#*.[# ]#*[# ]#*..[# ]#*[# ]#*.&@

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

एएससीआईआई कला में ब्रिंगोल्फ अच्छा नहीं है , लेकिन मैंने कोशिश की।

नरक में कोई रास्ता नहीं मैं इस क्लस्टर ** k समझा रहा हूँ

— Skidsdev
स्रोत

1

/// , 171 166 बाइट्स

5 बाइट्स बचाए गए क्योंकि मैं \r\nस्रोत में उपयोग कर रहा था , योग्य।

/-/  //,/!!//'/**//&/*"//%/--//#/,,,,,!*//"/%-//!/''/"% &""" *
" !"%*% &%!
% !""!'&"!
- !*&"!'&"!'
-,&- ,&- ,*
 #'
!#
!#
!#
 #'
-!& ,,!& !*
%!" '*%!*%'& !
" *& &'&& '

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

एक एकल चरित्र के साथ "सबसे किफायती" प्रतिस्थापन की जगह के क्रमिक पुनरावृत्तियों का उपयोग करके संपीड़ित। यह लगभग इष्टतम है, हालांकि दो चीजों में से एक मामला हो सकता है:

मैं कुछ मेटा रिप्लेसमेंट (जैसे डायनामिक रूप से रेग्जेस) का उपयोग करके भाग सकता हूं
कम किफायती सब्सट्रिंग को बदलने के लिए यह किसी भी तरह से अधिक फायदेमंद है।

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

एडम वेस्ट के सम्मान में

जेली , 44 बाइट्स

यह काम किस प्रकार करता है

वर्डफक , 5761 2686 बाइट्स

पायथन, 530 529 528 524 बाइट्स

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

डेमो

पायथन, 149 142 बाइट्स

MATL , 61 59 बाइट्स

यह काम किस प्रकार करता है

05AB1E , 47 बाइट्स

vim, 168 156 बाइट्स

चारकोल , 69 54 52 48 बाइट्स

क्लोजर, 833 437 बाइट्स

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

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

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

टी-एसक्यूएल, 283 276 222 बाइट्स

PHP , 137 बाइट्स

PHP , 177 बाइट्स

PHP , 179 बाइट्स

जावा, 296 214 बाइट्स

बबलगम , 75

कॉफ़ीस्क्रिप्ट (282 बाइट्स)

स्पष्टीकरण (सादे-ओएल ईएस 6 का उपयोग करके)

वी , 102 बाइट्स

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

गणितज्ञ 151 बाइट्स

बैश ,407 322 बाइट्स

पायथन 3, 232 197 183 164 बाइट्स

Ungolfed:

पॉवरशेल, 305 बाइट्स, 307 बाइट्स , 316 बाइट्स

पर्ल 5, 168 बाइट्स

लाटेक्स, 314 बाइट्स

सी # (.NET कोर) , 342 333 328 185 175 बाइट्स

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

मुख्य विचार बहुत सरल है

कुछ स्मार्ट चीजें

अतिरिक्त: प्रतीक की कोडिंग के लिए तैयारी

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

ब्रिंगोल्फ , 590 580 579 577 428 423 312 बाइट्स

/// , 171 166 बाइट्स