मुझे एक उल्टा क्रिसमस पेड़ बनाओ!

Question

चुनौती

हम सभी सामान्य क्रिसमस पेड़ों के बारे में जानते हैं - लेकिन कैसे एक उल्टा क्रिसमस पेड़ के बारे में ! यह एक काफी आसान, क्रिसमस थीम्ड चुनौती है। इस चुनौती का उद्देश्य मुझे एक ASCII उल्टा क्रिसमस पेड़ बनाना है। इस चुनौती के नियम इस प्रकार हैं:

1. एक विषम, सकारात्मक पूर्णांक स्वीकार करें। आप मान सकते हैं कि यह हमेशा 7और के बीच रहेगा 51।

2. पेड़ का आधार पात्रों से बना होगा:

   ___
   \ /
    |
   

3. पेड़ के शीर्ष (तारा), एकल से बना होगा *।

4. पेड़ की प्रत्येक पंक्ति का निर्माण उस प्रारूप का उपयोग करके किया जाएगा <?>जहां ?किसी भी संख्या में -एस है। उदाहरण के लिए, यदि लंबाई की रेखा बनाते हैं 5, तो रेखा होनी चाहिए <--->। या यदि लंबाई की रेखा बनाते हैं 8, तो रेखा होनी चाहिए <------>।

5. यहां बताया गया है कि पेड़ के शरीर का निर्माण कैसे किया जाना चाहिए:

   1. nइनपुट के रूप में दी गई विषम संख्या को लें , और उस लंबाई वाले पेड़ की एक पंक्ति बनाएं।

   2. घटाएँ 4से nऔर पेड़ कि लंबाई की एक पंक्ति बनाएँ।

   3. घटाएँ 2से nऔर पेड़ कि लंबाई की एक पंक्ति बनाएँ।

   4. से घटा nहै 2। उसके बाद, जब तक nबराबरी5 न हो , चरण 2 पर वापस जाएं।

6. आधार (देखें चरण 2) स्टार (देखें चरण 3) और पेड़ की प्रत्येक पंक्ति (चरण 4 और 5 देखें) सभी को मूल विषम संख्या इनपुट का उपयोग करके केंद्रित किया जाना चाहिए (चरण 1 देखें) अधिकतम के रूप में चौड़ाई।

उदाहरण / परीक्षण मामले

odd number inputed: 7
  ___
  \ /
   |
<----->      line length -> 7
  <->        line length -> 7 - 4 = 3
 <--->       line length -> 7 - 2 = 5
   *


odd number inputed: 13
     ___
     \ /
      |
<----------->      line length -> 13
  <------->        line length -> 13 - 4 = 9
 <--------->       line length -> 13 - 2 = 11
   <----->         line length -> 11 - 4 = 7
  <------->        line length -> 11 - 2 = 9
    <--->          line length -> 9 - 4 = 5
   <----->         line length -> 9 - 2 = 7
     <->           line length -> 7 - 4 = 3 
    <--->          line length -> 7 - 2 = 5
      *


odd number inputed: 9
   ___
   \ /
    |
<------->      line length -> 9
  <--->        line length -> 9 - 4 = 5
 <----->       line length -> 9 - 2 = 7
   <->         line length -> 7 - 4 = 3
  <--->        line length -> 7 - 2 = 5
    *


odd number inputed: 17
       ___
       \ /
        |
<--------------->      line length -> 17
  <----------->        line length -> 17 - 4 = 13
 <------------->       line length -> 17 - 2 = 15
   <--------->         line length -> 15 - 4 = 11
  <----------->        line length -> 15 - 2 = 13
    <------->          line length -> 13 - 4 = 9
   <--------->         line length -> 13 - 2 = 11
     <----->           line length -> 11 - 4 = 7
    <------->          line length -> 11 - 2 = 9
      <--->            line length -> 9 - 4 = 5
     <----->           line length -> 9 - 2 = 7
       <->             line length -> 7 - 4 = 3
      <--->            line length -> 7 - 2 = 5
        *    

नियम

• मानक खामियां लागू होती हैं ।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

Comments

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

— पलटें

