पृष्ठभूमि

जब मैं छोटा था, तो मुझे एक अजीब "एस" आकार बनाने की एक विधि सिखाई गई थी, जिसे मैं (अपने सहपाठियों के साथ) आकर्षक पाया। आज, मैंने इसे फिर से खोज लिया, और इसे आकर्षित करने के अपने फार्मूले के कारण, सोचा कि यह एक दिलचस्प चुनौती हो सकती है।

"S" खींचना

S को इन सरल चरणों का पालन करके तैयार किया जा सकता है:

सबसे पहले, तीन ऊर्ध्वाधर रेखाओं की 2 पंक्तियों को इस तरह खींचें

| | |

| | |

इसके बाद, शीर्ष बाईं रेखा को नीचे की मध्य रेखा और शीर्ष मध्य को नीचे दाईं ओर की रेखा के साथ जोड़ दें

| | |
 \ \
| | |

अंत में, वर्तमान में खींची गई छवि पर एक शीर्ष और नीचे खींचें ताकि यह दिखने में समाप्त हो जाए

  ^
 / \
| | |
 \ \
| | |
 \ /
  v

जैसा कि आप देख सकते हैं, यह एक "एस" आकार में परिणाम है। जब बढ़ाया जाता है (2 से अधिक पंक्तियों के साथ इसे खींचा जाता है), यह एक बहुत ही दिलचस्प पैटर्न पैदा करता है। आपका कार्य इस दिलचस्प पैटर्न को पुन: पेश करता है।

कार्य

एक पूर्णांक को देखते हुए n >= 2, जहाँ से nपंक्तियों के साथ S को आउटपुट किया जाता है। आउटपुट को एक फ़ंक्शन से वापस किया जा सकता है, और इनपुट मानक विधियों में लिया जा सकता है। समग्र छवि, साथ ही प्रत्येक पंक्ति के लिए अनुगामी / अग्रणी व्हाट्सएप, ठीक है। हालांकि, अग्रणी लाइन स्पेस लगातार होना चाहिए ताकि "टूट न जाए। आप लाइनों की सूची के रूप में आउटपुट कर सकते हैं।"

परीक्षण के मामलों

input
output
---

2

  ^
 / \
| | |
 \ \
| | |
 \ /
  v

---

8
  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

---

10

  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है! सौभाग्य,

code-golf string ascii-art

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

13

विकिपीडिया कूल एसS को कॉल करता है , और S Chain

— स्टीफन

क्या हम लाइनों की सूची के रूप में आउटपुट कर सकते हैं?

— श्री एक्सकोडर

@ Mr.Xcoder आप कर सकते हैं

— caird coinheringaahing

@ स्टेपेन 10 मिनट की गुगली और यह ऊपर नहीं आया। मैं प्रश्न का नाम संपादित

— करूंगा

@cairdcoinheringaahing मैंने छवियां खोजीं, जो शायद यह थीं: पी

— स्टीफन

15

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

lambda k:'  ^\n / '+'\\\n| | |\n \ '*k+'/\n  v'

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

— लिन
स्रोत

10

सी # (.NET कोर) , 73 69 66 64 62 बाइट्स

दो कम बाइट्स और पर्ल-जैसी उपस्थिति, बड़ौद के लिए धन्यवाद। Int का उपयोग करने के बारे में नहीं सोचा था? नल के लिए।

