स्टैक एक्सचेंज फ़ेविकॉन प्रिंट करें

19

चुनौती

नीचे दिए गए अनुसार, स्टैक एक्सचेंज फ़ेविकॉन को प्रिंट करें या लौटाएँ:

 ___________________
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\__________    _____/
           |  /
           | /
           |/

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है।

code-golf  string  ascii-art  kolmogorov-complexity 
— musicman523
स्रोत
2
क्या शीर्ष बाएं कोने को थोड़ा गलत संकेत दिया गया है?
— ETHproductions
@ETHproductions इसका उद्देश्य था , लेकिन मैं इसे अब बदल रहा हूं। यह किसी भी तरह से अजीब लगता है।
— संगीतज्ञ ५२३
2
संदर्भ के लिए वास्तविक आउटपुट 219 बाइट्स है।
— जुआन
अनुगामी रेखाएँ और / या लाइनों पर अनुगामी रिक्त स्थान की अनुमति है, है ना?
— द्विजिमा
1
— टेलर स्कॉट Scott

जवाबों:

43

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 263 195 बाइट्स

f={r="                   ";t="---------------------\n";s=" ___________________\n/"+r+"\\n"+t+"|"+r+"|\n"+t+"|"+r+"|\n"+t+"\__________    _____/\n           |  /\n           | /\n           |/";s}

नौकरी के लिए सही उपकरण नहीं।

के साथ बुलाना:

hint call f;

आउटपुट:

स्वरूपण विफल रहता है, क्योंकि फ़ॉन्ट मोनोपोज़ नहीं है।

— Steadybox
स्रोत
49
बस क्या आप एक चुनौती को देखते हैं और सोचते हैं "ओह, मुझे जवाब देना चाहिए कि ऑपरेशन फ्लैशपॉइंट में" पहेलियाँ मुझे ...
— जुआन
7
@totallyhuman मुझे लगता है कि इसकी स्क्रिप्टिंग लैंग में लिखने का मज़ा ही कुछ और है। इसकी कुछ विचित्रताएँ और सीमाएँ हैं, इसलिए आपको कभी-कभी कुछ अजीबोगरीब वर्कअराउंड्स का उपयोग करने की आवश्यकता होती है, जो इसे दिलचस्प (अभी तक बहुत व्यावहारिक नहीं) बनाती है।
— स्टैडबॉक्स
5
उत्तर को हार्डकोड करना शायद आपको बेहतर स्कोर देगा।
— निएडजेजकोब जूल
2
@NieDzejkob अब यह आउटपुट को हार्डकोड करने से कम है, लेकिन पिछले संस्करण की तुलना में अधिक उबाऊ है।
— स्टैडीबॉक्स
@totallyhuman और विशेष रूप से इस चुनौती के साथ, मैं यह परीक्षण करना चाहता था कि भाषा कोलमोगोरोव-जटिलता चुनौती के लिए कैसे किराया करेगी (जिसके लिए यह आदर्श से बहुत कम है)।
— स्थिर
11

चारकोल , 38 37 33 30 बाइट्स