इसके अलावा - repeat the above steps until the odd number minus 2 equals 5- पहले इनपुट में, विषम संख्या 7, और 7-2 = 5 है, इसलिए पेड़ को तुरंत समाप्त होना चाहिए (मुझे पता है कि आपका क्या मतलब है, लेकिन इसे

— रीफ़्रेशिंग की

@ फीलटैक मैं बिलकुल निश्चित नहीं हूं कि आपका क्या मतलब है। यदि विषम संख्या 7, न्यूनतम इनपुट है, तो आप पहले तीन ट्री लाइन (सब-स्टेप्स .1.1, .1.2, .1.3) बनाएंगे, फिर2 विषम संख्या से घटाएं और यदि बराबर हो तो परीक्षण करें 5। यह जांचने का निर्देश कि क्या "विषम संख्या शून्य 2 5 के बराबर है" अंत में है, अन्य तीन चरणों को पहले किया जाना चाहिए। लेकिन आपकी पहली टिप्पणी का जवाब देने के लिए, यह ठीक रहेगा।

— क्रिश्चियन डीन

@ फेलटैक मुझे लगता है कि वह पूछ रहा है कि क्या आपको 7इनपुट के 4रूप में स्वीकार करना है या यदि आप स्वीकार कर सकते हैं , जैसे कि चौथे विषम संख्या में (या 3यदि यह 0-अनुक्रमित है)।

— डोनीएलएफ

शीर्षक से: "ठीक है, तुम अब क्रिसमस के पेड़ के साथ उल्टा हो।"

— dkudriavtsev

Answer 1

पायथन 3 , 127 121 105 103 100 98 बाइट्स

यह एक अनाम लंबो फ़ंक्शन है जो लाइनों की सूची लौटाता है:

lambda o:[s.center(o)for s in['___','\ /','|',*[f'<{"-"*(o-i+2-i%2*3)}>'for i in range(4,o)],'*']]

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

इस उत्तर का मुख्य भाग है (o-i+2-i%2*3), जो एक पंक्ति में होने वाले डैश की संख्या को काम करता है। शेष उत्तर को बस वांछित ASCII- कला में परिवर्तित करना है।

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

लिन के लिए भी धन्यवाद कि 3*(i%2)हो सकता है i%2*3, 2 बाइट्स छोटे हैं!

Comments

121 बाइट्स में कुछ बहुत कम गणित के ट्रिक्स और f-स्ट्रिंग का उपयोग करना

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

जब भी मैं एक पायथन उत्तर पोस्ट करता हूं, दिन का समय या उसकी वर्तमान स्थिति पर कोई फर्क नहीं पड़ता, @ Mr.Xcoder को एक गोल्फ देना है :)

— FlipTack

वेल्ड , यह आसानी से मेरे 250 बाइट्स + पायथन समाधान को हरा देता है। अच्छी नौकरी! +1

— क्रिश्चियन डीन

o-i+2-i%2*3दो बाइट बचाता है।

— लिन

@Lynn अच्छा स्थान, अद्यतन।

— 18

Answer 2

सी, 163 बाइट्स

#define P;printf(
i;g(l){P"%*c",1+i-l--/2,60);for(;--l P"-"))P">\n");}f(n){i=n/2 P"%*c__\n%*c /\n%*c|\n",i,95,i,92,i,32);for(g(n);n>5;g(n-=2))g(n-4)P" %*c",i,42);}

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

unrolled:

#define P;printf(

i;
g(l)
{
    P"%*c", 1+i-l--/2, 60);
    for (; --l P"-"))
    P">\n");
}

f(n)
{
    i=n/2
    P"%*c__\n%*c /\n%*c|\n", i, 95, i, 92, i, 32);

    for(g(n); n>5; g(n-=2))
        g(n-4)

    P" %*c", i, 42);
}

Answer 3

प्रोटॉन , 83 बाइट्स

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

o=>[s.center(o)for s:['___','\ /','|']+['<'+"-"*(o-i+2-i%2*3)+'>'for i:4..o]+['*']]

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

Answer 4

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

__⸿ /⸿|Ｆ⮌…¹⊘Ｎ«⸿⊕ι>⸿⊖ι>»‖Ｂ← *

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

__⸿ /⸿|

आधार प्रिंट करें।

Ｆ⮌…¹⊘Ｎ«

इनपुट नंबर के आधे भाग से 1 तक लूप।

⸿⊕ι>⸿⊖ι>»

दो पंक्तियों को प्रिंट करें, -लूप इंडेक्स के एक से अधिक के साथ पहला , एक कम के साथ दूसरा।

