51

यह केल्विन है । बस 20 प्रतिनिधि प्राप्त करने की कोशिश कर रहा है ताकि यह उपयोगकर्ता PPCG Minecraft सर्वर चैटरूम में चैट कर सके ।

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक में लेता है।

यदि पूर्णांक सम (2, 4, 6, ...) है, तो इस सटीक ASCII कला स्ट्रिंग को प्रिंट या वापस करें:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

यदि पूर्णांक विषम है (1, 3, 5, ...), तो इस सटीक ASCII कला स्ट्रिंग को प्रिंट या वापस करें:

                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

आप मान सकते हैं कि इनपुट हमेशा एक सकारात्मक पूर्णांक है।

दोनों आउटपुट मामलों में वैकल्पिक रूप से प्रत्येक पंक्ति पर "टी" के दाहिने किनारे तक किसी भी संख्या में अनुगामी स्थान हो सकते हैं, और / या एकल अनुगामी न्यूलाइन हो सकती है। ध्यान दें कि प्रत्येक अक्षर के बीच रिक्त स्थान के दो स्तंभ कैसे हैं।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf ascii-art kolmogorov-complexity

— पुराने चैट रिले
स्रोत

54

यदि मैं एक नया उपयोगकर्ता प्रतिनिधि की तलाश में था, तो मैं नाम केल्विन को भी छोड़

— दूंगा

13

@Geobits यह मैं हूँ।

— केल्विन के

52

@ जीबिट्स नो, इट्स मी। मुझे पता था कि अगर मैं इसका वास्तव में खुलासा करता हूं तो कोई भी नहीं उखाड़ लेगा।

— ऑप्टिमाइज़र

19

यह क्यों मायने रखता है कि इसे किसने बनाया? पोस्ट की सामग्री के आधार पर प्रतिनिधि को निरस्त नहीं किया जाना चाहिए?

— हर्ष

19

@ आदर्श सिद्धांत में, हाँ। वास्तव में, लोग त्रुटिपूर्ण हैं। यह चलाने के लिए एक दिलचस्प प्रयोग होगा, उच्च-प्रतिनिधि उपयोगकर्ता रिसेप्शन में अंतर को कम करने के लिए कुछ चुनौतियों को पोस्ट करने के लिए एक नया खाता बनाते हैं।

— जोबिट्स

23

जावास्क्रिप्ट (ईएस 6), 343 336 289 267 265 260 बाइट्स

बस मज़े के लिए ... :) (46 बाइट्स काटने के लिए ज़ूफ़ॉक्स के लिए धन्यवाद, और मुझे अपने दम पर एक और 37 को काटने के लिए प्रोत्साहित करना)

n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')

के रूप में a(4)या समान कहा जाता है । इसे यहाँ आज़माएँ:

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

a=n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
document.getElementById("a").innerHTML = "<pre>"+a(2)+"</pre>";
document.getElementById("b").innerHTML = "<pre>"+a(3)+"</pre>";

<p id="a"></p>
<p id="b"></p>

Expand snippet

मैं से अंकों की स्ट्रिंग में खाली स्थान के सघन किया है 2करने के लिए 8(जैसे 887= 23 रिक्त स्थान)। प्रत्येक अंक को उसके बाद रिक्त स्थान की संख्या के साथ बदल दिया जाता है। 0प्रतिनिधित्व करता है | |, और 1प्रतिनिधित्व करता है __। कुल मिलाकर, यह कार्यक्रम संयुक्त दो तारों (203 + 227 = 430) की तुलना में 170 बाइट्स छोटा है, इसलिए मैं खुश हूं। :)

संपादित करें: किसी भी तरह, यह इस बिंदु पर केवल अन्य प्रविष्टि के समान लंबाई है .... o_o

संपादित करें 2: स्ट्रिंग्स n%2<1?को बदलने n%2?और स्वैप करके कुछ स्थान को बचाया । इस तथ्य का भी लाभ उठाया कि दो तारों की शुरुआत एक और 5 बाइट्स को कम करने के लिए समान है।

संपादित करें 3: |2| एक भयानक बहुत दिखाने के लिए लग रहा था, इसलिए x7 बाइट्स को बचाने के लिए प्रत्येक घटना को सरल बनाया गया । Xufox के सुझावों ने अन्य 40 बाइट्स काट दिए।