←×_χ↓Ｆ/||⟦ι¹¹⟧\×_⁹‖Ｂ_×ψ⁴↙↙³↑↑³

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: एक प्रतिबिंब की मदद से एक बाइट को बचाने के लिए प्रबंधित, हालांकि @CarlosAlejo से पता चलता है कि यह वास्तव में 37 बाइट्स में प्रतिबिंबित किए बिना किया जा सकता है। बाईं ओर the ड्राइंग और अंतिम ing को दर्शाते हुए एक और 4 बाइट्स सहेजे। संपादित करें: पिछला 33-बाइट उत्तर ReflectButterflyOverlap()प्रतिबिंब के साथ ओवरलैप क्षेत्र को ओवरप्रेटिंग न करने पर निर्भर करता था, इसलिए यदि यह व्यवहार बदल गया, तो मैंने एक समाधान की मांग की जो उस पर भरोसा नहीं करता था, और परिणाम वैसे भी कम हो गया, मेरे लिए धन्यवाद एक सरणी मुद्रण का रचनात्मक उपयोग। स्पष्टीकरण:

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     Ｆ/||                       For each character in the string `/||`
          ι                     Current character
           ¹¹                   Integer 11, prints as `-----------`
         ⟦   ⟧                  Put both into an array
                                Implicitly print on separate lines
              \                 Implicitly print `\`
               ×_⁹              Implicitly print 9 `_`s
                  ‖Ｂ            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s
— नील
स्रोत
2
बहुत अच्छा खेला। मुझे लगता है कि इस सवाल का चार चारकोल जवाब है कि प्यार करता हूँ ! ‖ＢＯपिछली बार जब मैंने इसका इस्तेमाल किया था, तब मैं भाषा में नहीं था - मुझे भविष्य के लिए इसे ध्यान में रखना होगा।
— DLosc
मुझे खुद के लिए देखना था कि "अंतिम ¼ को प्रतिबिंबित करने" के साथ आपका क्या मतलब है। वास्तव में अच्छा खेला!
— चार्ली
8

/// , 98 बाइट्स

/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/

इसे ऑनलाइन आज़माएं! या, यह अंतःक्रियात्मक रूप से देखें!

— कोनोर ओ ब्रायन
स्रोत
3
क्या कोई उपयोगिता है जो मुझे एक /// कार्यक्रम के विभिन्न "चरण" देखने की अनुमति देती है? (प्रत्येक प्रतिस्थापन के बाद आंशिक निष्पादन।) इससे मुझे उन्हें बेहतर ढंग से समझने में मदद मिली।
— सीएडी 97
@ CAD97 मैं ऑनलाइन दुभाषिया के साथ चक्कर लगा रहा हूं, और यह आमतौर पर डिबग विकल्पों के साथ आएगा, लेकिन जिस तरह से ऑनलाइन दुभाषिया तर्क देता है, वह उस तरह से कार्य नहीं करता है। आप खुद दुभाषिया की एक प्रति पकड़ सकते हैं और कुछ ऐसा कर सकते हैं perl slashes.pl -d1 code.txt। मैं वर्तमान में /// के लिए एक ऑनलाइन निष्पादन वातावरण पर काम कर रहा हूं, लेकिन इसमें कुछ समय लग सकता है।
— कॉनर ओ'ब्रायन
3
@ CAD97 ने कहा, ऑनलाइन बात उठ रही है, देख लो!
— कॉनर ओ'ब्रायन
8

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

(@ क्रेग आयरे को एक बाइट धन्यवाद दिया।)

let f=

_=>` _19
/ 19\\
-21
| 19|
-21
| 19|
-21
\\_10 4_5/
 11| 2/
 11| /
 11|/`.replace(/.(\d+)/g,([a],b)=>a.repeat(b))
 
 console.log(f());
स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत
लगता है कि आपके पास प्रतिस्थापन कार्य से पहले एक आवारा जगह है। मैं सिर्फ 113 बाइट्स में अपने जेएस समाधान के लिए एक समान अपडेट के साथ आया था। पता नहीं मुझे इसे पोस्ट करना चाहिए या आपके पास होने देना चाहिए।
— झबरा
आह, रुको, अब केवल यह देखकर कि तुमने मेरा पोस्ट करने से पहले अपना समाधान पोस्ट किया। जब मैं कंप्यूटर पर पहुँचता हूँ तो मैं उसे हटा देता हूँ और आप एक बाइट को बचा सकते हैं replace(/.(\d+)/g,(a,b)=>a[0].repeat(b))।
— झबरा
धन्यवाद, झबरा। मैंने इस प्रकार के उत्तर को स्वचालित करने के लिए एक कार्यक्रम लिखा था, और यह मूर्खतापूर्ण था कि यह एक अनावश्यक स्थान का उत्पादन करता था। आपका सुझाया गया replaceकथन निश्चित रूप से एक सुधार है, जिसे मैंने अब अपने कार्यक्रम में शामिल कर लिया है।
— रिक हिचकॉक
1
आप एक बाइट सरणी मिलान बचा सकते हैं a: ([a],b)=>a.repeat(b))?
— क्रेग आयरे
हाँ धन्यवाद! मैं उस वाक्य-विन्यास से अपरिचित था।
— रिक हिचकॉक
7

SOGL V0.12 , 32 31 बाइट्स

^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž

यह कोशिश करो!

स्पष्टीकरण:

...‘               push a quarter of the icon
    Β             palindromize vertically
      ╬⁷           palindromize horizontally (these two should be ╬3 together, but spacing doesn't work correctly (though now it does since I fixed it))
        "...‘      push the extention
             6«8ž  at coordinates [12; 8] in the quad-palindromized image put that in

एक चौथाई:

 __________
/
-----------
|
-----------

और दूसरा हिस्सा:

    
|  /
| /
|/
— dzaima
स्रोत
"togethe"? "गर्त"? इसके अलावा, यह थोड़ी देर के यह पता लगाने की है कि ले लिया .स्पष्टीकरण में मतलब string। शायद उपयोग ^...'और "...'?
— कैलक्यूलेटरफ्लेन
@ कैलाकुलरलाइन मैंने आमतौर पर ...संपीड़ित तारों (उर्फ बकवास) के लिए किया था , लेकिन हाल ही में मैंने एक या दो करना शुरू किया। और मेरी गलतियों और व्याकरण को ठीक करने के लिए स्वतंत्र महसूस करें: p
— dzaima
7

पायथन 2 , 115 बाइट्स, अधिक रचनात्मक विचार

t,u,v,w,x,y,z='\n -/\\_|';k=w+t+11*u+z;i=t+21*v+t
print u+19*y+t+w+19*u+x+(i+z+19*u+z)*2+i+x+10*y+4*u+5*y+k+u,k,k+w

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

पायथन 2 , 102 बाइट्स, उबाऊ विचार

print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')

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

— mdahmoune
स्रोत
2
मैं इसे नीचे वोट कर रहा हूं क्योंकि मैंने इस पद्धति का उपयोग कई बार देखा है। बार-बार देखना उबाऊ है।
— आर। कप
8
@ R.Kap जब तक कोई छोटा रास्ता नहीं होता है, तब तक यह एक मनमाना कारण होता है।
— डेनिस
1
@ डेनिस हो सकता है, लेकिन मैं अभी भी अपनी राय से खड़ा हूं और इसे व्यक्त करने का हर अधिकार है। मैंने इस पद्धति को इस प्रकार की चुनौतियों पर अनगिनत बार इस्तेमाल किया है और इसके लिए ओपी की ओर से किसी भी रचनात्मकता की आवश्यकता नहीं है, जो कि बड़े पहलू हैं, कम से कम मेरी राय में, कोलोमोगोरोव जटिलता चुनौतियों का, और इसलिए डाउन-वोट का मेरा कारण ।
— आर। कप
2
@ R.Kap यदि सामान्य प्रयोजन संपीड़न एल्गोरिदम मैनुअल को आसानी से हरा सकते हैं, तो यह चुनौती की समस्या है, उत्तर की नहीं। मैंने बबलगम को जेली के साथ मारने का प्रबंधन नहीं किया, और विघटन जेली में बहुत कम था।
— डेनिस
2
@ डेनिस मैं यहां कोड लंबाई के बारे में भी बात नहीं कर रहा हूं। मैं प्रयास और रचनात्मकता के बारे में बात कर रहा हूं, जो यह जवाब, मेरी राय में, एक ऐसी भाषा में प्रदर्शित करने में विफल रहता है जहां कोई इतना अधिक कर सकता है, यही कारण है कि मैंने नीचे मतदान किया है। अब, यदि आप मेरे तर्क से असहमत हैं तो ठीक है। उस स्थिति में, हमें सहमत होने के लिए सहमत होना चाहिए और इस बातचीत को यहीं समाप्त होने से पहले ही समाप्त कर देना चाहिए। :)
— आर। काप
6

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

a,b,d,e,f,g,h=' _-|/\\\n';r=d*21+h+e+a*19+e+h;n=f+h+a*11+e;print a+b*19+h+f+a*19+g+h+r*2+r[:22]+g+b*10+a*4+b*5+n+a*2+n+a+n+f

यह ऑनलाइन की कोशिश करो!

— आर। कप
स्रोत
आप कभी उपयोग नहीं करते हैं c, इसलिए आप इसे 3 बाइट्स के लिए समाप्त कर सकते हैं। इसे ऑनलाइन आज़माएं!
— संगीतज्ञ ५२३
@ musicman523 मुझे यह भी नहीं पता कि मैंने वहाँ क्यों लगाया। पकड़ने के लिए धन्यवाद! :)
— आर। काप
6

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

कोड़ी ग्रे के लिए 2 बाइट्स, और केयू गण के लिए 3 बाइट्स धन्यवाद!

#define a"         "
#define s a" "a
#define l"\n---------------------\n"
f(){puts(" ___________________\n/"s"\\"l"|"s"|"l"|"s"|"l"\\__________    _____/\n"a"  |  /\n"a"  | /\n"a"  |/");}

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

— musicman523
स्रोत
2
putsयदि एक अनुगामी नई-रेखा स्वीकार्य है, तो तुच्छ रूप से छोटी होगी।
— कोडी ग्रे
आप उपयोग कर सकते हैं f()के बजाय main()। एक फ़ंक्शन भी स्वीकार्य है।
— कीउ गान
5

जंग , 181 बाइट्स

||" ___________________
/2\\
1
1
3
\\__________    _____/
4|  /
4| /
4|/".replace("1","3
|2|").replace("2",&" ".repeat(19)).replace("3",&"-".repeat(21)).replace("4",&" ".repeat(11))

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

जंग , 184 बाइट्स

यह संस्करण और अधिक गोल्फ के रूप में हो सकता है क्योंकि replaceप्रत्येक में कम लागत वाले बाइट्स को जोड़ना होगा । पहले replaceलूप का हिस्सा नहीं है क्योंकि यह sएक के Stringबजाय एक डबल ड्यूटी को खींचता है &'static str।

||{let mut s=" 5__5__5
/2\\
1
1
3
\\55    5/
4|  /
4| /
4|/".replace("1","3
|2|");for p in vec![("2"," ",19),("3","-",21),("4"," ",11),("5","_",5)]{s=s.replace(p.0,&p.1.repeat(p.2))}s}

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

— CAD97
स्रोत
5

सी, 167 बाइट्स

i;char*d=" q    /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/",c,b;main(j){while(c=d[i++],b=c%5==2||c>123?c:c>95?95:c>45?45:c>=32?32:++c,i<47)for(j=c;j-->=b;)putchar(b);}

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

नोट: ऊपर स्पष्ट स्थानों का एक बहुत वास्तव में टैब चरित्र हैं।

पठनीय संस्करण:

i;
char *d = " q   /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/", c, b;
main(j) {
    while(
        c = d[i++],
        b = c % 5==2 || c > 123 ? c:
            c > 95 ? 95:
            c > 45 ? 45:
            c >= 32 ? 32:
            ++c,
        i < 47
    )
        for(j = c; j-- >= b;)
            putchar(b);
}

स्पष्टीकरण:

डेटा सरणी, d, शाब्दिक एकल वर्णों और कोडित दोहराया वर्णों में उत्तर को एन्कोड करता है। डेटा सरणी में प्रत्येक वर्ण, c, को आधार वर्ण, b, और कई पुनरावृत्तियों में मैप किया जाता है। फिर इसे कई बार छापा जाता है।

जिन वर्णों का उपयोग केवल एकल (स्लैश और पाइप) में किया जाता है उनके पास ASCII कोड 47, 92 और 124 होते हैं। इनमें से दो 5 के शेष के साथ 5 से विभाज्य हैं (c%5=2||c>123)। मुझे तीनों के परीक्षण के लिए एक छोटी शर्त नहीं मिली।

अक्षर जो ASCII कोड 95, 45 और 32 के साथ क्रमशः (अंडरस्कोर, डैश और स्पेस) दोहराए जाते हैं, उन्हें एक उच्च ASCII कोड के साथ कोडित किया जाता है - एक प्रति पुनरावृत्ति में वृद्धि। इसलिए, उदाहरण के लिए, एक एकल स्थान केवल एक स्थान है, लेकिन दो स्थानों को अगले ASCII वर्ण, विस्मयादिबोधक बिंदु द्वारा कोडित किया जा सकता है। जहां एक कोडित चरित्र अनुपयुक्त होगा क्योंकि यह उपरोक्त मोडुलो स्थिति को पूरा करता है, इसे ग्यारह स्थानों का प्रतिनिधित्व करने के लिए # के साथ विभाजित किया जा सकता है। एक ही तकनीक का उपयोग अंतरिक्ष और डैश चरित्र श्रेणियों के बीच ओवरलैप से बचने के लिए किया जाता है।

अंत में, दस नए समाचारों को बाइट्स को बचाने के लिए टैब के रूप में एन्कोड किया गया है जो एक बैकस्लैश के साथ नईलाइन्स से बचने में खर्च किए गए होंगे, फिर मुद्रण के लिए इंक्रीमेंट किया गया ( ++c)।

— Jiv
स्रोत
बहुत बढ़िया! मुझे पता था कि वहां बेहतर सी उत्तर थे।
— संगीतज्ञ ५२३
धन्यवाद! यह एक मजेदार चुनौती थी। मैंने उस पर चार घंटे की तरह कुछ बिताया, इसलिए मुझे खुशी है कि यह अंत में काम किया।
— jiv
4

लकड़ी का कोयला , 49 37 बाइट्स

↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /Ｆ³«Ｐ²¹¶¶

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

अंत में मैं यह थोड़ा गोल्फ सकता है। यह उत्तर (अन्य सभी चारकोल उत्तरों के विपरीत) प्रतिबिंब का उपयोग नहीं करता है, लेकिन अंत के लिए क्षैतिज सलाखों को छोड़कर, एक पास में सभी समोच्च खींचता है।

वर्बोज़ संस्करण से लिंक करें ।

— चार्ली
स्रोत
"अन्य सभी चारकोल जवाब के विपरीत" वास्तव में मेरे पहले उत्तर में प्रतिबिंब का उपयोग नहीं किया गया था, लेकिन मैं यह स्वीकार करूंगा कि मैंने बाईं ऊर्ध्वाधर रेखा के साथ ड्राइंग शुरू करके एक बाइट को गोल करने का मौका नहीं दिया। (हमारे समाधानों के बीच केवल अन्य परिवर्तन यह हैं कि आप उस श्रेणी का उपयोग करते हैं जहां मैंने टाइम्स का उपयोग किया था और आपने \जहां मैंने सिर्फ :UpLeft1 चरण मुद्रित किया था, वहां प्रिंट करें ।)
— नील
हालाँकि ऐसा लगता है कि यह परिलक्षित होने का रास्ता है ...
— नील
यह भी दो बार है कि मेरी कुंजी काम नहीं करती ...
— नील
3

बबल गम , 40 बाइट्स

एक अनुगामी न्यूलाइन को हटाकर 1 बाइट को बचाया, धन्यवाद @ovs!

00000000: 5388 c704 5cfa 0a98 2086 4b17 1be0 aac1  S...\... .K.....
00000010: a2b6 860a 6a63 10ee 0129 0333 f4b9 9035  ....jc...).3...5
00000020: 2a28 a0f1 51b9 fa00                      *(..Q...

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

— musicman523
स्रोत
एक अनुगामी न्यूलाइन के बिना, यह 40 बाइट्स प्राप्त करता है ।
— अंडा
धन्यवाद! मुझे लगता है कि मेरे टेक्स्ट एडिटर ने स्वचालित रूप से एक डाल दिया।
— Musicman523
आपने इसे कैसे बनाया? zlib.compress(s.encode(), 9)46 बाइट्स का आउटपुट देता है, और जवाब zlib लगता है।
— निदेज्जेकोब
प्रति डेनिस के सुझाव , मैं इस्तेमाल किया zopfli --deflateकच्चे हवा निकालना धारा है, तो इस्तेमाल किया उत्पन्न करने के लिए xxdयह XXD प्रारूप में परिवर्तित करने के। मेरा मानना ​​है कि zlibएक चेकसम छोड़ देता है, या किसी अन्य कारण से एक कच्ची ख़राब धारा नहीं है।
— म्यूजिकमैन 523
3

चारकोल , 38 बाइट्स

←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³

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

मैंने अपने मूल रूप में कार्लोस के उत्तर का इस्तेमाल जम्पिंग-ऑफ पॉइंट के रूप में किया, लेकिन प्रतिबिंब का उपयोग करके, क्षैतिज समरूपता का लाभ उठाकर एक अच्छा सा बचा लिया। (ऊर्ध्वाधर समरूपता इसके लायक नहीं थी क्योंकि अंडरस्कोर गलत पंक्ति पर समाप्त हो गया था।) आप यहां प्रत्येक चरण में कैनवास के विकास को देख सकते हैं ।

यहाँ वर्बोज़ संस्करण है ।

— DLosc
स्रोत
btw आप -dप्रत्येक चरण दिखाने के लिए उपयोग कर सकते हैं (यह भी क्षमा करें कि मैं लकड़ी का कोयला बहुत बदल रहा हूं, मुझे यकीन नहीं है कि बहुत से नए विचार बहुत उपयोगी हैं, विशेष रूप से बकरी अस्सी-आर्ट बिलिन और वुल्फराम भाषा का हिस्सा)
— केवल
1
— एएससीआईआई-केवल
3

पायथन 2, 119 117 116 बाइट्स

print''.join(' \n-/|\\_'[ord(x)/8-4]*int('1245abjl'[ord(x)%8],36)for x in' V(8&H(7(@&@(7(@&@(7(HT"S8(%@!8(%@ 8(%@8')

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

थोड़ा यातना रन लंबाई एन्कोडिंग ...

संपादित करें: लंबाई के सेट को बदलकर 3 बाइट्स सहेजें:

[1,2,4,5,10,11,19,21][ord(x)%8]

साथ में

int('1245abjl'[ord(x)%8],36)

— चास ब्राउन
स्रोत
वाह! मैं खुद ऐसा करने के लिए एक प्रभावी तरीका सोचने की कोशिश कर रहा था।
— गैरेथपब्लू
अच्छा कोड है, लेकिन ऐसा लगता है कि यह 119 बाइट्स है?
— mdahmoune
@mdahmoune: काफी सही - उपयोग करना भूल गया r''जब लंबाई की जाँच ...
— चास भूरा
3

सी ++ 11 - 162 159 154 152 150 बाइट्स

MSVC:

void f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i)cout<<string(*i++-97,*i),i++;}

जीसीसी: (+4 चार्ट)

int f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i){cout<<string(*i-97,*(i+1));i+=2;}}

इनपुट स्ट्रिंग iको चार जोड़े में कोडित किया गया है:

  1. दोहराने के लिए वर्णों की गिनती (एक सुयोग्य चरित्र होने के लिए 'क' में जोड़ी गई)
  2. प्रिंट करने के लिए चार

मुझे लगता है, यहां सुधार के लिए अभी भी बहुत जगह है।

संपादित करें:

  1. Cout के साथ प्रतिस्थापित पुछ <<
  2. हटाते समय, वर्णों को दोहराने के लिए स्ट्रिंग कंस्ट्रक्टर का उपयोग करें
  3. सूचक से पहले हटाए गए स्थान और एक शानदार अर्ध-बृहदान्त्र ;;
  4. कॉमा के साथ निर्देश को हटाते हुए, ब्रेसिज़ को हटाते हुए।
— रॉबर्ट आंद्रेजुक
स्रोत
C ++ 11 autoरिटर्न प्रकार के रूप में समर्थन नहीं करता है , यह C ++ 14 की विशेषता है। हालाँकि, आप इसे ठीक कर सकते हैं और वापसी प्रकार बनाकर एक बाइट बचा सकते हैं int। ऐसा नहीं लगता कि यह कोड काम करता है, हालाँकि; क्या आप इसे ऑनलाइन आजमा सकते हैं! और देखें कि क्या आप इसे ठीक कर सकते हैं?
— संगीतज्ञ ५२३
वापसी प्रकार ऑटो को बदला -> शून्य। मैं Visual Studio 2017 पर परीक्षण कर रहा था - स्वचालित रूप से C ++ 14। Gcc के लिए एक संस्करण जोड़ा गया।
— रॉबर्ट आंद्रेजुक जूल
ओह ठीक है, गच्चा। मैं लिनक्स चला रहा हूं इसलिए मेरे पास वी.एस. अच्छी नौकरी!
— संगीतज्ञ ५२३
हाय रॉबर्ट - आपकी रन लंबाई एन्कोडिंग दृष्टिकोण मेरे खुद के समान है; यहाँ देखें । मैं इसके अलावा प्रत्येक (लंबाई, चार) जोड़ी को एक चार के बजाय एक चार में पैक करता हूं। 7 संभावित वर्ण हैं, और 8 अलग-अलग लंबाई हैं; इसलिए मैं ' '..'X'एन्कोडिंग के लिए 56 वर्णों का उपयोग करता हूं ; जो डिकोडिंग के लिए थोड़ा अतिरिक्त ओवरहेड के साथ 40 बाइट्स बचाता है।
— चास ब्राउन
3

R16K1S60 विधानसभा , 152 144 बाइट्स

ASCII में R16K1S60 स्क्रीन परिधीय के लिए आउटपुट लिखता है। पाउडर खिलौना बचाने पर चलाता है2012356 । (जानकारी के लिए हेडर में लिंक देखें)

कार्यक्रम का बाइट आकार संकलित परिणाम है (सेल प्रयुक्त 2 *), न कि विधानसभा।

आप जानते हैं कि जब आप लोगो ने अपने बाइटकोड से ज्यादा जगह ले ली तो आपने अच्छा प्रदर्शन किया है।

a:
mov ex, ip
mov ax, .string
mov sp, ip
mov dx, 0x1000
send sp, dx
.loop:
mov bx, [ax]
cmp bx, ip
je .end
cmp bx, ip
je .newline

shr bx, cx, 8
and cx, 0x00FF
.inner:
send sp, cx
sub bx, ex
jnz .inner
.reentry:
add ax, ex
jmp .loop
.newline:
add dx, 0x0020
send sp, dx
jmp .reentry
.string:
dw 0x0120
dw 0x135F
dw 0x000C
dw 0x012F
dw 0x1320
dw 0x015C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x015C
dw 0x0A5F
dw 0x0420
dw 0x055F
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0220
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0120
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x012F
dw 0x0009
.end:
hlt

व्याख्या

विधानसभा कोड ऊपर एक सरल संपीड़न एल्गोरिथ्म लागू करता है, शब्द 0x000C के साथ एक नई लाइन और 0x0009 निष्पादन को रोकने के लिए कमांड है।

अन्य शब्दों को केवल इस तरह एन्कोड किया गया है: 0xTTCC

  • T: मान को दोहराने के लिए टाइम्स

  • C: ASCII वर्ण मुद्रित करने के लिए

ASM इसके लिए उपलब्ध हर रजिस्टर का उपयोग करता है, जिसमें कुछ कम इस्तेमाल किए जाने वाले भी शामिल हैं:

  • इंस्ट्रक्शन पॉइंटर, कुछ बाइट्स को बचाने के लिए कुछ ज्ञात मूल्यों को त्वरित रूप से प्राप्त करने के लिए (एक इंस्टेंशन में एक निरंतर मूल्य जो इसे रजिस्टर करने के लिए एक अतिरिक्त बाइट का उपयोग नहीं करता है)

  • स्टैक पॉइंटर का उपयोग 6 वें सामान्य प्रयोजन रजिस्टर के रूप में किया जाता है, क्योंकि कोई भी कोड स्टैक का उपयोग नहीं करता है।

केवल AX, BX, CX और DX वास्तव में महत्वपूर्ण डेटा के लिए उपयोग किए जाते हैं। EX और SP का उपयोग कुछ स्थिरांक को संग्रहीत करने के लिए किया जाता है जो अक्सर उपयोग किए जाते हैं।

यह कुछ हद तक सरल है, और इसमें जीतने की संभावना कम है, लेकिन यह लिखने में मजेदार था!

पुराने उत्तर के लिए संशोधन इतिहास देखें (यह ASM के संदर्भ में उतना ही बड़ा है)

funfact: यदि इसे शब्दों में (R16K1S60,16 बिट्स के मामले में) मापा गया था, तो यह 72 बाइट्स में pyth उत्तर से छोटा होगा

— moonheart08
स्रोत
2

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

Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]
— J42161217
स्रोत
2

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

p,u,q,v,r,s,F=' ','_','/','|','-'*21,'\\',lambda f,m:f+m*19+f;B=lambda n:p*11+v+p*n+q
print'\n'.join([F(p,u),q+p*19+s,r,F(v,p),r,F(v,p),r,s+u*10+p*4+u*5+q,B(2),B(1),B(0)])

प्रत्येक पंक्ति बिल्कुल 85 बाइट्स है! Hoorah!

— डैनियल
स्रोत
2

Zsh, 244 बाइट्स

यह विशेष रूप से Zsh के लिए लिखा गया है, न कि बैश के रूप में, क्योंकि यह अजीब वाक्यविन्यास के संदर्भ में थोड़ा अधिक अनुमति देता है।

alias p=printf
function r { p "$1%.s" {0..$2}}
function l { p $1;r $2 19;p $3;p "\n"}
l " " _ " "
l / " " \\
l - - -
l \| " " \|
l - - -
l \| " " \|
l - - -
p \\
r _ 10
r " " 4
r _ 5
p "/\n"
r " " 11
p "|  /\n"
r " " 11
p "| /\n"
r " " 11
p \|/

नोट: जब मैंने इसे tio.run पर चलाने का प्रयास किया , तो आउटपुट मेरे टर्मिनल से भिन्न है। इसे ठीक करने की जगह बदल रही है

function r { p "$1%.s" {0..$2}}

साथ में

function r { p "$1%.0s" {0..$2}}

जो इसे 245 बाइट्स ( लिंक ) बना देगा।

लगता है संपादित करें जैसे मैं उस पोस्ट बटन को हिट करने के लिए बहुत उत्सुक था और मैंने कुछ रिक्त स्थान को याद किया, जिससे मेरा समाधान थोड़ा कम कुशल हो गया। हालांकि मेरा नया आउटपुट बंद है, लेकिन मुझे लगता है कि मैंने सही तरीके से गिना (लेकिन यह वैसे भी लंबाई नहीं बदलेगा)।

— Luca_Scorpion
स्रोत
PPCG में आपका स्वागत है! ध्यान दें कि अंडरस्कोर की निचली रेखा में चार रिक्त स्थान का अंतर है, जो आपके कोड के आउटपुट से गायब है।
— स्टेयडबॉक्स
@Steadybox ओह, मुझे मूर्ख। मैंने उत्तर अपडेट किया है, इसे इंगित करने के लिए धन्यवाद!
— लुका_स्कॉर्पियन
कोई दिक्कत नहीं है! दुर्भाग्य से, मुझे लगता है कि यह अभी भी एक सा बंद है, लेकिन यह इसे ठीक करना चाहिए (और यह आपको एक बाइट भी बचाता है!)।
— स्टडिओबॉक्स
मुझे लगता है कि आप 'फंक फंकनेम {}' के बजाय 'funcname () {}' का उपयोग करके कुछ बाइट्स बचा सकते हैं
— Winny
2

पायथन 2, 159 153 139 बाइट्स

s=" "*19;e="-"*21;a=" "*9;print" %s\n/%s\\\n%s\n|%s|\n%s\n|%s|\n%s\n\%s    %s/\n%s|  /\n%s| /\n%s|/"%("_"*19,s,e,s,e,s,e,"_"*8,"_"*7,a,a,a)

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

EDIT: के %बजाय स्वरूपण का उपयोग करके 6 बाइट्स सहेजे गए .format()।
EDIT: आउटपुट को ठीक करके एक और 14 बाइट्स सहेजा गया है, Musicman523 के लिए धन्यवाद।

— LyricLy
स्रोत
1
यह सटीक पाठ नहीं छाप रहा है (अतिरिक्त लाइनें मौजूद हैं)। इसे ठीक करने से संभवतः कुछ बाइट्स भी बचेंगे।
— अधिकारिक
यहाँ एक निश्चित संस्करण है , जो एक गर्म 139 बाइट्स में आता है
— संगीतज्ञ 523
2

जाप , 79 72 71 बाइट्स

" _p
/ p\\
{"-r
| p|
"²}-r
\\_g a_b/
 h|  /
 h| /
 h|/"r".%l"_g p6nZÅnH

झसे आज़माओ

  • 7 बाइट्स ने पुनरावृत्ति मूल्यों के लिए बेस 32 पूर्णांकों का उपयोग करने के ETHproductions के उत्कृष्ट सुझाव के लिए धन्यवाद बचाया।
— झबरा
स्रोत
बहुत अच्छा संपीड़न विधि। यदि आप उपयोग nHकरते हैं तो आप कुछ और बाइट्स बचा सकते हैं: ethproductions.github.io/japt/…
— ETHproductions
1

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

_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

टेस्ट स्निपेट

f=
_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

O.innerHTML=f()
<pre id=O>
स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत
1

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

↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³

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

कार्लोस की तुलना में कुछ अलग आंतरिक, हालांकि पहली बार में दिखाई नहीं दे रहा है।

— आउटग्रॉफर को एरिक करें
स्रोत
1

,,, , 115 101 98 बाइट्स

मैं पूरी तरह से शर्मिंदा हूं कि यह सबसे अच्छा मैं पैदा कर सकता है। >।>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
— totallyhuman
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.