‖Ｂ←

वृक्ष को पूरा करने के लिए दर्पण।

 *

स्टार लगाएं।

Answer 5

SOGL V0.12 , 35 30 बाइट्स

┌* <++L
%⁽⁄6‘√.⁾δ№{⁽LFL}j *+§Γ

यह कोशिश करो!

नील के चारकोल एल्गोरिथ्म का उपयोग करता है , विषम संख्या में सूचकांक के रूप में इनपुट लेता है - इसलिए 13 इनपुट 7 के अनुरूप होगा

Answer 6

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

.+
$*->
^--
<
+`( *<)----(-+>)$
$&¶  $1$2¶ $1--$2
s`.*¶( +)<->.*
$1___¶$1\ /¶$1 |¶$&¶$1 *

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पहला चरण इनपुट को एकता में परिवर्तित करता है और एक संलग्न करता है >। दूसरा चरण लाइन की लंबाई को सही करने के लिए दो -एस की जगह लेता है <। तीसरा चरण तब शाखा की प्रतिकृति बनाता है, लेकिन हर बार जब तक शाखा को आगे छोटा नहीं किया जा सकता है तब तक थोड़ा कम होता है। अंतिम चरण आधार और तारा जोड़ता है।

Answer 7

जावास्क्रिप्ट 506 बाइट्स

गोल्फ-संस्करण:

function tree(i){const mid=(i+1)/2;const leg1=' '.repeat((mid-2))+`___
`;const leg2=' '.repeat((mid-2))+`\\ \/
`;const leg3=' '.repeat((mid-1))+`|
`;let xmasTree=leg1+leg2+leg3;for(let j=0;j<(i-4);j++){if(j%2===0){let v=j/2;let t=i-2*v-2;let body1=" ".repeat(j/2)+"<"+"-".repeat(t)+">"+`
`;xmasTree=xmasTree+body1}else{let k=1+Math.ceil(j/2);let h=i-2*k-2;let body2=' '.repeat(k)+'<'+'-'.repeat(h)+">"+`
`;xmasTree=xmasTree+body2}}
const head=' '.repeat((mid-1))+'*'
xmasTree=xmasTree+head;return xmasTree}

Ungolf-संस्करण:

function tree(i){
  const mid = (i+1)/2;
  const leg1 = ' '.repeat((mid-2)) + `___
`;
  const leg2 = ' '.repeat((mid-2)) + `\\ \/
`;
  const leg3 = ' '.repeat((mid-1)) + `|
`;
  let xmasTree = leg1 + leg2 + leg3;
  for (let j = 0; j<(i-4); j++) {
    if (j%2===0) {
      let v = j/2;
      let t = i-2*v-2;
      let body1 = " ".repeat(j/2)+"<"+"-".repeat(t) +">"+`
`;
      xmasTree = xmasTree + body1;
    } else {
      let k = 1 + Math.ceil(j/2);
      let h = i-2*k-2;
      let body2 = ' '.repeat(k)+ '<'+ '-'.repeat(h) + ">"+`
`;
      xmasTree = xmasTree + body2;
    }
  }
  const head = ' '.repeat((mid-1)) + '*'
  xmasTree = xmasTree + head;
  return xmasTree;
}

उपयोग: console.log(tree(13)), console.log(tree(17)),

ES6 165 बाइट्स (मेरे दोस्त से)

गोल्फ-संस्करण:

p=n=>{l=_=>console.log(`${' '.repeat((n-_.length)/2)}${_}`);t=_=>_==1?'*':'<'+'-'.repeat(_-2)+'>';x=n;l('___');l('\\ /');l('|');for(;x!==3;){l(t(x));l(t(x-4));x-=2}}

Ungolf-संस्करण:

p = n => {
  l = _ => console.log(`${' '.repeat((n-_.length)/2)}${_}`);
  t = _ => _ == 1 ? '*' : '<' + '-'.repeat(_-2)+'>';
  x = n;
  l('___');l('\\ /');l('|');
  for(;x!==3;) {
    l(t(x)); l(t(x-4));x-=2;
  }
}

उपयोग: p(31); p(17);

Comments

आप केवल 1-अक्षर वाले वैरिएबल नामों का उपयोग करके, constकीवर्ड्स आदि को हटाकर इसे बहुत बड़ा कर सकते हैं

— FlipTack

Answer 8

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