संपादित 4: Xufox का सुझाव \nकुल लाइन से 6 बाइट्स हटाकर, वास्तविक लाइन ब्रेक से भुगतान करने का है। बदलने xके लिए 0और __करने के लिए 1, (बुराई हंसी यहाँ सम्मिलित) तो (Regex यहाँ से डालने बहुवचन) के सभी संयोजन, के रूप में वह अपने प्रवेश में किया था, एक अतिरिक्त 16 बाइट्स बचा लिया।

संपादित करें 5: चूंकि मैंने ES6 मानकों का उपयोग करने के लिए चुना है, इसलिए मैंने 2 अंतिम बाइट्स को बंद करने के लिए कस्टम टेम्पलेट स्ट्रिंग प्रक्षेप का उपयोग किया।

— ETHproductions
स्रोत

1

उस नंबर में कुछ होना चाहिए! एक परिपूर्ण घन होने के अलावा, वह :-) आपके जवाब पर वोट नहीं दे सकता है क्योंकि मुझे जावास्क्रिप्ट का कोई पता नहीं है ...

— लुइस मेंडो

1

कैसे के बारे में .replace(/\d/g,d=>' '.repeat(d))?

— सेबेस्टियन साइमन

1

@ETHproductions अच्छा लगा! अब, क्या तुम मेरे उत्तर को हरा सकते हो? केवल 9 बाइट्स जाने के लिए ...;), जब मैं आपके बाइट्स को गिनता हूं, तो यह 289 कहता है, गिडिट काउंटिंग टूल का उपयोग ...

— सेबेस्टियन साइमन

1

हो सकता है कि टेम्पलेट स्ट्रिंग्स का उपयोग करने के बजाय वास्तविक लाइन ब्रेक बनाने में सक्षम हो \n, प्रति पंक्ति एक बाइट को बचाने के लिए?

— सेबस्टियन साइमन

1

अब मुझे आपसे 2 बाइट कम मिली हैं। = पी

— सेबस्टियन साइमन

12

मतलाब, 343 341

a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))

स्टड से इनपुट नंबर दिया गया है।

नमूना रन:

>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

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

1

वह सिर्फ पागल है। +1।

— रायरेंग - मोनिका जूल 28'15

1

@rayryeng हाँ :-) दया है कि मतलाब केवल 36 तक आधार की अनुमति देता है। एक बड़ा मूल्य काफी कुछ बाइट्स बचा होगा

— लुइस मेंडो

1

@LuisMendo अपने जावास्क्रिप्ट समाधान करते समय मैंने जो सोचा था ...

— सेबेस्टियन साइमन

जेएस में @Xufox () और atob () फ़ंक्शन क्रमशः बेस 64 एनकोड और डीकोड हैं।

— ताली

11

CJam, 158 149 145 138 बाइट्स

li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

उपरोक्त कार्यवाहक संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यदि पर्मलिंक आपके ब्राउज़र में काम नहीं करता है, तो आप इस पेस्ट से कोड कॉपी कर सकते हैं ।

उदाहरण चलाते हैं

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

विचार

सीधे MINECRAFT स्ट्रिंग (एक निरंतर लाइन लंबाई को प्राप्त करने के लिए गद्देदार) को एन्कोडिंग करने के बजाय, हम इसका "ज़िप्ड" संस्करण एन्कोड करेंगे, जहाँ पंक्तियों और स्तंभों को ट्रांसपोज़ किया गया है।

लाइनफ़ीड्स को ज़िप करने और निकालने के बाद, इस स्ट्रिंग (इसे आर कहते हैं ) को एनकोड करना होगा:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_

रिक्त स्थान के कई रन हैं, इसलिए हम स्पेसफ़ीड ट्रिप की प्रत्येक घटना को एक लाइनफ़ीड के साथ बदल देंगे।

यह हमें सात अलग-अलग वर्णों ( \n -/\_|) के साथ छोड़ता है , इसलिए हम उनमें से प्रत्येक को 0 से 6 तक एक संख्या प्रदान करते हैं और एक आधार 7 संख्या के परिणामी सरणी अंकों पर विचार करते हैं, जिसे हम तब बाइट स्ट्रिंग के रूप में एन्कोड करते हैं।

ऊपर से चरणों को उल्टा करके डिकोडिंग कार्य करता है।

मूल से दर्पण का निर्माण किया जा सकता है।