n=>$@"  ^
 / {string.Join(@"\
| | |
 \ ",new int?[++n])}/
  v"

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

— मेरा सर्वनाम monicareinstate है
स्रोत

1

यदि यह मौजूदा C # उत्तर का एक गोल्फ होता, तो मैं कभी नहीं बता पाता। शाबाश :-)

— ETHproductions

क्या आप बता सकते हैं कि क्या new string[n+1]करता है? मैंने इसे पहले कभी नहीं देखा।

— इयान एच।

खाली स्ट्रिंग AFAIK की एक सरणी बनाता है। मैंने स्ट्रिंग के साथ एक हैक का उपयोग किया है। जॉइन, उर्फ {"", "", "", "}} के साथ विभाजक" \ n | | | \ n \ "

— मेरा सर्वनाम

@someone Woah, मैंने पहले कभी इस ट्रिक को स्वीकार नहीं किया। बहुत कूल! (इसके अलावा मेरा बुरा, मैं हालांकि new string[n+1]कुछ प्रकार के मुश्किल स्ट्रिंग निर्माता था और एक सरणी घोषणा नहीं है

— इयान एच।

6

पायथन 3 , 48 56 59 61 बाइट्स

lambda k:'  ^\n / %s/\n  v'%('\\\n| | |\n \ '*k)

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

— श्री एक्सकोडर
स्रोत

आप अकेला बैकस्लैश को हटाकर 2 बाइट बचा सकते हैं।

— L3viathan

@ L3viathan अभी भी अपडेट कर रहा है

— श्री एक्सकोडर

56 बाइट्स; यकीन नहीं है कि यह उचित खेल है ; TIO पर काम नहीं करता है

— L3viathan

@ L3viathan यह सही नहीं है। अतिरिक्त \ \।

— श्री एक्सकोडर

TIO पर: हाँ। मेरे टर्मिनल में: नहीं।

— L3viathan

6

05AB1E , 27 26 बाइट्स

…^
/ð"\
| | |
\ "I×…/
vJ.c

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

वैकल्पिक 27 बाइट संस्करण

'^…/ \©IF…| |û…\ \}\®R'v».c

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

व्याख्या

'^                             # push "^"
  …/ \©                        # push "/ \" and store a copy in register
       IF                      # input times do:
         …| |û                 # push "| | |"
              …\ \             # push "\ \"
                  }            # end loop
                   \           # discard top of stack (the extra "\ \")
                    ®R         # push "/ \" reversed = "\ /"
                      'v       # push "v"
                        »      # join stack on newlines
                         .c    # center each row

— Emigna
स्रोत

5

आपका कोड मेरे लिए एक हाथी की तरह दिखता है :)

— वोजोवू

यह शाब्दिक रूप से डरावना है कि मेरा उत्तर आपके कितने करीब था: '^…/ \©IF„| ûû„\ û}\®R'v).Cबिना देखे।

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

6

जाप , 34 25 23 बाइट्स

" ^ /{ç'\²i|³1}/ v"¬¸ò5

इसे ऑनलाइन टेस्ट करें! लाइनों की एक सरणी के रूप में आउटपुट; -Rध्वज को नए समाचारों में शामिल होने के लिए जोड़ा गया। (साभार @ शगुन)

~~पहला~~ दूसरा प्रयास, हो सकता है कामचलाऊ ...

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

" ^ /{ ç'\²  i |³  1}/ v"¬ ¸  ò5
" ^ /{Uç'\p2 i'|p3 1}/ v"q qS ò5   Ungolfed
                                   Implicit: U = input number
        '\p2                       Repeat a backslash twice, giving "\\".
             i     1               Insert at index 1
              '|p3                   3 vertical bars. This gives "\|||\".
      Uç                           Make U copies of this string. U = 2: "\|||\\|||\"
" ^ /{              }/ v"          Insert this into this string.    " ^ /\|||\\|||\/ v"
                         q qS      Split into chars; join on spaces."  ^   / \ | | | \ \ | | | \ /   v"
                              ò5   Split into rows of length 5.    ["  ^  "," / \ ","| | |"," \ \ ","| | |"," \ / ","  v"]
                                   Joining on newlines gives "  ^  
                                                               / \ 
                                                              | | |
                                                               \ \
                                                              | | |
                                                               \ /
                                                                v"

— ETHproductions
स्रोत

चारकोल की पिटाई और SOGL को बांधना? उत्कृष्ट कार्य!

— झबरा

आप लाइनों की एक सरणी का उत्पादन कर सकते हैं, वैसे, तो आप अंतिम 2 वर्णों को खोद सकते हैं।

— झबरा

@ झगड़ालू महान, अब हम जीत रहे हैं!

— ETHproductions

हम हाल ही में अच्छी तरह से कर रहे हैं :)

— झबरा

6

SOGL V0.12 , 26 25 18 बाइट्स

°I-‘*"∑ūCƨΩ)¹‘@∑5n

यह कोशिश करो!

ETHproductions के Japt उत्तर के समान रणनीति का उपयोग करता है

स्पष्टीकरण:

..‘           push "\|||\"
   *          repeat input times
    "..‘      push " ^ /ŗ/ v ", with ŗ replaced with POP. The reason why there's a trailing
              space is because otherwise it didn't have enough repeating characters to compress
        @∑    join with spaces
          5n  split to line lengths of 5

— dzaima
स्रोत

2

push "|" and " "क्या वह बिल्ली है कि निर्मित

