अपनी सुबह की कॉफी पिएं

Question

इस आस्की कॉफी कप को ड्रा करें:

  ओ
       ओ
    ओ
 __________
/ \ __
| जे | \
| ए | |
| वी | |
| ए | __ /
\ __________ /

कॉफी-स्क्रिप्ट या जावा के लिए ब्राउनी अंक :)

बाइट्स, फंक्शन या प्रोग्राम में सबसे छोटा कोड, न्यूलाइन या व्हाइट स्पेस को पीछे छोड़ना स्वीकार्य है, पीना!

Comments

मुझे एक कप स्पार्कलिंग कॉफी पर बहुत संदेह होगा। ;)

— डेनिस

@ डेनिस इट्स माई स्पेशल कॉफ़ी फ्रॉम फ्राइडे मॉर्निंग;)

— आरोन

यह 2 या अधिक पेय के साथ और अधिक दिलचस्प नहीं होगा: गर्म एक "" ("और") ", ठंड एक चमक के साथ वाष्प का प्रतीक होगा? और रॉड की टिप्पणी से उधार लेकर, कोड को वर्तमान समय के आधार पर एक या दूसरे को प्रदर्शित करना चाहिए।

— मैनटवर्क

क्या लाइनों पर सफेद स्थान को पीछे छोड़ना स्वीकार्य होगा?

— जोनाथन एलन

@Aaron के कप में एक अच्छा पैटर्न नहीं है, हार्ड-कोडिंग / कंप्रेसिंग कई भाषाओं में छोटी होगी

— रॉड

Answer 1

एसओजीएल , 48 बाइट्स

mγmλ⁶…Jcēņ▒&↓¡℮štΥ{ιE‽▼⅛÷εγ╝Ξ∫$■⌡πθ&χF׀▼ΡQ7L↓F¶‘

स्पष्टीकरण:

एसओजीएल में अंतर्निहित स्ट्रिंग संपीड़न है और इसमें से एक चीज एक चार शब्दकोश संपीड़न है। इससे भी बेहतर, यह एक बॉक्सस्ट्रीम संपीड़न प्रकार है जहां केवल उपलब्ध चार्ट "/ \ | _- \ n" हैं। तो पूरा कार्यक्रम "" ("निहित है") में संलग्न एक स्ट्रिंग है।

मैंने जो तार दिया वह कंप्रेसर है (बच गया):

"  o\n       o\n    o\n ",
"__________",
"\n/          \\__\n|   ",
"J",
"      |  \\\n|    ",
"A",
"     |  |\n|     ",
"V",
"    |  |\n|      ",
"A",
"   |__/\n\\",
"__________",
"/"

Answer 2

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

सहेजे गए 4 बाइट्स edc65 की बदौलत

let f =

_=>`1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/`.replace(/\d/g,n=>' _'[n>>3].repeat(++n))

console.log(f())

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

मूल ASCII कला का संपीड़न 2 से 10 लगातार स्थानों के सभी अनुक्रमों को बदलने और एक अंक के साथ 10 लगातार अंडरस्कोर के दो अनुक्रमों द्वारा प्राप्त किया जाता है:

• Nलगातार रिक्त स्थान के प्रत्येक अनुक्रम को अंक के साथ एन्कोड किया गया है N-1।
• अंडरस्कोर अनुक्रम एक के साथ एन्कोडेड हैं 9।

हम N-1इसके बजाय उपयोग करते हैं Nताकि हमें कभी भी एक से अधिक अंकों का उपयोग न करना पड़े। इसलिए ++nजब डिकोडिंग की आवश्यकता हो।

अभिव्यक्ति n>>3(दाईं ओर शिफ्ट) 1 के लिए 0 के बराबर n = 1है n = 7और 1 के लिए बराबर है n = 8(उपयोग नहीं किया गया है) और n = 9। इसलिए, के ' _'[n>>3]लिए एक अंडरस्कोर देता है 9, और अन्य सभी सामना किए गए मूल्यों के लिए एक स्थान।

एकमात्र विशेष मामला "जेएवीए" के ठीक ऊपर 10 लगातार स्थानों का क्रम है। इसे 9अंडरस्कोर अनुक्रमों के साथ संघर्ष के साथ एन्कोड करना। इसलिए हमें इसे 5 स्थानों के दो अनुक्रमों में विभाजित करने की आवश्यकता है, जैसे कि एन्कोडेड 44।

Comments

मैं 108 बाइट्स (गिनती नहीं f=) गिनता हूं । : आप इस तरह से बाइट्स 4 बचा सकता है n>>3के बजाय +!(n&7), 9के बजाय _8(दो बार) और 44के बजाय9

— edc65

@ edc65 मुझे पता नहीं है कि मैंने f=उस एक में क्यों गिना ... सहेजे गए बाइट्स के लिए धन्यवाद!

— Arnauld

क्या आप बता सकते हैं कि रेगेक्स थोड़ा काम कैसे करता है? ऐसा प्रतीत होता है कि यह एक अंक d को प्रतिस्थापित करता है, d रिक्त स्थान ('4' बन जाता है ' ') के साथ। लेकिन यकीन नहीं है कि यह कैसे करता है। बिट शिफ्ट क्या करता है? हम एन को क्यों बढ़ा रहे हैं?

— क्रंचर

@ क्रंचर मैंने 'कैसे काम करता है' अनुभाग जोड़ा है।

— अरनौलद

@ अरनल्ड बहुत चालाक :)