यदि हम चार पंक्तियों के क्रम को उल्टा करते हैं और ठोसताओं को स्वैप करते हैं, तो हम निम्नलिखित प्राप्त करते हैं:

\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
                       __    __   __             __  ___

किसी तरह, लेकिन हमें स्पष्ट रूप से नीचे की पंक्ति को शीर्ष पर लाने के लिए पंक्तियों को घुमाना होगा:

                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     |

अगर यह उन pesky अंडरस्कोर के लिए नहीं था तो यह होगा।

अगर हम मूल स्ट्रिंग को ऊपर से नीचे तक पढ़ते हैं और लाइनफीड्स को अनदेखा करते हैं (इस प्रकार आर प्राप्त करते हैं ) और पंक्तियों को शिफ्ट करने से पहले एक अंडरस्कोर के बाद अंतरिक्ष के साथ प्रत्येक अंडरस्कोर की जगह लेते हैं, तो यह परिणाम है:

                         _     _                      _ 
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

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

कोड

li2%           e# Read an integer from STDIN and push its parity.

"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"

281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.

— डेनिस
स्रोत

यह कैसे काम करता है?

— अनातोलीग

@anatolyg मैंने अपना उत्तर संपादित कर लिया है।

— डेनिस

10

पायथ - 182 बाइट्स

बेस एन्कोडिंग दृष्टिकोण का उपयोग करता है। चूंकि पायथन में इंडेक्सिंग मॉड्यूलर है, इसलिए मुझे कुछ भी अजीब नहीं करना है, बस इसे सही क्रम में रखें, और उपयोग करें @Q। एक बोनस के रूप में यह नकारात्मक संख्याओं के साथ भी काम करता है।

@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þKÙ£ÄIOõìæ«FFãbÐÄBØ\«¼,vã<RN>º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q

मेरे पास केवल पहले एक को एन्कोडिंग करने की कोशिश थी, फिर फ्लिपिंग और स्लैश को स्विच करना, लेकिन पहली और आखिरी पंक्ति बहुत कठिन थी।

मैं कोड में वास्तविक नल बाइट्स लगाकर 6 बाइट्स बचा सकता था, लेकिन यह बहुत अधिक परेशानी है।

इसे यहाँ ऑनलाइन आज़माएँ ।

यह ऑनलाइन बहुत बुरा लगता है क्योंकि आउटपुट बॉक्स बहुत छोटा है और लपेटता है। मैं देव-सांत्वना के साथ fiddling और col-md-5करने के लिए एक बदलने की सलाह देते हैं col-md-7।

— Maltysen
स्रोत

दो तारों में डुप्लिकेट वर्णों का एक गुच्छा है, आप 11 बाइट्स को इस तरह निकाल सकते हैं ।

— PurkkaKoodari

8

जावास्क्रिप्ट (ईएस 6), 312, 285, 281, 272, 270, 263, 262, 260

पिछले संपादन के लिए संपादित इतिहास देखें ।

संपादित करें 5: रूपांतरण में, मैंने -(अब 0) और व्हॉट्सएप (अब 1) से जुड़ी संख्या को स्विच कर दिया । परिणामी ब्लॉक में, संख्या 1, 2 और 3 का उपयोग नहीं किया गया था। यह मुझे लापता संख्या के साथ एक सरणी का उपयोग करने की अनुमति देता है।

संपादित करें 6: सरणी शाब्दिक रूप से बेहतर हुई। मैंने यह पहले की कोशिश की, लेकिन इस्तेमाल किया 777और 77संख्याओं के बजाय तार के रूप में और केवल अब ध्यान दिया कि मैंने इसे याद किया था।

संपादित करें 7: "गोल्फ कोड" एक फ़ंक्शन है, जैसा कि प्रश्न द्वारा निर्दिष्ट किया गया है और f=इस विनिर्देश को पूरा करने के लिए कोई आवश्यकता नहीं है । इस प्रकार, इसे हटाकर, दो बाइट्स बचा रहा है।

फ़ायरफ़ॉक्स 39 में चलने योग्य:

// Testing:

f=

// Golfed code:

n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``

// Testing:

;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);

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

यह आधार 6 संख्या प्रणाली पर आधारित है और प्रत्येक ASCII वर्ण संख्या के लिए खड़ा है:

"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5