— स्टीवन एच।

1

@StevenHewitt, जो वास्तव में दो बिल्ट-इन हैं, लेकिन मैंने उन्हें एक साथ जोड़ा (जैसा कि मैं अन्य सामान के साथ करता हूं) क्योंकि मुझे नहीं लगता कि जल्द ही एक साथ इस्तेमाल होने वाले सामान को अलग करना जरूरी नहीं है

— dzima

5

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

n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`

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

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

let f=
n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`
;(I.oninput=_=>O.innerHTML=I.value+"\n"+f(+I.value))()

<input id=I type=range min=2 max=15 value=2><pre id=O></pre>

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

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

1

57: n=>' ^\n /${' \\ \\\n| | |\n'.repeat(n).slice(2)} \\ /\n v'(

— बैकटिक्स

5

चारकोल , 27 26 25 बाइट्स

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

  ^⸿ / ×\⸿| | |⸿ \ Ｎ/⸿  v

इसे ऑनलाइन आज़माएं! लिंक वर्बोज वर्जन के लिए है। # लकड़ी का कोयला-verbose-obfucation

— totallyhuman
स्रोत

1

आप केवल कॉल करके 1 बाइट बचा सकते हैं प्रिंट (तार जोड़ने के बजाय) और उपयोग करके \r: `^ \ / × \ by | | | | \ ⸿ / ⸿ v`। वर्बोज़ संस्करण ।

— चार्ली

आह ... मैं नए \rतरीके से समझदार तरीका पाने के लिए याद रखना होगा । धन्यवाद!

— पूरी तरह से

25 बाइट्स

— केवल

@ एएससीआईआई-केवल: पी -

— 12

4

पर्ल 5 , 39 37 बाइट्स

say"  ^
 / ".'\
| | |
 \ 'x<>."/
  v"

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

@DomHastings के सुझाव के साथ दो बाइट शेव की गईं

— Xcali
स्रोत

यदि आप एकल उद्धरण का उपयोग करते हैं, तो आपको -2 के लिए बैकस्लैश से बचने की आवश्यकता नहीं है! :)

— डोम हेस्टिंग्स

3

दरअसल , 49 बाइट्स

"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"

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

स्पष्टीकरण:

"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"
"| | |"@α                                          push a list containing n copies of the vertical lines
         ;lD" \ \"@α                               push a list containing n-1 copies of the diagonal connections
                    @Z♂i                           interleave
                        i                          flatten
                         "  v"" \ /"))             make the bottom
                                      " / \""  ^"  make the top

— मै जाऊं
स्रोत

3

05AB1E , 38 बाइट्स

…| |ûU"  ^
 / \"XI<F„ \2×X}" \ /
  v"»

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

…| |                         # Push "| |"
    û                        # Palindromize
     U                       # Store in X
      "..."X                 # Push the top three rows
            I<F      }       # One less than input times do:
               „ \           #   Push " \"
                  2×         #   Concatenate that with itself
                    X        #   Push "| | |"
                      "..."  # Push the last two rows
                           » # Join stack with newlines

— रिले
स्रोत

3

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

f(n){for(puts("  ^\n / \\");--n;puts("| | |\n \\ \\"));puts("| | |\n \\ /\n  v");}

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

— cleblanc
स्रोत

3

सी # (.NET कोर) , 101 77 73 बाइट्स

_{सहेजा गया 24 बाइट्स के लिए धन्यवाद मैं cri everytim !}_{केविन क्रूज़सेन के}
_{लिए धन्यवाद 4 बाइट्स सहेजे गए !}

n=>{var s="  ^\n / ";for(;n-->0;s+="\\\n| | |\n \\ ");return s+"/\n  v";}

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

हमेशा की तरह, C # में स्ट्रिंग दोहराना एक दर्द है।

— इयान एच।
स्रोत

77 बाइट्स।

— 21

@icrieverytim, आह, बेशक, बेहतर तरीका है।

— इयान एच।

आप बदल सकते हैं --n>=0करने के लिए n-->0और s+="/\n v";return s;करने के लिए return s+"/\n v";कुछ बाइट्स को बचाने के लिए।

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

1

@ केविनक्रूजसेन धन्यवाद, निश्चित!

— इयान एच।

3

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

.+
$*
1
¶|||¶x\\
^
 ^¶x/\
.$
/¶ v
x?

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