$i=2;$x="$args"..5|%{' '*($j=if($_%2){$i-2}else{($i++)})+'<'+'-'*($_-(5,2)[$_%2])+'>'};($y=' '*++$j)+"___";"$y\ /";"$y |";$x;"$y *"

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

खैर, यह PowerShell में किसी से भी बातचीत नहीं करने के लिए एक सही गड़बड़ है ... इसलिए, आइए देखें कि मैं कैसे अच्छी तरह समझा सकता हूं कि यह कैसे काम करता है।

स्पष्टीकरण के लिए, मैं उपयोग करूंगा input = 17।

हम हेल्पर वेरिएबल $i=2को सेट $xकरने के लिए <something>, <something>इनपुट के $argsनीचे से रेंज के रूप में शुरू करने के साथ 5, ताकि, बहुत सरल शुरू करते हैं 17,16,15,...,6,5। उस सीमा को लूप के लिए पंप किया जाता है।

प्रत्येक यात्रा, हम सहायक चर की स्थापना के साथ शुरू $jएक का परिणाम माना if, बयान if($_%2){$i-2}else{($i++)}। यदि यह अजीब है $j=$i-2, अन्यथा $j=($i++)। यह, $i=2शुरुआत में युग्मित , हमें वह क्रम देता है 0, 2, 1, 3, 2, 4, 3, 5...जो ऐसा होता है कि वास्तव में हमारे पेड़ की लाइन के लिए हमें कितने स्थानों की आवश्यकता होती है। ;-) हम लेते हैं ' 'और स्ट्रिंग को उस संख्या से गुणा करते हैं।

आगे हमें अपनी शाखाओं की आवश्यकता है। यह '<'प्लस के साथ किया जाता है मध्य भाग '-'बाहर गुणा, प्लस अंत '>'। गुणन को पहचानकर किया जाता है कि इनपुट संख्या के आधार पर -एक 2, 5, 2, 5, 2...पैटर्न में वैकल्पिक $_, इसलिए हम उस पैटर्न के आधार पर एक छद्म-त्रिगुट से चयन कर रहे हैं।

आगे स्पष्टीकरण के लिए, यहां प्रत्येक खंड में पहले दो शब्द दिए गए हैं:

$_ = 17 16 15 14 13 12 11 10
$j =  0  2  1  3  2  4  3  5
mid=  2  5  2  5  2  5  2  5
'-'= 15 11 13  9 11  7  9  5

तो अब हम $xशाखाओं की एक सरणी (यानी, तार) होना तय है। लूप के बाहर, हम अब अपने पेड़ "शीर्ष" का निर्माण करते हैं, जिसमें उचित संख्या में रिक्त स्थान बच जाते हैं $y, फिर अपनी शाखाओं को प्रदर्शित करते हैं $x, और फिर पेड़ "नीचे" के साथ *। उनमें से प्रत्येक को पाइपलाइन पर छोड़ दिया गया है और आउटपुट को आइटम के बीच एक नई रेखा के साथ निहित किया गया है।

Answer 9

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

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,n=N,l=n=>' '[r](N/2-n/2)+(n-1?`<${'-'[r](n-2)}>
`:'*');n-3;n-=2)s+=l(n)+l(n-4)
return s}

f=

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,n=N,l=n=>' '[r](N/2-n/2)+(n-1?`<${'-'[r](n-2)}>
`:'*');n-3;n-=2)s+=l(n)+l(n-4)
return s}

console.log(f(7))
console.log(f(9))
console.log(f(13))
console.log(f(17))

Answer 10

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

-×>＋∔
__¶ /¶|╶┤ｒ⇵｛├⁸¹⁸｝ｋ*∔↔│

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

मेरे एसओजीएल उत्तर का एक बंदरगाह जो नील के चारकोल उत्तर का एक बंदरगाह है।

Answer 11

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,l=n=>' '[r](N/2-n/2)+n-1?`<${'-'[r](n-2)}>
`:'*');N-=2;s+=l(N)+l(N-4);return s}

जेएस ESGoogoltriplex पर मेरा प्रयास।

f=

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,l=n=>' '[r](N/2-n/2)+n-1?`<${'-'[r](n-2)}>
`:'*');N-=2;s+=l(N)+l(N-4);return s}

console.log(f(7))
console.log(f(9))
console.log(f(13))
console.log(f(17))