फिर, मैंने प्रत्येक ASCII स्ट्रिंग की संख्या प्रतिनिधित्व संयुक्त किया है। उदाहरण के लिए: जब पहली ASCII स्ट्रिंग एक में शामिल है /एक की स्थिति में और एक दूसरे को एक में शामिल है \पर एक ही स्थिति , उस स्थिति हो जाता है 32, जो आधार 6 (है 20दशमलव में)। यदि आप इसे आधार 36 में परिवर्तित करते हैं ( प्रत्येक दो आधार -6 संख्याओं के लिए एक आधार -36 संख्या प्राप्त करने के लिए ), तो आप प्राप्त करते हैं ।k

यह सब पहले से किया गया था और फ़ंक्शन मूल रूप से इस प्रक्रिया को पूर्ववत् करता है।

~~अब दो जावास्क्रिप्ट उत्तर दोनों का एक-दूसरे का जवाब है, एक ही बाइट गिनती है ...~~

पुनश्च: खुद के लिए एक नोट और दूसरों के लिए एक संदर्भ के रूप में, यह मेरे द्वारा उपयोग किया जाने वाला कोड है:

// 1. ASCII here
a=`|\\-/ _`;

// 2. ASCII here
b=`/|\\_ -`;

// Note: the ASCII strings’ backslashes have to be escaped!

[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.

— सेबस्टियन साइमन
स्रोत

2

हे गोश, क्यों है ~NaN == -1!

— सेबेस्टियन साइमन

मैं भी लाइन द्वारा ASCII तार लाइन पीछे के बारे में सोचा है, फिर भी अधिक रिक्त स्थान अनुगामी से छुटकारा पाने के (यह भी प्रतिस्थापन में दो बाइट्स बचाया: […][x]+77, 77अब और एक स्ट्रिंग होने की जरूरत नहीं है), लेकिन अतिरिक्त golfed कोड में पीछे यह इसके लायक नहीं बना ...

— सेबेस्टियन साइमन

मुझे यह समझ में नहीं आया जब मैंने पहली बार इसे एक साल पहले पढ़ा था, लेकिन अब मैं तकनीक देखता हूं। चरस के हर जोड़े को एक में मिलाना बहुत चालाक है :-) मुझे लगता है कि आप के isNaNसाथ 1+, और ~~(i/6)साथ बदल सकते हैं i/6|0।

— ETHproductions

Haha, मैं अब एक बाइट के आगे हूँ;)

— ETHproductions

@ETHproductions ठीक है, एक दूसरे को पकड़ो ... मैंने अभी देखा कि आपके पास f=शुरुआत में नहीं है, लेकिन मैं करता हूं। मैंने यह भी पढ़ा कि इसे हटाने के लिए इसे स्वीकार कर लिया गया है, इस प्रकार मैं खुद ऐसा करूँगा, और अब मेरे पास 260 बाइट्स हैं। ;)

— सेबेस्टियन साइमन

6

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

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

उपरोक्त कार्यवाहक संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं।

लाइनफीड पूरी तरह से "पठनीयता" के लिए है। CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यदि पर्मलिंक आपके ब्राउज़र में काम नहीं करता है, तो आप इस पेस्ट से कोड कॉपी कर सकते हैं ।

उदाहरण चलाते हैं

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

विचार

इस दृष्टिकोण में मेरे दूसरे उत्तर में कुछ समानताएं हैं , लेकिन यह बहुत सरल है और (बल्कि निराशाजनक रूप से) थोड़ा कम है।

हम निम्नलिखित स्ट्रिंग को एनकोड करने का तरीका खोजते हैं:

                       __    __   __             __  ___                       __    __                         
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

प्रत्येक पंक्ति को पैडिंग (निरंतर लाइन की लंबाई को प्राप्त करने के लिए), ज़िपिंग (पंक्तियों और स्तंभों को स्थानांतरित करना) और लाइनफ़ीड को हटाने के बाद, इस स्ट्रिंग को एन्कोड करना होगा:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _

हम एक-स्ट्रिंग से बदल देंगे " |||"एक साथ 0 , प्रत्येक स्ट्रिंग " "एक साथ 1 और के पात्रों "/-_\| "के साथ 2 करने के लिए 7 , आधार 8 अंक है, जो एक बाइट स्ट्रिंग के रूप में एन्कोड किया जा सकता की एक सरणी के गठन।