प्रत्येक पंक्ति पर अग्रणी स्थान और अनुगामी स्थान का एक स्तंभ प्रिंट करता है।

व्याख्या

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

^
/\
|||
\\
|||
\/
v

हो जाता है:

 ^ 
 / \ 
 | | | 
 \ \ 
 | | | 
 \ / 
 v

यह लगभग सही है, सिवाय इंडेंटेशन के। ^और vदो रिक्त स्थान याद कर रहे हैं। यह वास्तव में तय करना आसान है, क्योंकि यदि हम उनमें से प्रत्येक के सामने एक स्पष्ट स्थान डालते हैं, तो इसका परिणाम अंत में दो अतिरिक्त स्थानों पर होगा। स्लैश वाली लाइनें पेचीदा होती हैं क्योंकि उन्हें केवल एक अतिरिक्त स्थान की आवश्यकता होती है। इसे ठीक करने के लिए, हम वहां एक प्लेसहोल्डर चरित्र डालें ( x)। जब हम अंत में रिक्त स्थान डालते हैं, तो हम उन्हें हर खाली मैच के लिए सम्मिलित नहीं करते हैं, लेकिन हम वैकल्पिक रूप से मेल खाते हैं x। इसका मतलब है कि सामने एक जगह डालने के बजाय x, xखुद को बदल दिया जाता है। और फिर अभी के बाद एक खाली मैच होगा x। इसका मतलब है, हरxकुछ और बदले बिना बिल्कुल एक स्थान जोड़ता है। तो हम इसे स्थापित करना चाहते हैं:

 ^
x/\
|||
x\\
|||
x\/
 v

जो हमें वांछित परिणाम देगा। तो यहाँ कोड है:

.+
$*

इनपुट को unary में बदलें।

1
¶|||¶x\\

प्रत्येक कन्वर्ट 1के साथ दो लाइनों के लिए |||और x\\(एक प्रमुख linefeed और)।

^
 ^¶x/\

पहले दो लाइनों को सम्मिलित करें ^और x/\।

.$
/¶ v

अंतिम x\\को चालू \करके /और उसके साथ एक पंक्ति जोड़कर फाइनल को ठीक करें v।

x?

प्रत्येक xया खाली मिलान को एक स्थान से बदलें ।

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

नीट दृष्टिकोण। मैं अपने पिप समाधान के लिए जॉइन-ऑन-स्पेस का उपयोग करने का एक तरीका जानने की कोशिश कर रहा था, लेकिन विभिन्न पंक्तियों पर अग्रणी स्थानों की अलग-अलग संख्याओं के कारण यह काफी काम नहीं कर रहा था।

— DLosc

2

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

"  ^
 / \\"
+*j[jd*\|3" \ \\"k))Q" \ /
  v

परीक्षण सूट।

— स्टीवन एच।
स्रोत

36 बाइट्स:%" ^\n / %s/\n v"*Q"\\\n| | |\n \

— श्री एक्सकोडर

31 बाइट्स ।

— श्री Xcoder

2

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

K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v

स्टीवन हेविट के समान ही, लेकिन स्वतंत्र रूप से विकसित हुआ।

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

व्याख्या

K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v
K" / \ ""                                 Set K = " / \ "
        "  ^"                       "  v  Draw the end points.
             K                    _K      Draw the slants.
                         *Q]*3"| "        Draw the vertical bars...
              j+b+*2+d\\b                 ... interspersed with slants.

2

पायथ, 33 32 31 बाइट्स

एक बाइट के लिए धन्यवाद श्री Xcoder।

%"  ^
 / %s/
  v"*tj\|_B" \\
|

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

— Jakube
स्रोत

बहुत अच्छा जवाब! आप इसे 32 बाइट तक नीचे ला सकते हैं ।

— श्री Xcoder

2

31 बाइट्स , वास्तव में।

— श्री Xcoder

2

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

यह एक बहुत ही सरल उपाय है।

.+
$*
^1
  ^¶ /x
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

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

यदि कला इसके बजाय 1-अनुक्रमित हो सकती है, तो यह थोड़ा कम होगा (44 बाइट्स):

.+
  ^¶ /x$0$*1
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

— mbomb007
स्रोत

2

पिप , 45 42 33 बाइट्स

"  ^
 / "."\
| | |
 \ "Xa."/
  v"

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

व्याख्या