— क्रंचर

Answer 3

जेली , 67 64 बाइट्स

डेनिस के लिए -2 बाइट्स धन्यवाद। (1. निरर्थक हटा दें ”, और 2. प्रतिस्थापन और रन-लेंथ डिकोड को प्रतिस्थापित करें ZŒṙ, तत्व पुनरावृत्ति द्वारा कम करें x/।)

“Ñṁ{xGgṭḷVỤɲ8ṿfƬT9Ɱ¹=qṀS“$<(ƇỤ08ØÑḌṃṘX6~cuc8HṗḞ2’Dx/ị“ ¶_/\|JAVo

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

कैसे?

“...“...’ दो आधार -25 संपीड़ित संख्याओं की एक सूची है:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D अंकों की दो सूचियों को प्राप्त करने के लिए दशमलव में कनवर्ट करता है:

[[1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 3, 3, 2, 4, 1, 1, 5, 3, 2, 6, 1, 7, 1, 6, 1, 5, 2, 6, 1, 8, 1, 6, 1, 6, 2, 6, 1, 9, 1, 6, 1, 6, 2, 6, 1, 8, 1, 6, 3, 4, 2, 5, 3, 3, 4], [2, 1, 1, 7, 1, 1, 4, 1, 1, 1, 5, 5, 1, 1, 5, 5, 1, 2, 1, 1, 3, 1, 6, 1, 2, 1, 1, 1, 4, 1, 5, 1, 2, 1, 1, 1, 5, 1, 4, 1, 2, 1, 1, 1, 6, 1, 3, 1, 2, 1, 1, 1, 5, 5, 1]]

x/ तत्वों की पुनरावृत्ति द्वारा अंकों की एक सूची देने के लिए कम करता है (दूसरे के समान मूल्य द्वारा पहली सूची से संख्या को दोहराता है):

[1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0, 2, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 3, 3, 2, 6, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 6, 1, 1, 5, 2, 6, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 6, 1, 1, 6, 2, 6, 1, 1, 1, 1, 1, 1, 8, 1, 1, 1, 6, 3, 3, 4, 2, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4]

ịइंडेक्स को दाईं ओर की सूची में, एक आधारित और मॉड्यूलर तरीके से (0 इंडेक्स सबसे दाहिने आइटम में) को निर्देश देता है। दाईं ओर की सूची ¶_/\|JAVo, केवल आवश्यक क्रम में उपयोग किया जाने वाला पात्र है, जहां पायलट, एक लाइनफीड ¶के समान कोड-पॉइंट है। समापन भागीदार की “आवश्यकता नहीं है क्योंकि यह कार्यक्रम का अंत है:

[' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', 'o', '\n', ' ', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '\n', '/', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\\', '_', '_', '\n', '|', ' ', ' ', ' ', 'J', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '\\', '\n', '|', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', 'V', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', '|', '_', '_', '/', '\n', '\\', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '/']

जेली इस सूची का एक अंतर्निहित प्रिंट निष्पादित करती है, जिसमें चूंकि इसमें वर्ण होते हैं, जैसे कि यह एक स्ट्रिंग है:

  o
       o
    o
 __________
/          \__
|   J      |  \
|    A     |  |
|     V    |  |
|      A   |__/
\__________/

Comments

मुझे लगता है कि इनमें से कुछ भाषाएँ सीधे कंप्रेशन एल्गोरिदम

— क्रंचर

@ क्रंचर जो बबलगम

— जोनाथन एलन

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

— Cruncher

हां अगर यादृच्छिक। बबलगम वास्तव में संपीड़न का उपयोग कर रहा है, लक्ष्य कोलमोगोरोव जटिलता चुनौतियां हैं और इसलिए इनपुट में पैटर्न (या यहां की तरह कम से कम पुनरावृत्ति) होना चाहिए।

— जोनाथन एलन

फाइनल ”निहित है और आप के ZŒṙसाथ बदल सकते हैं x/। इसके अलावा, जबकि इसके पास कोई बाइट्स नहीं हैं, ¶एक शाब्दिक न्यूलाइन के बजाय कोड का उपयोग करने से कोड अधिक लाल हो जाता है।

— डेनिस

Answer 4

कॉफीस्क्रिप्ट ईएस 6, 214 180 बाइट्स

r="replace";" 1o0n0 6o0n0 3o0n0 _9n0/0 9b0_1n0|0 2J0 5|0 1b0n0|0 3A 4|0 1|0n0|0 4V0 3|0 1|0n0|0 5A0 2|0_1/0n0b0_9/0"[r](/\d/g,(a,b,c)->c[b-1].repeat(a))[r](/n/g,"\n")[r](/b/g,"\\")

कॉफीस्क्रिप्ट, हार्डकोडिंग के साथ 135 बाइट्स

f=()->"""  o
       o
    o
 __________
/          \__
|   J      |  \\
|    A     |  |
|     V    |  |
|      A   |__/
\__________/"""

Comments

कोई अप / डाउन वोट नहीं; मुझे यह उत्तर पसंद नहीं है क्योंकि आम तौर पर कोलमोगोरोव-कॉम्प्लेक्सिटी उत्तर में बिंदु कोड में पूरी चीज़ का उपयोग किए बिना आउटपुट उत्पन्न करना है।

— हाइपरन्यूट्रिनो

@ हाइपर न्यूट्रिनो, मैं मानता हूं, इसे बेहतर बनाने पर काम कर रहा हूं।

— टॉम

Answer 5

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

कोई हार्ड-कोडिंग नहीं।
कोई बेस -64 एनकोडिंग नहीं।
रेगेक्स नहीं।

k=' '
q='_'*10
print'\n'.join([k*i+'o'for i in 2,7,4]+[k+q]+['/'+k*10+'\\__']+['|'+k*s+'JAVA'[s-3]+k*(9-s)+'|'+' _'[s==6]*2+'\\||/'[s-3]for s in 3,4,5,6]+['\\'+q+'/'])

Externalizing द्वारा 2 बाइट्स सहेजा '_'*10और के अजगर के रूपांतरण का दुरुपयोग करके True -> 1और False -> 0।
अनावश्यक व्हाट्सएप को हटाकर 1 बाइट को बचाया।
@TuukkaX के लिए धन्यवाद 4 बाइट्स सहेजे गए!

Comments

आपको कम से 2 बेकार व्हाइटस्पेस है लगता है ] forऔर in [।

— यति

असल में, आप छोटा कर सकते हैं [2,7,4]और [3,4,5,6]करने के लिए 2,4,7और 3,4,5,6।

— यति

Answer 6

पॉवरशेल , 136 124 123 105 बाइट्स

"""2o
7o
4o
 $(($a='_'*10))
/55\__
|3J6|2\
|4A5|2|
|5V4|2|
|6A3|__/
\$a/"""-replace'(\d)','$(" "*$1)'|iex

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

उस छोटी -replaceविधि को खोजने के लिए @briantist का धन्यवाद जो मुझे पता था कि कहीं न कहीं था।

यह रिक्त स्थान की अपेक्षित संख्या के स्थान पर संख्याओं के साथ स्ट्रिंग लेता है। हम -replaceएक स्क्रिप्ट अभिव्यक्ति के साथ अंकों को फिर से जोड़ते हैं $(" "*$1)। इसलिए, उदाहरण के लिए, स्ट्रिंग की पहली पंक्ति होगी $(" "*2)o, दूसरी होगी $(" "*7)oऔर इसी तरह। ट्रिपल-कोटिंग की वजह से, इसे पाइपलाइन पर एक स्ट्रिंग के रूप में छोड़ दिया जाता है। हम इसे iex(संक्षिप्त Invoke-Expressionऔर समान eval) के लिए डंप करते हैं , जो स्क्रिप्ट के भावों को संसाधित करता है और पाइप लाइन पर परिणामी मल्टी-लाइन स्ट्रिंग छोड़ देता है। आउटपुट निहित है।

Comments

यह अजीब है, हार्डकोडिंग कम है। हम्म। +1 फिर भी :)

— हाइपरनेट्रो

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

— हारून

किसी कारणवश शॉर्ट-हैंड अगर / अन्यथा काम करने के लिए प्रतीत नहीं होता है ($_,' '*$_)[+$_-in48..57]- कोई फर्क नहीं पड़ता कि मैं क्या बदल रहा हूं, यह मेरे लिए विफल हो रहा है।

— कुलदेवता

@ConnorLSW ऐसा इसलिए है क्योंकि दोनों अभिव्यक्तियों का मूल्यांकन किया जाता है और अनुक्रमण होने से पहले निर्मित सरणी । नतीजतन, PowerShell को पता नहीं है कि कैसे और कितनी बार गुणा करना spaceहै o।

— AdmBorkBork

@briantist खोजने के लिए धन्यवाद! मुझे पता था कि यह वहाँ था, बस इसे काम करने के लिए उद्धरणों के सही संयोजन के साथ नहीं आ सका।

— AdmBorkBork

Answer 7

GNU sed , 113 112 बाइट्स

s:$:  o@SS o@S o@ UU@/SSS \\__@|SJSS|  \\@|S AS  |  |@|S  VS |  |@|SSAS|__/@\\UU/:
s:S:   :g
y:@:\n:
s:U:_____:g

बुनियादी एन्कोडिंग, यह 3 रिक्त स्थान रखता है S, \nजैसा कि @और 5 के रूप में रेखांकित करता है U। मैं कुछ कम खोजने के लिए संयोजन का प्रयास करता रहूँगा।

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

स्ट्रिंग को सीधे प्रिंट करने का तुच्छ समाधान नीचे दिया गया है। इसमें 136 बाइट्स हैं, जिसके परिणामस्वरूप ऊपर एन्कोडिंग योजना का उपयोग करते हुए, 18% का संपीड़न होता है।

c\  o\
       o\
    o\
 __________\
/          \\__\
|   J      |  \\\
|    A     |  |\
|     V    |  |\
|      A   |__/\
\\__________/

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

Comments

एन्कोडिंग के ssरूप में S1 बाइट बचाता है।

— रिले

@ रिले थैंक्स। मैं भी सिर्फ एक 1 बाइट कम समाधान पाया, S3 रिक्त स्थान के साथ, नहीं s। मुझे लगता है कि मैं इसके बजाय इसे संपादित करूंगा, क्योंकि यह एक ही संख्या में परिवर्तन रखता है।

— शीशमारा

Answer 8

MATL, 87 86 83 82 78 बाइट्स

[TIH][IAC]111Z?c'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

यह समाधान कॉफी को दो टुकड़ों में तोड़ता है: "बुलबुले" और मग। बुलबुले बनाने के लिए, हम तीन स्थानों पर स्थित 111 के साथ एक विरल मैट्रिक्स बनाते हैं और इसे एक चरित्र सरणी में बदलते हैं

[TIH][IAC]111Z?c

मग घटक के लिए, हम स्ट्रिंग संपीड़न पर भरोसा करते हैं

'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

दोनों घटकों को आउटपुट में प्रिंट किया जाता है और घटकों के बीच एक नई रेखा स्वचालित रूप से रखी जाती है

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

Answer 9

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

रॉड के लिए -1 बाइट धन्यवाद ( ('_'*10,)एक घोषणा से बचने के लिए टपल के गुणन का उपयोग करें )।

print''.join('0'<c<':'and' '*int(c)or c for c in'''2o
7o
4o
 %s
/ 9\__
|3J6|2\\
|4A5|2|
|5V4|2|
|6A3|__/
\%s/'''%(('_'*10,)*2))

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

नोट: कि लाइन फीड से पहले डबल बैकस्लैश की जरूरत है।

'''और के बीच सब कुछ '''एक स्ट्रिंग है, दो %sस्वरूपक हैं जो अनुगामी %(...)ट्यूपल की सामग्री द्वारा प्रतिस्थापित हो जाते हैं, जिसमें बदले में '_'*10ट्यूपल गुणन के माध्यम से दो प्रतियां शामिल होती हैं (...)*2। '_'*10प्रदर्शन स्ट्रिंग गुणा उपज के लिए '__________'।

कोड वर्ण, को पार करता c, कि पूरी स्ट्रिंग का उपयोग कर रहा for c in '''...है और में शामिल होने से एक नया स्ट्रिंग बनाता है ( join(...))
या तो द्वारा की पहचान स्थानों की संख्या c, int(c), अगर cएक अंक है
या c खुद को
एक अंकों की जा रही द्वारा पहचाना जाता है - '0'<c<':'से अधिक को बचाने के लिए c.isdigit()।

Comments

आप के u,uसाथ प्रतिस्थापित ('_'*10,)*2और uघोषणा को छोड़ सकते हैं

— रॉड

ओह, अच्छा मैं उस पर ध्यान दिया और लगता है कि वहाँ एक रास्ता था - धन्यवाद @Rod!

— जोनाथन एलन

Answer 10

जावा 8, 294 289 248 बाइट्स

golfed:

()->{String s="";for(char c:"\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()){for(int i=0;i<c>>8;++i)s+=' ';s+=(char)(c&255);}return s;}

कोलमोगोरोव-जटिलता की भावना में , यह स्ट्रिंग को आउटपुट में हार्ड-कोड नहीं करता है। इसके बजाय, यह इस तथ्य का उपयोग करता है कि प्रिंट करने योग्य चरित्र के बाद कई स्थानों के कई मामले हैं। यह उन स्थानों की संख्या को एन्कोड करता है जो चरित्र के उच्च-क्रम बाइट में एक चरित्र से पहले होते हैं, निम्न-क्रम बाइट में वास्तविक ASCII चरित्र के साथ।

Ungolfed:

import java.util.function.*;

public class DrinkYourMorningCoffee {

  public static void main(String[] args) {
    System.out.println(f(
    () -> {
      String s = "";
      for (char c : "\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()) {
        for (int i = 0; i < c >> 8; ++i) {
          s += ' ';
        }
        s += (char) (c & 255);
      }
      return s;
    }
    ));
  }

  private static String f(Supplier<String> s) {
    return s.get();
  }
}

Comments

मुझे लगता है कि उच्च बाइट में एक चरित्र से पहले प्रमुख स्थानों की संख्या को एनकोड करना बेहतर होगा। तो, छह स्थानों से पहले एक 'ए' के ​​रूप में कूटबद्ध किया जाएगा \u0641।

— डेविड कॉनरेड

@DavidConrad दोनों क्यों नहीं? स्ट्रिंग में कहीं भी लगातार दस से अधिक दोहराव नहीं हैं, और दशमलव दस हेक्स में फिट बैठता है F। इसमें दोनों को फिट करना संभव होना चाहिए।

ये एक अच्छा बिंदु है।

— डेविड कॉनराड

@DavidConrad यह दूसरे लूप के कारण फ़ाइल आकार को बड़ा बनाता है जिसे मुझे जोड़ना था। लेकिन मैंने हेक्स को दशमलव स्थिरांक में परिवर्तित करके कुछ बाइट्स बचाए। 0xउपसर्ग खोने से मदद मिली।

दो एन्कोडिंग हैं जो उपयोगी दिखते हैं: रिक्त स्थान की संख्या, और दोहराव की संख्या। आप सही थे: रिक्त स्थान की संख्या को एन्कोडिंग एक शुद्ध लाभ है। मैं कुछ अन्य कोड ( ifउदाहरण के लिए, निरर्थक है) में से कुछ को गोल्फ करने में सक्षम था और आकार का लगभग 1/6 वां हिस्सा बंद कर दिया।

Answer 11

Befunge, 158 105 101 बाइट्स

<v"XaXXXNYXNY77777'XXXXX2_TXQXX0XZTXDXX0X^TXXRX0X^TXXDX07]27777#"p29+55
:<_@#:,g2/+55,g2%+55
\JV/|_Ao

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

स्ट्रिंग में वर्णों को पहले संकेत के रूप में दस संभावित मूल्यों के लुकअप टेबल में एन्कोड किया गया है। सूचकांकों को जोड़े में बांटा गया है, प्रत्येक जोड़ी को 0 से 99 की सीमा में एक ही संख्या (i1 + i2 * 10) में जोड़ा जा रहा है। ध्यान से देखने की मेज के क्रम को चुनकर, हम गारंटी दे सकते हैं कि वे मूल्य हमेशा मान्य होंगे। ASCII वर्ण जिन्हें एक स्ट्रिंग शाब्दिक में दर्शाया जा सकता है।

यह कोड का ही टूटना है:

हम लुकअप तालिका के अंतिम तत्व को एक नए वर्ण (ASCII 10) के साथ आरंभ करके शुरू करते हैं।
हम तब स्टैक पर एन्कोडेड सामग्री को पुश करने के लिए एक स्ट्रिंग शाब्दिक का उपयोग करते हैं।
अंत में हम स्टैक के मूल्यों पर लूप करते हैं, एक बार में दो वर्णों को डिकोडिंग और आउटपुट करते हैं।
अंतिम पंक्ति लुकअप तालिका रखती है: 9 वां तत्व एक निहित स्थान है, और 10 वीं (नई लाइन) मैन्युअल रूप से सेट की गई है, जैसा कि पहले बताया गया है।

Answer 12

रेटिना , 71 बाइट्स

मेरे दूसरे उत्तर से अलग , यह एक हाथ से लिखा गया था।

2o¶6o¶3o¶1=¶/55\__¶|3J6|2\¶|4A5|2|¶|5V4|2|¶|6A3|__/¶\=/
=
10$*_
\d
$* 

(अंत में एक अनुगामी स्थान है)

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

सिद्धांत अभी भी एक "संपीड़ित" स्ट्रिंग है जिसमें से कॉफी के कप को प्रतिस्थापन द्वारा फिर से बनाया जा सकता है। अलग-अलग बारीकियों की कोशिश करने से यह पता चला कि जो करने योग्य हैं वे हैं:

• =में बदल जाता है __________(10 अंडरस्कोर)
• कोई भी अंक रिक्त स्थान की संख्या में बदल जाता है

Answer 13

आम लिस्प, 125 123 122 120 114 बाइट्स

(format t"~3@{~vto
~} ~10@{_~}
/~11t\\__
|   J~11t|  \\
~2@{|~5t~a~11t|  |
~}|~7tA   |__/
\\~10{_~}/"2 7 4'A" V"1)

मैंने 6 बाइट्स को बचाया, ~&एस के बजाय स्ट्रिंग में प्रवेश करने के विचार का उपयोग करके ।

सुधार के लिए विचारों का स्वागत किया।

Answer 14

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

print('  o\n'+7*' '+'o\n'+4*' '+'o\n'+' '+10*'_'+'\n'+'/'+10*' '+'\__\n'+'|'+3*' '+'J'+6*' '+'|  \\\n'+'|'+4*' '+'A'+5*' '+'|  |\n'+'|'+5*' '+'V'+4*' '+'|  |\n'+'|'+6*' '+'A'+3*' '+'|__/\n'+'\\'+10*'_'+'/') 

Comments

इतने सारे अंतरिक्ष वर्ण ... बेहतर रूप से एक s=' 'चर घोषित करते हैं और इसका उपयोग करते हैं।

— मैनटवर्क

इसके अलावा नई लाइन को पूर्वनिर्धारित करने के लिए दुख नहीं होगा

— गेहूं जादूगर

— हार्डकोडिंग

@WheatWizard, मुझे ऐसा नहीं लगता। केवल एकान्त एकांत है। अन्य लोग तार के अंदर हैं, इसलिए एक चर का उपयोग करने के लिए भी एक संचालक ऑपरेटर की आवश्यकता होगी। और 'o\n'जैसी ही लंबाई है 'o'+n।

— manatwork

@manatwork एक हो सकता है: print(*(' o',7*' '+'o',4*' '+'o',' '+10*'_','/'+10*' '+'\__','|'+3*' '+'J'+6*' '+'| \\','|'+4*' '+'A'+5*' '+'| |','|'+5*' '+'V'+4*' '+'| |','|'+6*' '+'A'+3*' '+'|__/','\\'+10*'_'+'/'),sep='\n')या for x in(' o',7*' '+'o',4*' '+'o',' '+10*'_','/'+10*' '+'\__','|'+3*' '+'J'+6*' '+'| \\','|'+4*' '+'A'+5*' '+'| |','|'+5*' '+'V'+4*' '+'| |','|'+6*' '+'A'+3*' '+'|__/','\\'+10*'_'+'/'):print(x), दोनों 197 हैं। अभी भी एक 136 हार्ड कोड से अधिक लंबा है ।

— जोनाथन एलन

Answer 15

पायथ, 80 बाइट्स

r"  o
7 o
4 o
 10_
/10 \__
|3 J6 |  \\
|4 A5 |  |
|5 V4 |  |
|6 A3 |__/
\\10_/"9

ऑनलाइन दुभाषिया यहाँ उपलब्ध है।

सरल रन-लंबाई डिकोडिंग।

Answer 16

सी - 179

प्रारूप स्ट्रिंग के व्यापक उपयोग के साथ समाधान:

void f(){printf("%1$3c\n%1$8c\n%1$5c\n%2$11s\n/%3$13s\n|%4$4c%5$7c%6$3c\n|%7$5c%5$6c%5$3c\n|%8$6c%5$5c%5$3c\n|%7$7c%5$4c__/\n\\%2$s/\n",'o',"__________","\\__",74,'|',92,65,86);}

यहाँ एक अधिक पठनीय संस्करण है:

void f() {
  printf("%1$3c\n"
         "%1$8c\n"
         "%1$5c\n"
         "%2$11s\n"
         "/%3$13s\n"
         "|%4$4c%5$7c%6$3c\n"
         "|%7$5c%5$6c%5$3c\n"
         "|%8$6c%5$5c%5$3c\n"
         "|%7$7c%5$4c__/\n"
         "\\%2$s/\n"
         'o',"__________","\\__",'J','|','\','A','V');
}

Comments

कोड के अंदर कला को मजबूर करने वाला जानवर एक छोटा संस्करण देता है और पुट के साथ प्रिंट करता है: void g(){puts(" o\n o\n o\n __________\n/ \\__\n| J | \\\n| A | |\n| V | |\n| A |__/\n\__________/\n");}

— चूरम

Answer 17

रेटिना , 99 बाइट्स

इस स्क्रिप्ट का उपयोग करके यह समाधान स्वचालित रूप से उत्पन्न किया गया था ।

0 0o¶ 1¶/32\__¶4 J24\¶|3A 34|¶| 3V34|¶|2A   |__/¶\1/
4
|  
3
    
2
      
1
__________
0
  o¶    

(कई लाइनों पर अनुगामी स्थान हैं)

यह कुछ वर्ण अनुक्रमों के स्थान पर संख्या 1,2,3,4 का उपयोग करके काम करता है जो लक्ष्य स्ट्रिंग में दोहराए जाते हैं और फिर उन्हें वापस प्रतिस्थापित करते हैं।

मुझे पता है कि इस कोड को पूरी तरह से बदलकर या पूरी तरह से बदलते दृष्टिकोण से इसे गोल्फ किया जा सकता है, लेकिन चूंकि कोलमोगोरोव मेटा-गोल्फ चैलेंज में काफी निराशाजनक परिणाम था, इसलिए मैं अपनी स्क्रिप्ट का वास्तविक चुनौती पर उपयोग करने की कोशिश करना चाहता था।

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

Comments

तुम एक करने के लिए अंतिम पंक्ति के अंत में सभी रिक्त स्थान की जगह ले सकता 3है और फिर से पहले 3. इसके अलावा, आप बदल सकते हैं करने के लिए प्रतिस्थापन ऊपर ले जाने के 2\n लिए 2\n3 और इससे पहले कि 3. इस प्रतिस्थापन के लिए कदम यह ऑनलाइन कोशिश करो!

— कृति लिथोस

तुम भी बदल सकते हैं 1\n__________करने के लिए 1\n_____और उसके बाद प्रत्येक को बदलने 1मुख्य प्रतिस्थापन में करने के लिए 11 इसे ऑनलाइन कोशिश करो!

— कृति लिथोस

@KritiiLithos जैसा कि मैंने कहा, मुझे पता है कि यह गोल्फ हो सकता है :) मैं बस अपने एल्गोरिथ्म द्वारा सीधे बनाया गया एक समाधान पोस्ट करना चाहता था, शायद मैं एक और उत्तर पोस्ट करूंगा जो मैन्युअल रूप से अनुकूलित है ^ ^

— Leo

Answer 18

अजगर 3.6

(गैर प्रतिस्पर्धा)

यहाँ हफ़मैन एन्कोडिंग में मेरा प्रयास है। यह निश्चित रूप से आगे बढ़ने योग्य है यदि कोई भी विचार लेना चाहता है।

from bitarray import bitarray as b
a=b()
a.frombytes(bytes.fromhex('ca7fca7e53b6db6db664ffc6d9ae1fd6335e2fad1af83d68d7e2e9b218db6db6db20'))
print(''.join(a.decode({k:b(v)for k,v in zip(" _|\no/\\AJV","1 011 010 0011 00101 00100 00011 00010 00001 00000".split())})))

बेसल या अन्य में कनवर्ट करके शाब्दिक को अभी भी संपीड़ित किया जा सकता है, और हफ़मैन पेड़ को अभी भी एक छोटे बिटार्रे का उत्पादन करने के लिए अनुकूलित किया जा सकता है।

Comments

गैर-प्रतिस्पर्धा अमान्यता का बहाना नहीं है।

— मेगो

@ मेरे पास इसे ठीक करने के लिए समय नहीं है, मैं सिर्फ किसी और के साथ समाधान के ढांचे को देना चाहता था। गैर-प्रतिस्पर्धी क्योंकि मैं चुनौती का ओपी था

— हारून

यह वास्तव में कोई फर्क नहीं पड़ता। हमारी नीति स्पष्ट है ।

— मेगो

@ मेगो तय ... बस तुम्हारे लिए

— हारून

Answer 19

गेममेकर लैंग्वेज, 138 बाइट्स

show_message("  o#       o#    o# __________#/          \__#|   J      |  \#|    A     |  |#|     V    |  |#|      A   |__/#\__________/")

Answer 20

सी, 141 बाइट्स

f(){printf("  o\n%7co\n    o\n __________\n/%11c__\n|   J%6c|  \\\n|    A     |  |\n|%6c    |  |\n|%7c   |__/\n\\__________/",0,92,0,86,65);}

प्रयोग

main(){f();}

आसान समाधान, 148 बाइट्स:

w(){puts("  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/");}

Answer 21

PHP, 116 बाइट्स

for(;$c="1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/"[$i++];)echo$c>0?str_repeat(" _"[$c>8],$c+1):$c;

यह अरनौलड्स के उत्तर की तरह दिखता है - और बहुत अधिक समान है। साथ चलाना -r।

Answer 22

zsh, 86 बाइट्स

printf "^_<8b>^H^@^@^@^@^@^B^CSPÈçR^@^A^P^CJÆÃ^A<97>¾^B^\Ä^@¹5@Ú^KÂ^E2cÀ|^EG^X¿^FÂW^HCæÃTÔÄÇësÅÀ^L^Fq^@<92>}ý^?{^@^@^@"|zcat

स्पष्टीकरण: वह स्ट्रिंग गज़िप-संपीड़ित जावा कप अस्की कला है। मैं उपयोग करता हूं printf, क्योंकि इसके साथ echo, zcatएक चेतावनी प्रिंट करता है, और echo -eएक वर्ण लंबा है। यह साथ काम नहीं करता है bashया sh, क्योंकि उन्हें लगता है कि यह एक बाइनरी फ़ाइल है। चूँकि आप ब्राउज़र से उस आउटपुट को प्रभावी रूप से पेस्ट नहीं कर सकते हैं, यहाँ एक प्रयोग करने योग्य फ़ाइल है।

Answer 23

जावा 9 / जेएसहेल, 299 बाइट्स

()->{String s="";BigInteger b=new BigInteger("43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",36);while(!b.equals(BigInteger.ZERO)){int x=b.intValue()&0x3ff;for(int i=0;i<x>>7;i++)s+=' ';s+=(char)(x&0x7f);b=b.shiftRight(10);}return s;}

Ungolfed:

() -> {
    String s = "";
    BigInteger b = new BigInteger(
        "43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",
        36);
    while (!b.equals(BigInteger.ZERO)) { 
        int x = b.intValue() & 0x3ff;
        for (int i = 0; i < x >> 7; i++) s+=' ';
        s += (char)(x&0x7f);
        b = b.shiftRight(10);
    }
    return s;
}

JShell में उपयोग:

Supplier<String> golf = <lambda expression>
System.out.println(golf.get())

निम्न सात बिट्स में कोड बिंदु द्वारा निम्नलिखित उच्च तीन बिट्स में वर्ण से पहले रिक्त स्थान की संख्या की संख्या से युक्त दस बिट्स के रूप में प्रत्येक वर्ण को एन्कोड करता है।

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

अफसोस की बात है, यह इस तुच्छ 140-बाइट जावा समाधान को खो देता है:

()->"  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/"

Answer 24

05AB1E , 85 बाइट्स

•1d'uì[_ÍpH»Ð]jŠ$ÿ{ɘß|ªpå±W¾Ö:ÞjÇ&@è$´Öàˆå]Á¢šBg¦ï&-ã¥ønØ7Ñà'?•9B8ÝJ"o _/\|JAV"‡15ô»

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