ऊपर से चरणों को उल्टा करके डिकोडिंग कार्य करता है।

कोड

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^Ã 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"

265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.

— डेनिस
स्रोत

"कथित पठनीयता?" : P

— FryAmTheEggman

4

रैकेट, 443 434 386 बाइट्स

(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

लातों के लिए।

(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))

NB आपको #lang racketDrRacket में चलाने के लिए लाइन की आवश्यकता हो सकती है ।

— winny
स्रोत

1

बिल्कुल 100 बाइट्स बंद।

— user253751

1

आओ! मुझे पता है कि आप इसे 343

— ऑप्टिमाइज़र

जब तक मैं इस दृष्टिकोण को नहीं छोड़ता, मैं ऐसा नहीं देखता।

— विनी जूल

आपको आधार 64 वर्णों का उपयोग करने की आवश्यकता नहीं है। आप बस कच्चे यूनिकोड वर्णों का उपयोग कर सकते हैं जो गनज़िप बाहर भेजता है

— MilkyWay90

4

05AB1E , 179 177 176 बाइट्स

"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè

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

स्पष्टीकरण:

•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huÑ¦%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆË²’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•

है संकुचित संख्या :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

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

7в इसे आधार -7 में सूची के रूप में परिवर्तित करता है, इसलिए हमें अंकों की सूची मिलती है:

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]

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

èस्ट्रिंग में प्रत्येक अंक को अनुक्रमित करता है "\n-/\_|", और Jफिर पूरी सूची को एक साथ जोड़ता है, जो हमें निम्नलिखित देता है:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

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

2äस्ट्रिंग को दो भागों में विभाजित करता है।
Ièइनपुट लें, और इसे दो भागों में से एक को प्राप्त करने के लिए (स्वचालित रैप-अराउंड के साथ) अनुक्रमित करें, जो बाद में आउटपुट रूप से किया जा रहा है।

@MagicOctopusUrn के ASCII कंप्रेसर के लिए बहुत धन्यवाद जो संपीड़ित संख्या और बेस -7 ट्रांसलेटरल उत्पन्न करने के लिए उपयोग किया गया था। इसे ऑनलाइन आज़माएं। (जिसके बाद ट्रांसलेट को स्ट्रिंग पर स्ट्रिंग और संख्या को उल्टा करके गोल्फ किया गया है, вइसके बजाय Bइसे अंकों की सूची बनाने के लिए उपयोग करें , और इसके साथ स्ट्रिंग में इंडेक्स करें è।

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

3

सी, 251 बाइट्स

k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

यह एक फ़ंक्शन है kजो एक पैरामीटर प्राप्त करता है और संदेश को प्रिंट करता है stdout।

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

k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character

    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}

सबसे पहले, यह एक खाली संदेश (रिक्त स्थान से भरा) तैयार करता है। प्रत्येक वर्ण (जैसे |या -) के लिए, उस चरित्र को स्थान देने के लिए उसके पदों की एक सूची है।

प्रत्येक स्थिति के लिए, यदि उल्टा संस्करण मुद्रित किया जाना चाहिए, तो स्थिति फ़्लिप की जाएगी। यही है, इसके ऊर्ध्वाधर समन्वय yको बदल दिया जाता है 4-yया 3-y(इस पर निर्भर करता है कि चरित्र एक अंडरस्कोर है)। इसके अलावा, स्लैश की दिशाएं फ़्लिप की जाती हैं - यह एक के XORसाथ किया जाता है 115।

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

इस प्रणाली के साथ कुछ मामूली गड़बड़ियां हैं। सबसे पहले, अंतिम अक्षर T फ़्लिप किए गए संस्करण में थोड़ा अलग दिखता है:

___ 
 |    |
 |    |
 |   _|_

इसे सही ढंग से आउटपुट करने के लिए, कोड को |वर्णों के बाद वर्ण रखना होता है _।

इसके अलावा, यह सुनिश्चित करने के लिए कि नियंत्रण स्ट्रिंग में केवल ASCII वर्ण हैं, मैंने इसे एन्कोड किया है:

यह पदों के बजाय खुद के बीच के अंतर को रिकॉर्ड करता है - यह सीमा को कम करता है
स्ट्रिंग में संख्याओं 37ने उन्हें जोड़ा है, उन्हें ASCII रेंज 32 ... 127 में स्थानांतरित करने के लिए। मैं एक छोटी संख्या जोड़ सकता था, लेकिन 37जैसे पात्रों से बचा जाता है, "और \स्ट्रिंग शाब्दिक के अंदर भागना पड़ता है।
दो में से संख्या 127 से अधिक थी - उदाहरण के लिए, पहला -चरित्र 137 की स्थिति में दिखाई देता है। इसके लिए, मैंने एक -अन्य स्थिति (79) में एक कृत्रिम चरित्र जोड़ा , जिसे बाद में अधिलेखित कर दिया गया - चरित्र |79 की स्थिति में भी दिखाई देता है।

एक और मजेदार बात यह थी कि मैं putsस्ट्रिंग को आउटपुट करने के लिए उपयोग नहीं कर सकता था - यह एक अतिरिक्त अनुगामी न्यूलाइन का उत्पादन करेगा। इसलिए मैंने printfइसके बजाय इस्तेमाल किया।

इसके अलावा, संख्या 57गोल्फ कोड में 4 बार दिखाई देती है - प्रतीत होता है कि लंबी-घुमावदार अभिव्यक्ति (w%2?4-i/6-p/57:p/57)*57+p%57चर को खत्म करना संभव बनाती है y, जिससे कोड छोटा हो जाता है।

— anatolyg
स्रोत

सी ऐसा लगता है कि "इस कोड के साथ हमेशा इस तरह के निर्माण को लिखें" इस तरह की भाषा ... यह ... यह ... बहुत ... उम ... +1;)

— ताली

3

पर्ल, 292 259 246 बाइट्स

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

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

बहु लाइन:

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_

विचार:

चूंकि आउटपुट में केवल 22 अद्वितीय कॉलम हैं, इसलिए इसे 56 कैरेक्टर लुकअप के साथ-साथ 0-17 (सभी संभावित "ड्यूल-अर्थ" अक्षर) की सीमा के साथ 22 * 4 = 88 वर्णों के रूप में संग्रहीत करना संभव है। प्रति स्तंभ 0-21 की सीमा में एक प्रविष्टि के साथ तालिका। सिद्धांत रूप में यह है, लेकिन यह यह डिकोड करने के लिए और अधिक जटिल कोड की वजह से यह एक शुद्ध जीत करना मुश्किल है <100 बाइट्स के साथ इनकोडिंग जा सकता है।

— Samgak
स्रोत

2

आप बाइट्स की एक जोड़ी दाढ़ी कर सकते हैं - y / foo / बार / के लिए टीआर / foo / बार / पर्याय है

— Ryanm

2

सीजेएएम, 206

दो अस्सी चित्र आधार-216 एनकोडेड हैं, एक बाइट = 3 वर्ण हैं।

" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/

इसका परीक्षण यहां करें

— अरनॉड
स्रोत

2

पॉवर्सशेल, 275 253 248 बाइट्स

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

टेस्ट स्क्रिप्ट:

$f = {

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

}

&$f 2
&$f 1

आउटपुट:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

मुख्य विचार

डेनिस D द्वारा संपीड़न विधि CJam की विस्तारित विधि है :

संपीड़न से पहले एक स्ट्रिंग बनाएं:
- दोनों ASCII कला के पहले कॉलम के चार्ट, फिर
- दूसरे कॉलम के वर्ण, तब
- तीसरे कॉलम और इतने पर ...
10 लगातार प्रतिस्थापनों का उपयोग करके संपीड़ित करें (10 क्योंकि पॉवरशेल नंबर 0..9 स्ट्रिंग्स के रूप में उपयोग कर सकते हैं, इससे डिकम्प्रेस एल्गोरिथ्म छोटा हो जाता है। क्रूर बल द्वारा पाया गया प्रतिस्थापन।)

संपीड़न के लिए स्क्रिप्ट:

$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2

$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z

संपीड़न स्ट्रिंग से पहले है:

   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _

— Mazzy
स्रोत

आपके उत्तर की व्याख्या संभवतः मेरे सभी उत्तरों की तुलना में अधिक प्रयास में थी! +1

— मिल्कीवेय 90

1

एसएएस, 442 बाइट्स