कोड वास्तव में सरल है, हालांकि नए अंक पढ़ने के लिए कठिन बनाते हैं। यहाँ संरचना को देखने का एक बेहतर तरीका है:

"prefix" . "repeated" X a . "suffix"

एस-चेन में दोहराया तत्व है

   \
| | |
 \

इसे शाब्दिक स्ट्रिंग के रूप में लें और इसे aबार-बार दोहराएं (जहां aपहला कमांड-लाइन तर्क है)। फिर उपसर्ग को पूर्व निर्धारित करें:

  ^
 /

और प्रत्यय संलग्न करें:

   /
  v

और प्रिंट करें।

(मुझे पसंद है कि यह कैसे समाप्त हो गया> एक> <> कार्यक्रम की तरह थोड़े।

— DLosc
स्रोत

यह एडवेंचर टाइम :) से

— लुम्पी

2

MATL , 47 44 43 बाइट्स

-3 बाइट्स ग्यूसेप के लिए धन्यवाद

'  ^' ' / \ 'XK'| | |'XJGq:"' \'thJ]KP'  v'

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

— Cinaski
स्रोत

' ^' ' / \ 'XK'| | |'XJ`' \ \'JGq@-]KP' v'44 बाइट्स है।

— ग्यूसेप

1

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

f n="  ^\n /"++([1..n]>>" \\\n| | |\n \\")++" /\n  v"

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

— nimi
स्रोत

1

एक्सेल, 60 बाइट्स

="  ^
 / \
"&REPT("| | |
 \ \
",A1-1)&"| | |
 \ /
  v"

— Wernisch
स्रोत

आपको यह देखने के लिए जाँच करनी चाहिए कि क्या यह Google शीट के साथ एक बहुभुज है

— टेलर स्कॉट

1

पॉवरशेल , 83 , 57 बाइट्स

"  ^
 / \"
1..--$args[0]|%{"| | |
 \ \"}
"| | |
 \ /
  v"

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

प्रति @ AdmBorkBork के सुझाव,

forएक नंबर रेंज का उपयोग करके सरलीकृत ।
बदला हुआ ;और संयुक्त तार।
एक अनावश्यक चर परिभाषा को हटा दिया।

— जड़
स्रोत

आप अपने forलूप का उपयोग करके बहुत कुछ गोल्फ कर सकते हैं 1..--$args[0]|%{ }।

— AdmBorkBork

इसके अलावा, आप सहेजने के लिए आसन्न स्ट्रिंग्स के बीच शाब्दिक न्यूलाइन्स का उपयोग कर सकते हैं ";"और यह $sपूरी तरह से छुटकारा पाने के लिए सस्ता है । 57 बाइट्स

— AdmBorkBork

स्लिक। मुझे न्यूलाइन सेव पसंद है। अजीब बात है कि मैं मौका चूक गया 1..$args। मुझे यकीन नहीं है कि इस साइट पर सही शिष्टाचार क्या है। क्या मैं अपने उत्तर में परिवर्तन करता हूं और आपको क्रेडिट देता हूं, या क्या आप एक अलग उत्तर के रूप में अपना समाधान पोस्ट करते हैं?

— रूट

परिवर्तनों में संपादन करना और श्रेय देना उचित शिष्टाचार है। PPCG में आपका स्वागत है।

— AdmBorkBork

1

AsciiDots , 88 बाइट्स

.*$"  ^"$" / \"
/>#?)--*$"| | |"$" \ \"
*#1\ /-~$"| | |"$" \ /"$"  v"
*-{-}*[<]
\#0----/

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

— user31415
स्रोत

1

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

लिन के पायथन समाधान का बोरिंग बंदरगाह ।

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”

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

स्पष्टीकरण:

“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”    Example input: 5
“\¶| | |¶ \ ”                       Literal string "\¶| | |¶ \ " (¶ = newline). Result: "\¶| | |¶ \ "
             ẋ                      Repeat as many times as the (implicit) input. Result: "\¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
              ṭ                     Tack that on the end of...
               “  ^¶ / ”            ...the string "  ^¶ / ". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
                        ;           Append...
                         “/¶  v”    The string "/¶  v". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ /¶  v"
                                    Implicit print

— कॉमरेड स्पार्कलपनी
स्रोत

1

दरअसल , 30 बाइट्स

यह उसी सिद्धांत पर काम करता है जैसे कि ETHproductions के Japt उत्तर , जहां अतिरिक्त रिक्त स्थान बाद में जोड़े जाते हैं, और पूरे स्ट्रिंग को अंतर्निहित मुद्रण के लिए 5 की पंक्तियों में विभाजित किया जाता है। इसे ऑनलाइन आज़माएं!

"\|||\"*" ^ /"+"/ v"@+#' j5@╪i

Ungolfing

            Implicit input.
"\|||\"*    Add the middle portion and multiply that by the input.
" ^ /"+     Append the top.
"/ v"@+     Append the bottom.
#           Convert into a list of strings
' j         Join with spaces.
5@╪         Split into a list of length-5 strings.
i           Flatten list onto the stack for implicit printing with newlines.

— Sherlock9
स्रोत

अपनी भाषा में मेगो को पछाड़ कर अच्छा काम किया!

— caird coinheringaahing

1

जेली , 25 23 बाइट्स

यह ETHproductions के Japt उत्तर के समान सिद्धांत पर काम करता है , जहां अतिरिक्त स्थान बाद में जोड़े जाते हैं, और पूरे स्ट्रिंग को मुद्रण से पहले लंबाई 5 के तारों में विभाजित किया जाता है। इसे ऑनलाइन आज़माएं!

संपादित करें: मुझे पता था कि गोल्फ के रास्ते में एस-चेन के ऊपर और नीचे से जुड़ने का एक तरीका था। -2 बाइट्स के लिए आउटगोल्फ को एरिक करने के लिए धन्यवाद।

“\|||\”ẋ“ ^ /“/ v”jKs5Y

Ungolfing

                Left argument: n
“\|||\”ẋ        Repeat the middle portion n times.
“ ^ /“/ v”j     Append the top and bottom.
K               Join with spaces.
s5              Split into a list of length-5 strings.
Y               Print the strings with linefeeds.

— Sherlock9
स्रोत

“\|||\”ẋ“ ^ /“/ v”jKs5Y

— आउटगॉल्फ

1

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

↘^\¶/¶Ｇ→⁵↓⊕⊗Ｎ←⁵|¶ \↗¶\¶v/

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

— नील
स्रोत

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

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

@ केविनक्रूजसेन आप ताकत कहते हैं, लेकिन यह वास्तव में तिरछे मुद्रण होना चाहिए; दुख की बात है कि सबसे अच्छा मैं कर सकता था 29 बाइट्स:↘^\|¶/|\|¶|Ｆ⊖Ｎ↘\|\|¶|↘\|/¶|\v

— नील

1

बैश, 67 बाइट्स

printf -v a %\*s $1 \ ;echo '  ^
 / '"${a// /\\
| | |
 \\ }"'/
  v'

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

— नहुएल फौलीउल
स्रोत

0

जावा 8, 93 76 बाइट्स

n->{String r="  ^\n / ";for(;n-->0;r+="\\\n| | |\n \\ ");return r+"/\n  v";}

पोर्ट @IanH। मैं इसे थोड़ा और अधिक गढ़ने के बाद C # .NET उत्तर देता हूं।

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

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

यह हास्यास्पद है कि यह कैसे stringबनाम varभाग के लिए लगभग समान है ।

— इयान एच।

@IanH। और n->बनाम n=>;)

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

एक एस-चेन ड्रा करें

पृष्ठभूमि

"S" खींचना

कार्य

परीक्षण के मामलों

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

सी # (.NET कोर) , 73 69 66 64 62 बाइट्स

पायथन 3 , 48 56 59 61 बाइट्स

05AB1E , 27 26 बाइट्स

जाप , 34 25 23 बाइट्स

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

SOGL V0.12 , 26 25 18 बाइट्स

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

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

चारकोल , 27 26 25 बाइट्स

पर्ल 5 , 39 37 बाइट्स

दरअसल , 49 बाइट्स

05AB1E , 38 बाइट्स

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

सी # (.NET कोर) , 101 77 73 बाइट्स

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

व्याख्या

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

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

व्याख्या

पायथ, 33 32 31 बाइट्स

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

पिप , 45 42 33 बाइट्स

व्याख्या

MATL , 47 44 43 बाइट्स

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

एक्सेल, 60 बाइट्स

पॉवरशेल , 83 , 57 बाइट्स

AsciiDots , 88 बाइट्स

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

दरअसल , 30 बाइट्स

जेली , 25 23 बाइट्स

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

बैश, 67 बाइट्स

जावा 8, 93 76 बाइट्स