29

नहीं, ^^vv<><>BAईस्टर अंडे की तरह नहीं , असली ईस्टर अंडे जो हम पेंट करते हैं।

यहाँ एक (भयानक रूप से तैयार) अंडा है।

  __
 /  \
/    \
|    |
\____/

ईस्टर में, हम उन्हें पैटर्न के साथ पेंट करते हैं। इनकी तरह:

  __
 /--\
/----\
|----|
\____/
  __
 /%%\
/%%%%\
|%%%%|
\____/
  __
 /~~\
/~~~~\
|~~~~|
\____/

चुनौती

अंडे को चित्रित करने के लिए एक चरित्र (प्रिंट करने योग्य अस्की) को देखते हुए, चित्रित अंडे को प्रिंट करें।

उदाहरण:

&:
  __
 /&&\
/&&&&\
|&&&&|
\____/

#:
  __
 /##\
/####\
|####|
\____/

चश्मा

अनुगामी newlines / रिक्त स्थान की अनुमति है।

code-golf ascii-art

— मैथ्यू रो
स्रोत

8

क्यों होता है पतन? यदि आप इस सवाल को पसंद नहीं करते हैं, तो नीचे एक कारण छोड़ दें।

— मैथ्यू रोह

2

एक संभावित कारण यह हो सकता है कि उन्हें नहीं लगता कि यह कार्य पर्याप्त रूप से स्पष्ट या पर्याप्त है। मैं कहूंगा कि यह पर्याप्त स्पष्ट है, और यह सचमुच या तो तुच्छ नहीं है। उस ने कहा, मैं विशेष रूप से उत्साहित नहीं हूं।

— जॉन ड्वोरक

17

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

— दादा

25

अपवित्र क्योंकि इस तरह की सरल चुनौतियां मेरे जैसे शुरुआती लोगों के लिए गोल्फ में आसानी करने के लिए बहुत अच्छी हैं।

— झबरा

7

Poof! तुम एक ईस्टर अंडे हो। (क्षमा करें, विरोध नहीं कर सकता)

— जॉर्ज कमिंस

16

ब्रेन-फ्लैक , 270 268 266 + 1 = 267 बाइट्स

-cझंडे से +1

(((((((((({}<(((([(()()())]((((((((((({}){}){}){}){}[()]))<>)<>{}())))))<>)<>(((()()()()()){}))({}()){})<>)<>>))))<<>({}<>)((()()()()()){})<>({}<>)>))))<<>((({})<>)({})<((()()()()()){})>[()()])>))<>((((({})<>)[(()()()()())({}){}])<((()()()()()){})<>((({}<>){}()))>))

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

मैं एक स्पष्टीकरण लिखने जा रहा था, लेकिन मैंने पहले एक झपकी ली और यह भूल गया कि यह पूरा विचार कैसे काम करता है। तुम्हारा अंदाज़ा मेरी तरह सटीक है।

— गेहूं का जादूगर
स्रोत

14

यह सबसे अच्छा स्पष्टीकरण है जो मैंने कभी यहां पढ़ा है। +1

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

12

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

सुपर स्ट्रेट-फॉरवर्ड। इसे ऑनलाइन आज़माएं ।
-1 बाइट, @ mbomb007 के लिए धन्यवाद

print r'''  __
 /~\
/~~\
|~~|
\____/'''.replace('~',input()*2)

— मृत पोसुम
स्रोत

1

62 बाइट्स

— mbomb007

@ mbomb007 अच्छा एक, धन्यवाद

— मृत पोसम

2

आप इस

— लंबोतरा

@ कीर्तनप्रभाकरन, मुझे यकीन नहीं हो रहा है कि लांबाडा आसिकी चुनौतियों के लिए ठीक है

— डेड पोसुम

1

Ascii चुनौतियों में लैम्ब्डा का उपयोग करने में क्या समस्या है? वे भी कैसे संबंधित हैं !? : ओ

— कीर्तन प्रभाकरन १17

10

चारकोल , 30 26 16 बाइट्स

दो बाइट्स आकार बनाने के बाद भरने से @Neil के लिए धन्यवाद बचाया

__↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ

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

व्याख्या

कार्यक्रम पहले अंडे के दाहिने आधे हिस्से को बनाने के द्वारा काम करता है, और फिर इसे बाएं आधे को उत्पन्न करने के लिए प्रतिबिंबित करता है।

__↗¹                          Write the two bottom _s and write the /
←↑¹                           Move left and write the |
↖²                            Then write two \s
↓_                            And the top _
‖Ｍ←                          Reflect the canvas to the left
¤Ｓ                           Fill the shape with the string input

— क्रिक्टी लिथोस
स्रोत

←_↘हो सकता है, ↓_लेकिन वास्तव में आप 16 बाइट्स को प्रतिबिंबित करने के बाद भर सकते हैं __↗¹←↑¹↖²↓_‖Ｍ←¤Ｓ:।

— नील

@ नील मुझे शुरू करने के लिए धन्यवाद¤

— क्रिस्सी लिथोस

9

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

Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ

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

कैसे?

Ḥ;“ ¶/\|_”“Ṁ¢ṚR;ḳ}AṠ’ṃ - Main link: character c  e.g. '~'
Ḥ                      - double c: ['~','~']
  “ _¶/\|”             - string literal: [' ','_',<newline>,'/','\','|']
 ;                     - concatenate c:  [['~','~'],' ','_',<newline>,'/','\','|']
          “Ṁ¢ṚR;ḳ}AṠ’  - base 250 number: 3067183430901851641706
                     ṃ - base decompression with reversed @rguments:
                       -     take the number and convert it to a base length(the list)
                       -     then index (1-based) into that same list.
                       -     i.e.: 3067183430901851641706 in base 7
                                 = 22003241534115361163500004
                                   indexed into [['~','~'],' ','_',<newline>,'/','\','|']
                                 = [' ',' ','_','_',<newline>,' ','/',['~','~'],'\',<newline>,'/',['~','~'],['~','~'],'\',<newline>,'|',['~','~'],['~','~'],'|',<newline>,'\','_','_','_','_','/']
                       - implicit print:  __
                                         /~~\
                                        /~~~~\
                                        |~~~~|
                                        \____/

— जोनाथन एलन
स्रोत

3

मैं ṃएक एकल बाइट के सबसे लंबे समय तक स्पष्टीकरण के लिए आपकी व्याख्या को नामांकित करता हूं ।

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

ऐसा लगता है कि यह एक बहुत ही आसान परमाणु बन गया है, मैंने सोचा कि इसे थोड़ा समय दे दूंगा!

— जोनाथन एलन

2

मैं देख रहा हूँ कि डेनिस इसका भरपूर उपयोग कर रहे हैं, यह पहली बार है जब मुझे ऐसा लग रहा है कि मैं वास्तव में इसे समझ गया हूँ; समय बर्बाद नहीं हुआ! आपने मुझे 1 इकाई दी है।

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

1

वैसे यह मेरे शिशुओं में से एक है :)

— जोनाथन एलन

6

सेड, 43 वर्ण

s:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:

नमूना रन:

bash-4.3$ sed 's:.:  __\n /&&\\\n/&&&&\\\n|&&&&|\n\\____/:' <<< '★'
  __
 /★★\
/★★★★\
|★★★★|
\____/

— आदमी काम पर है
स्रोत

ठीक यही मैंने लिखा है, बस कुछ सेकंड तेजी से।

— रिले

6

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

मुझे यकीन है कि मैं इससे थोड़ा और निचोड़ सकता हूं - \एस से बचने के लिए मुझे परेशान कर रहा है।

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

console.log(f`-`)
console.log(f`%`)
console.log(f`~`)
console.log(f`&`)
console.log(f`#`)

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

4 बाइट्स s=c+cको पहले सेट के अंदर वेरिएबल असाइनमेंट को मूव करके सेव किया जाता है {}।
2 बाइट्स का उपयोग करके बचाया c+=cबजाय s=c+cऔर s=s+s, के हिस्से में धन्यवाद के साथ नील जो एक ही समय में यह सुधार देखा के रूप में मैं इसे बना रही थी।

अपनी खुद की पेंट!

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

f=

c=>`  __
 /${c+=c}\\
/${c+=c}\\
|${c}|
\\____/`

o.innerText=f` `;i.addEventListener("input",function(){o.innerText=f(this.value||" ");})

<input maxlength="1" id="i">
<pre id=o></pre>

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

— झबरा
स्रोत

यह थोड़ा बेहतर होगा अगर आप उन इनपुट को <pre><code>एस में रखते हैं। हालांकि अच्छी नौकरी।

— मैथ्यू रो

धन्यवाद, @SIGSEGV कंसोल सफेद स्थान को संरक्षित करते हैं और, डिफ़ॉल्ट रूप से, कम से कम, एक मोनोसैप्ड फ़ॉन्ट का उपयोग करते हैं, इसलिए आउटपुट को ए की आवश्यकता नहीं है pre।

— झबरा

1

क्यों नहीं c+=c?

— नील

धन्यवाद, @ नील, मैं बस अपने आप में संपादन कर रहा था, लेकिन मैं आपको फिर से एक संकेत देने के लिए फिर से अपडेट करूँगा।

— झबरा

@ अरनल्ड आपको f=\nबाइट की गिनती के लिए भाग की गणना करने की आवश्यकता नहीं है । इतना ही स्निपेट चलता है।

— AdmBorkBork

5

ऐलिस , 53 52 बाइट्स, गैर-प्रतिस्पर्धात्मक

परोक्ष रूप से 1 बाइट बचाने के लिए लियो को धन्यवाद।

/o *^i}'.*[;.h~r}}~"{.[^\\
@"S .^~ y~a}~~.["{!~"}^^^

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

दुर्भाग्य से, मुझे yइस काम को करने के लिए (लिप्यंतरण) के साथ एक बग को ठीक करना पड़ा , इसलिए मैंने इसे गैर-प्रतिस्पर्धी के रूप में चिह्नित किया है।

व्याख्या

मूल विचार अंडे की एक स्ट्रिंग बनाने के लिए है, लेकिन इनपुट की दो प्रतियों के ~लिए प्लेसहोल्डर के रूप में है। हालांकि, इनपुट के अन्य वर्ण विशेष रूप से ऐलिस स्ट्रिंग्स के लिए अनुकूल नहीं हैं, क्योंकि उन में लाइनफ़ीड नहीं हो सकता है, और सभी को भागने की आवश्यकता होगी (क्योंकि उन्हें दर्पण और दीवारों के रूप में माना जाता है)। इसलिए मैं इन के लिए प्लेसहोल्डर्स का उपयोग करके कुछ बाइट्स बचा सकता हूं, और फिर उनका अनुवाद कर सकता हूं। के लिए प्लेसहोल्डर हैं , जो कि उनके प्रतिनिधित्व करने से ठीक पहले चरित्र हैं। मेरे द्वारा उपयोग किए जा रहे लाइनफीड के लिए ।/\_|/\_|.[^{}

अब कोड ... पूरे कार्यक्रम को ऑर्डिनल मोड में हल किया जा सकता है क्योंकि हमें केवल स्ट्रिंग प्रसंस्करण और पूर्णांक की कोई प्रसंस्करण की आवश्यकता नहीं है। इसके अलावा, हमें किसी भी सशर्त नियंत्रण प्रवाह की आवश्यकता नहीं है। पूरे कार्यक्रम को रैखिक रूप से व्यक्त किया जा सकता है। कार्यक्रम की सामान्य संरचना यह है:

/...//
@....

इस तरह के एक कार्यक्रम में, आईपी ...अनुभाग के माध्यम से ऊपर और नीचे उछलता है , पहले केवल आधे पात्रों को निष्पादित करता है। फिर /अंत में दो आईपी को एक सेल द्वारा दाईं ओर ले जाते हैं, ताकि रास्ते में यह दूसरे आधे (फिर से ऊपर और नीचे उछलते हुए) को निष्पादित करे जब तक @कि कार्यक्रम समाप्त न हो जाए । इसलिए यदि हम बीच में अजीब वक्र संरचना को प्रकट करते हैं, तो हम जिस प्रोग्राम को निष्पादित कर रहे हैं वह वास्तव में इस तरह दिखता है:

"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So

आइए इससे गुजरते हैं:

"  ^^} .~[}.~~[}{~~{}[^^^^."
      This first string is simply the egg template I've talked about.
"!}"  Push this string. It covers all the characters we need to replace
      in the template except ~.
r     Range expansion. Turns '!}' into '!"#$...z{|}'.
.     Duplicate.
h~;   Split off the first character, swap it to the top and discard it.
a*    Append a linefeed.
      We've now basically rotated the string to the left, but appended
      a linefeed instead of the exclamation mark we've shifted off.
      This maps each character in the string to the next one, except }
      which gets mapped to a linefeed.
y     Transliterate. Since the strings have the same length, this just maps
      each character in the first string to the corresponding character in
      the second string, replacing all of our placeholder characters.
'~    Push "~".
i.*   Read the input and duplicate it.
S     Substitute all "~" with the doubled input.
o     Output the result.

— मार्टिन एंडर
स्रोत

: D यह यहाँ है !! यह भाषा निफ्टी लगती है

— कॉनर ओ'ब्रायन

@ ConorO'Brien धन्यवाद। यदि आप अधिक नमूने देखना चाहते हैं, तो मैंने इसके साथ कुछ पुरानी चुनौतियों को पहले ही हल कर दिया है। :)

— मार्टिन एंडर

4

पॉवरशेल , 50 49 48 बाइट्स

'  __
 /11\
/1111\
|1111|
\____/'-replace1,$args

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

सीधे स्ट्रिंग को शाब्दिक स्ट्रिंग में बदलना। गोल्फ के लिए ज्यादा जगह नहीं।

हाइपरनेट्रिनो के लिए -1 बाइट धन्यवाद; -1 बाइट्स शुक्रिया शुक्रिया

— AdmBorkBork
स्रोत

4

गाजर , 34 बाइट्स, गैर-प्रतिस्पर्धात्मक

  __
 /##\\
/####\\
|####|
\\____/

गैर-प्रतिस्पर्धा क्योंकि मैंने सिर्फ प्रमुख व्हाट्सएप में दुभाषिया के साथ बग को तय किया है जो नहीं दिखाया जा रहा है।

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

सबसे पहले, हम कैरेट-मोड में हैं, जहां हर पात्र "स्टैक" में धकेल दिया जाता है। और अंत में "स्टैक" आउटपुट के रूप में मुद्रित हो जाता है।

कैरेट-मोड में, #इनपुट को धक्का देता है, इसलिए उदाहरणों #को मूल रूप से इनपुट के साथ बदल दिया जाता है (FYI करें #एक-बाइट बिल्ली कार्यक्रम)।

— क्रिक्टी लिथोस
स्रोत

4

SOGL V0.12 , 21 18 16 बाइट्स

0≈⁾‛≤¦¶W?5┼EB§  ‘

यह कोशिश करो!

पूरा कार्यक्रम निम्नलिखित संकुचित है:

  __
 /ŗŗ\
/ŗŗŗŗ\
|ŗŗŗŗ|
\____/

जहां ŗइनपुट के साथ बदल जाता है।

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

— dzaima
स्रोत

आपको अंडे को पेंट करना होगा। (यानी पात्रों के साथ अंडे के अंदर भरें)

— मैथ्यू रो

@SIGSEGV - यह समझाया गया है कि इनपुट के साथ रिक्त स्थान की जगह और कोड के साथ रिक्त स्थान के साथ डैश की जगह से प्राप्त किया जाता है@,ŗ -@ŗ

— जोनाथन एलन

क्या SOGOL जल्द ही TIO में होगा?

— जोनाथन एलन

@JonathanAllan यदि कोई इसे वहां प्राप्त कर सकता है, तो हाँ।

— द्विजिमा

टॉक -ट्राइटनलाइन-नेट रूम में डेनिस से बात करें ।

— जोनाथन एलन

3

05AB1E , 34 33 32 बाइट्स

„__I244S×'/ì'\«`©¦¨'|.ø®R¹'_‡).c

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

व्याख्या

„__                               # push "__"
   I244S×                         # push a list of the input repeated 2 and 4 and 4 times
         '/ì                      # prepend "/"
            '\«                   # append "\"
               `                  # split list to separate items
                ©                 # store a copy of the last one in register
                 ¦¨               # remove first and last item of the string
                   '|.ø           # surround with pipes
                       ®R         # retrieve the string from register and reverse it
                         ¹'_‡     # replace input with "_"
                             ).c  # print each line centered

— Emigna
स्रोत

•jÀÅˆiXƒÐ[Z•6B6ôvy5ÝJ"_ |/\"¹«‡,32 के लिए, हालांकि पूरी तरह से अलग है। इसने मुझे बाहर निकाल दिया और मुझे लगता है कि मैं palindromize का उपयोग कर सकता हूं ... तथ्य यह है कि ())(और /\\/palindromes हैं।

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

1

@ कोरसोकोमप्यूटिंग: आपको इसे अलग से पोस्ट करना चाहिए। यह अपने आप में दिलचस्प होने के लिए पर्याप्त है :)

— एमिग्ना

3

पायथन 3.6 , 53 बाइट्स

lambda x:fr'''  __
 /{2*x}\
/{4*x}\
|{4*x}|
\____/'''

चरित्र लेने xऔर एक स्ट्रिंग लौटने समारोह ।
पहले संस्करण के लिए जोड़े गए विकल्प के रूप में पायथन 3.6 के एफ-स्ट्रिंग्स का उपयोग करता है .format()- {}एफ-स्ट्रिंग के संलग्न भागों का मूल्यांकन किया जाना है।
स्ट्रिंग एक आर-स्ट्रिंग और ट्रिपल बाइट है जो एक बाइट को बचाती है:

lambda x:f'  __\n /{2*x}\\\n/{4*x}\\\n|{4*x}|\n\____/'

~~हालांकि मैं अजगर 3.6 के लिए एक ऑनलाइन दुभाषिया नहीं देख सकता।~~
इसे repl.it पर आज़माएं (3.5 कहता है लेकिन यह 3.6 है)

— जोनाथन एलन
स्रोत

3

रेटिना 0.8.2 , 43 41 बाइट्स

-2 बाइट्स केविन क्रूज़सेन की बदौलत

.
$&$&
..
  __¶ /$&\¶/$&$&\¶|$&$&|¶\____/

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

— रिले
स्रोत

मुझे पता है कि थोड़ी देर हो गई है, लेकिन आप इस तरह से 2 बाइट बचा सकते हैं ।

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

3

ब्रेनफक - 257 बाइट्स 181 बाइट्स

गोल्फ: लाइव संस्करण यहां क्लिक करें

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

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

आउटपुट:

  __ 
 /XX\ 
/XXXX\ 
|XXXX| 
\____/ where X is the given char.

असंगठित (+ टिप्पणियाँ):

; chars:
; _ 95
; / 47
; \ 92
; | 142
; min val = 42 (7 times 6)

; lets do some math
+++++++[>++++++<-]> ; effectively 7 times 6

; now lets copy this to the next pointers multiplying by 2 
the subsequent ones after the 1st
[>+>++>++>++<<<<-]

>+++++
>>>

> ; empty space starting from this pointer
++++++++++[>+++>+<<<++++<+<+>>>-]
>++<
<<--<+
>>>,
>..<<<<..>>>>>.<.
<<<<<.
>>>>..<<.>>>>.
<<<<<<.>>>>....<<.>>>>.
<<<.>....<.
>>>.<<<<.<....<.

— लुक्का फेरी
स्रोत

2

05AB1E , 32 29 26 बाइट्स (एमिग्ना / अदनान के लिए धन्यवाद)

•jÀÅˆiXƒÐ[Z•6B6ôvy5ÝJ¹"_ |/\ÿ"‡,

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

•jÀÅˆiXƒÐ[Z•6B6ô # Push ['110011', '135541', '355554', '255552', '400003']
vy               # For each encrypted block...
  5ÝJ            # Push 012345.
     ¹"_ |/\ÿ"   # Push "_ |/\{input_char}".
              ‡, # Swap the charsets.

29 बाइट संस्करण (होशियार डब्ल्यू / ओ पुनरावृत्ति की वजह से एन्कोडिंग के रूप में अच्छी तरह से एन्कोडिंग):

05AB1E , 29 बाइट्स (एमिग्ना)

•P£<r7»TwDšç6•5ÝJI"
_/ÿ\|"‡.c

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

एमिगा के सुझाव के 26 बाइट विस्तार, एस को एक सरणी में अलग करने के लिए एस का उपयोग करते हुए, फिर पिछले अंक में संबंधित स्थान के साथ प्रत्येक अंक को प्रक्षेपित करने के लिए एक [ख]। यह अनिवार्य रूप से एक तत्व-आधारित लिप्यंतरण (स्मार्ट) है।

05AB1E , 26 बाइट्स (अदनान)

"
_/ÿ\|"•P£<r7»TwDšç6•Sè.c

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

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

1

यह 3 बाइट्स छोटा है। आपके जवाब से ज्यादा मेरा

— जैसा है

1

@ नई लिपि का उपयोग करते हुए प्रत्यक्ष लिप्यंतरण एक उपन्यास विचार है, मुझे यह पसंद है; यह ईमानदारी से मेरे मौजूदा समाधानों में से 5 बाइट्स को बंद कर सकता है।

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

2

26 बाइट्स के लिए ।

— अदनान

1

@adnan Sè- डरपोक डरपोक ...

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

मुझे ऐसा लगता है कि मेरे लगभग सभी उत्तरों को क्रेडिट की आवश्यकता है Admigna, वास्तव में आपके निरंतर उदाहरणों के बिना भाषा को नहीं जानते होंगे।

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

2

PHP, 51 बाइट्स

$a.=$a=$argn;echo"  __
 /$a\
/$a$a\
|$a$a|
\____/";

पीएचपी, बिना भौतिक लाइनब्रेक के 58 बाइट्स

$a.=$a=$argn;echo"  __\n /$a\\\n/$a$a\\\n|$a$a|\n\\____/";

इस -Rविकल्प के साथ चलाएं

61 बाइट्स

echo strtr("  __\n /88\\\n/8888\\\n|8888|\n\\____/",8,$argn);

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

स्टोर किए गए मूल्य को दोगुना कर दिया; अनावश्यक स्थान हटा दें; शाब्दिक न्यूलाइन वर्ण का उपयोग करें: pastebin.com/EghdAYMf

— manatwork

@manatwork धन्यवाद मैं वास्तव में दोहरे इनपुट के बारे में नहीं सोच रहा

— हूं

फिजिकल लाइनब्रीक के साथ 7 बाइट्स बचाएं और बैकस्लैश से बचकर न निकले (पिछले किसी भी तरह से बचने की जरूरत नहीं है)। ओह और btw: -Rएक पैरामीटर नहीं है, यह एक विकल्प है।

— टाइटस

@ टिट्स मुझे शारीरिक रेखाओं से नफरत है

— जॉन् हल्सरमैन

@ टिट्स, राइट, हालांकि man phpउन्हें पैरामीटर कहते हैं : "पैरामीटर -R या -F का उपयोग करके लाइन द्वारा मानक इनपुट लाइन को संसाधित करना भी संभव है।"

— मैनटवर्क

2

बीएफ, 142 140 बाइट्स

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

यह स्पष्टता के लिए दो लाइनों में विभाजित है; न्यूलाइन की गिनती नहीं की जाती है।

बीएफ में इस तरह की बात लिखना काफी आसान है, लेकिन यह गैर-तुच्छ है कि आंदोलन को कम करने के लिए कोशिकाओं के क्रम को कैसे अनुकूलित किया जाए। मैंने सभी संयोजनों को आजमाने और सबसे छोटा खोजने के लिए एक ब्रुट-फ़ॉरेसर स्क्रिप्ट लिखी थी, और मैंने इसे एक छोटे से गोल्फिंग अवसर के लिए ध्यान में रखा, जिसे मैंने ब्रूट-फ़ॉरेसर में शामिल नहीं किया था।

— फल तोड़ना
स्रोत

@JoKing मेरा सुझाव है कि आप एक अलग उत्तर के रूप में पोस्ट करें, क्योंकि यह मेरा से बहुत अलग लगता है।

— १२:

2

ब्रेनफक , 114 बाइट्स

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

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

मैंने व्यक्तिगत पात्रों को उत्पन्न करने के लिए अधिक इष्टतम तरीका खोजने के लिए यहां BF क्रंच का उपयोग किया है ।

— मजाक कर रहा है
स्रोत

2

सी (जीसीसी) , 95 88 85 बाइट्स

-7 बाइट्स के लिए अल्बर्ट को धन्यवाद

छत -3 बाइट्स के लिए भी धन्यवाद

f(c){for(int*s=L"  __\n /00\\\n/0000\\\n|0000|\n\\____/\n";*s;s+=printf(*s%6?s:&c));}

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

— cleblanc
स्रोत

*q5 बाइट्स को बचाने के लिए अपने घोंसले में बस इसे घोंसला घोषित न करें । char*s;f(c){for(s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}

— अल्बर्ट रेनशॉ

आप *sलूप के घोषणा तर्क के अंदर की घोषणा करके उस पर 2 और बाइट्स को भी सहेज सकते हैं :f(c){for(char*s=" __\n /11\\\n/1111\\\n|1111|\n\\____/\n";*s;putchar(*s^49?*s:c),s++);}

— अल्बर्ट रेनशॉ

आप एक ASCII वर्ण के लिए 1 बाइट भी शेव कर सकते हैं जिसमें एक अंक का संख्यात्मक मान हो। 1है 49ASCII में लेकिन यह है कि 2 बाइट्स, 0-9 से एक मूल्य के साथ कुछ प्रयोग, सारणीकरण चरित्र `है उदाहरण के लिए` ASCII मूल्य है 9।

— अल्बर्ट रेनशॉ

के *s;f(c){for(sबजाय सुझावf(c){for(int*

— छत

1

SpecBAS - 70 बाइट्स

1 INPUT a$:  ?"  __"'" /";a$*2;"\"'"/";a$*4;"\"'"|";a$*4;"|"'"\____/"

?PRINTकमांड के लिए आशुलिपि है , और एपोस्ट्रोफी कर्सर को अगली पंक्ति में ले जाती है।

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

1

रोड़ा , 46 बाइट्स

{a=`  __
 /-\
/--\
|--|
\____/`a~="-",_*2;[a]}

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

— fergusq
स्रोत

1

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

lambda n:r'''  __
 /a\
/aa\
|aa|
\____/'''.replace('a',n*2)

— Rɪᴋᴇʀ
स्रोत

1

लुआ, 66 बाइट्स

print((([[  __
 /ee\
/eeee\
|eeee|
\____/]]):gsub("e",io.read())))

((([[#बिल्कुल सही किया]])))

— गप्पी
स्रोत

1

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

.
$0$0
..
  __¶ /$0\¶/$0$0\¶|$0$0|¶\____/

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

— डेनिस
स्रोत

1

जाप , 35 बाइट्स

"  __
 /01
/001
|00|
1____/"d0U²1'\

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

41-बाइट समाधान:

[S²'_²RS'/U²'\R'/U²²'\R'|U²²'|R'\'_²²'/]q

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

— ओलिवर
स्रोत

अच्छा है। मेरा पहला प्रयास यह 36 बाइट्स के लिए था , लेकिन ऐसा लगता है कि उपयोग dकरना बाइट कम है।

— ETHproductions

1

[आर], ६५ बाइट्स

cat(gsub('x',scan(,''),"  __\n /xx\\\n/xxxx\\\n|xxxx|\n\\____/"))

बहुत अलौकिक, कृपया आर में एक छोटा खोजें ... यह आपका मूल जीएसयूबी है

— user11599
स्रोत

1

सी ++ 208 बाइट्स

टिप्पणियों के जवाब में: यह एक पूर्ण री-पोस्ट है।

#include<iostream>
using namespace std;int main(){char e;cin>>e;cout<<"  __  \n";cout<<" /"<<e<<e<<"\\ "<<endl;cout<<"/"<<e<<e<<e<<e<<"\\"<<endl;cout<<"|"<<e<<e<<e<<e<<"|"<<endl;cout<<"\\____/ \n";return 0;}

— takintoolong
स्रोत

1

सी # , 56 बाइट्स

golfed

i=>"  __\n /i\\\n/ii\\\n|ii|\n\\____/".Replace("i",i+i);

Ungolfed

i => 
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
      .Replace( "i", i + i );

अनपढ़ पठनीय

i => 
   "  __\n /i\\\n/ii\\\n|ii|\n\\____/"

      // Replace every instance of 'i' with the input cloned twice
      .Replace( "i", i + i );

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = i => 
            "  __\n /i\\\n/ii\\\n|ii|\n\\____/"
               .Replace( "i", i + i );

         List<String>
            testCases = new List<String>() {
               "-",
               "%",
               "~",
               "o",
               " ",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput:\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

विज्ञप्ति

v1.0 - 56 bytes- प्रारंभिक समाधान।

टिप्पणियाँ

प्रदान किए गए लिंक के भीतर मुद्रित परिणाम दिखावे की तरह नहीं दिखेंगे, क्योंकि फ़ॉन्ट का उपयोग मोनोस्पेस नहीं होने के कारण होता है।

— auhmaan
स्रोत

1

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

e(d){printf("  __\n /%c%c\\\n/%c%c%c%c\\\n|%c%c%c%c|\n\\____/\n",d,d,d,d,d,d,d,d,d,d);}

stdio.h के बिना प्रिंटफ चेतावनी का कारण बनता है, लेकिन कोई त्रुटि नहीं, जिससे सफल संकलन की अनुमति मिलती है।

व्याख्या

Printf का कथन है कि सब कुछ एक पंक्ति में क्रैम्प करता है, सजावट वर्ण को% c के साथ स्वरूपित करता है।

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

— जेक रेनॉल्ड्स
स्रोत

1

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

g(f){char e[]={f,f,f,f};printf("  __\n /%.2s\\\n/%.4s\\\n|%.4s|\n\\____/\n",e,e,e);}

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

— मैं हूं।
स्रोत

मुझे एक ईस्टर अंडा बनाओ!

चुनौती

चश्मा

ब्रेन-फ्लैक , 270 268 266 + 1 = 267 बाइट्स

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

चारकोल , 30 26 16 बाइट्स

व्याख्या

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

कैसे?

सेड, 43 वर्ण

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

अपनी खुद की पेंट!

ऐलिस , 53 52 बाइट्स, गैर-प्रतिस्पर्धात्मक

व्याख्या

पॉवरशेल , 50 49 48 बाइट्स

गाजर , 34 बाइट्स, गैर-प्रतिस्पर्धात्मक

SOGL V0.12 , 21 18 16 बाइट्स

05AB1E , 34 33 32 बाइट्स

पायथन 3.6 , 53 बाइट्स

रेटिना 0.8.2 , 43 41 बाइट्स

ब्रेनफक - 257 बाइट्स 181 बाइट्स

05AB1E , 32 29 26 बाइट्स (एमिग्ना / अदनान के लिए धन्यवाद)

05AB1E , 29 बाइट्स (एमिग्ना)

05AB1E , 26 बाइट्स (अदनान)

PHP, 51 बाइट्स

बीएफ, 142 140 बाइट्स

ब्रेनफक , 114 बाइट्स

सी (जीसीसी) , 95 88 85 बाइट्स

SpecBAS - 70 बाइट्स

रोड़ा , 46 बाइट्स

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

लुआ, 66 बाइट्स

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

जाप , 35 बाइट्स

41-बाइट समाधान:

[आर], ६५ बाइट्स

सी ++ 208 बाइट्स

सी # , 56 बाइट्स

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

व्याख्या

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