%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`

गैर golfed:

%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;

%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;

टेस्ट:

data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

संभवतः उन्हें इनपुट ब्लॉकों में डालकर थोड़ा सा कोड सहेजा जा सकता है, लेकिन यह प्रतिबंध जोड़ता है कि मैक्रो केवल एक बार डेटास्टेप के अनुसार हो सकता है जो मुझे लगता है कि यह मैक्रो के रूप में लिखने की भावना का उल्लंघन करता है। (और मुझे संदेह है कि डेटास्टेप में इनपुट पाने के लिए एक संकेत जोड़ना अधिक वर्ण जोड़ता है)।

— जो
स्रोत

1

बैश, 247 बाइट्स

(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4

तार सुरीले और गज़ब के होते हैं।

— g.rocket
स्रोत

1

PHP, 225 बाइट्स

बदसूरत, जानवर बल समाधान।

echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];

मैंने तब संकुचित किया जब बेस 64 को प्रदर्शित होने के लिए संघटित तारों को एन्कोड किया गया। कोड डिकोड करता है, डिकम्प्रेस करता है और इसे 224 अक्षरों के टुकड़ों में विभाजित करता है। पहला स्ट्रिंग 224 अक्षर है जो एक अनुगामी नई रेखा के बिना है, दूसरा 201 वर्ण है (इसके बाद भी कोई नई पंक्ति नहीं है)। कमांड लाइन तर्क की समता ( $argv[1]%2) द्वारा निर्मित सरणी में सूचकांक के रूप में उपयोग की जाती है str_split()।

— axiac
स्रोत

1

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

m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")

यह थोड़ा हैक है। मैं दो minecraft ग्रंथों के समाप्ती के SHA256 हैश की सराहना कर रहा हूं, और फिर उन्हें अलग करके पैरामीटर x के आधार पर उपयुक्त पाठ का चयन कर रहा हूं। यह बहुत ही अव्यावहारिक है और वास्तविक समय में गणना नहीं की जा सकती है, और यहां तक कि मेरे द्वारा ज्ञात सभी तरीकों से टकराव भी हो सकता है।

क्योंकि हास्केल के पास स्ट्रिंग में उस हैश का ASCII प्रतिनिधित्व नहीं हो सकता है, मैं इसे "a" नामक फ़ाइल से पढ़ रहा हूं, और इसमें मेरे स्कोर में 32 बाइट्स जोड़े गए हैं।

readFile और पैक Data.ByteString.Char8 से है
हैश Crypto.Hash.SHA256 से है

explaination:

replicateM 425"/\\|_- "

425 अक्षरों पर "/ \ _ _-" अक्षरों के प्रत्येक संयोजन की एक सूची बनाता है (दोनों लघु पाठों की लंबाई)

find((==h).hash.pack)

पहले वाले को हैश से मिलाएं

take 225.drop(225*mod x 2)

पहला पाठ 225 अक्षरों का लंबा है, दूसरा एक बिल्कुल 200 है।

— BlackCap
स्रोत

106 बाइट्स, नहीं 138

— बिल्ली

मेरी व्याख्या देखें, मैंने 32 बाइट्स जोड़े क्योंकि मैं एक 32 बाइट लंबी फ़ाइल पढ़ रहा हूँ

— ब्लैकपाप

1

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

(मेरे पिछले उत्तर से स्थानांतरित ) एक नया तरीका आज़मा रहे हैं:

n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`

ध्यान दें कि कुछ अनपेक्षित चरित्र है; इन्हें उदाहरण के साथ बदल दिया गया है \x83।

एन्कोडिंग अपने आप में अन्य की तुलना में लगभग 40 बाइट्स है, लेकिन डिकोडिंग प्रक्रिया अधिक विस्तृत है। मैंने आधार-216 प्रणाली का उपयोग किया है जो दूसरों ने पाठ को एन्कोड करने के लिए उपयोग किया है। संदर्भ के लिए, यहां मेरा उपयोग किया गया कोड है:

// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';

// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/

console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));

यह मूल रूप से ASCII टेक्स्ट (पूर्व-परिवर्तित बेस 6) और इसे अपने आप में जोड़ लेता है, इसे बेस 216 में बदल देता है। 53 को तब अधिकांश गैर-मुद्रण योग्य वर्णों को हटाने के लिए जोड़ा जाता है।

सुझावों का स्वागत है!

यहाँ मूल 403-बाइट कोड है:

a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};

एक forलूप, एक whileलूप, चार चर का उपयोग करना जो केवल एक बार उपयोग किए गए थे, और सरल चीजों के लिए एक टन लंबा एल्गोरिदम। लड़का, क्या मैंने सुधार किया है ...

— ETHproductions
स्रोत

आप शायद पूरी तरह से हटा सकते हैं y=[' ','/','|','\\','_','-'],और y[x]लिखने के बजाय ' /|\\_-'[x]। =)

— सेबस्टियन साइमन

@Xufox मैंने किया है और एक पूरी बहुत अधिक, कुल मिलाकर 107 बाइट्स गोल्फिंग!

— ETHproductions

0

पायथन, 312 बाइट्स

def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

फंक्शन प्रिंट्स आउटपुट को एक इंट देता है

— नीला
स्रोत

हाँ, मैं अभी इसे फिर से नीचे संपीड़ित करने का एक साफ तरीका देख रहा हूं, हालांकि

— ब्लू

यह कैसे काम करता है?

— ओलिवर नी

क्या बेस -36 है? लेकिन यह है अगर क्या 16598125653940296495007405984048067937906981182427207589486265398555496561913976121109917896233762115477615438181875147062369253802653987802486539858466848179256705775331854915993645

— ओलिवर नी

असल में, यह एक सूची में दो परिणामों को संग्रहीत करता है और फिर मापांक फ़ंक्शन का उपयोग करके सही प्राप्त करता है। जैसा कि आपने सोचा था कि यह तब बेस 36 से डिकोड करता है। क्योंकि यह 2 की एक बड़ी शक्ति थी, मैंने कुछ वर्णों को हटाकर >> 69 किया। फिर मैं इसे सही आउटपुट में बदलने के लिए एक मूल अनुवाद फ़ंक्शन का उपयोग करता हूं।

— ब्लू

0

सी, 321 बाइट्स

पुनरावृत्ति और चरित्र सूचकांक को एक स्ट्रिंग में एन्कोड किया गया।

main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}

— कोल कैमरून
स्रोत

0

अजगर 3, 486 533 612

r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1

— ओलिवर नी
स्रोत

0

PHP , 263 बाइट्स

<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

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

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

आप 3 रिक्त स्थान के लिए स्वयं के प्रतिस्थापन के साथ आठ और बाइट्स बचा सकते हैं।

— टाइटस

0

रूबी, 290 बाइट्स

$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

संभवतः एक कमजोर और कामचलाऊ प्रविष्टि। मूल रूप से एक बहुत ही सरल (हैंडक्राफ्टेड) संपीड़न जहां लोअरकेस अक्षर का मतलब है कि कई रिक्त स्थान (वास्तव में ऑर्ड (ch) - 'ए' स्पेस) और अपरकेस अक्षर कुछ सामान्य शब्द हैं जो कुछ बाइट्स को बचाते हैं।

— पीटर लेनकेफी
स्रोत

0

SOGL V0.12 , 72 71 बाइट्स

═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕

यह कोशिश करो!

SOGLs वर्टिकल मिररिंग ने इसके लिए पूरी तरह से काम किया।

— dzaima
स्रोत

0

कैनवस , 70 बाइट्स

Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕

यहाँ यह कोशिश करो!

— dzaima
स्रोत

Minecraft मिरर

जावास्क्रिप्ट (ईएस 6), 343 336 289 267 265 260 बाइट्स

मतलाब, 343 341

CJam, 158 149 145 138 बाइट्स

उदाहरण चलाते हैं

विचार

कोड

पायथ - 182 बाइट्स

जावास्क्रिप्ट (ईएस 6), 312, 285, 281, 272, 270, 263, 262, 260

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

उदाहरण चलाते हैं

विचार

कोड

रैकेट, 443 434 386 बाइट्स

05AB1E , 179 177 176 बाइट्स

सी, 251 बाइट्स

पर्ल, 292 259 246 बाइट्स

सीजेएएम, 206

पॉवर्सशेल, 275 253 248 बाइट्स

मुख्य विचार

एसएएस, 442 बाइट्स

बैश, 247 बाइट्स

PHP, 225 बाइट्स

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

explaination:

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

पायथन, 312 बाइट्स

सी, 321 बाइट्स

अजगर 3, 486 533 612

PHP , 263 बाइट्स

रूबी, 290 बाइट्स

SOGL V0.12 , 72 71 बाइट्स

कैनवस , 70 बाइट्स