Meydan okuma

Hepimiz normal Noel ağaçlarını biliyoruz - ama baş aşağı bir Noel ağacına ne dersiniz ! Bu oldukça kolay, Noel temalı bir meydan okuma. Bu zorluğun amacı bana bir ASCII baş aşağı Noel ağacı yapmaktır. İşte bu meydan okuma için kurallar:

1. Tuhaf, pozitif bir tamsayıyı kabul edin. Sen hep arasında olacaktır varsayabiliriz 7ve 51.

2. Ağacın tabanı karakterlerden oluşacaktır:

   ___
   \ /
    |
   

3. Ağacın tepesi (yıldız), tek bir parçadan oluşacaktır *.

4. Ağacın her satır biçimini kullanarak inşa edilecek herhangi bir sayıdır s. Örneğin, bir uzunluk çizgisi yapıyorsanız , çizgi olmalıdır . Veya bir uzunluk çizgisi yapıyorsanız , çizgi olmalıdır .<?>?-5<--->8<------>

5. Ağacın gövdesi şu şekilde inşa edilmelidir:

   1. nGiriş olarak verilen tek sayıyı alın ve bu uzunlukta bir ağaç çizgisi oluşturun.

   2. Çıkar 4gelen nve bu uzunluğun ağacının bir çizgi oluşturun.

   3. Çıkar 2gelen nve bu uzunluğun ağacının bir çizgi oluşturun.

   4. Azalma ntarafından 2. Bundan sonra, neşit5 olmadığı sürece 2. adıma geri dönün.

6. Taban (bkz. Adım 2.) yıldız (bkz. Adım 3.) ve ağacın her satırı (bkz. Adım 4. ve 5.), orijinal tek sayı girişi (bkz. Adım 1) maksimum olmalıdır. Genişlik.

Örnekler / Test Örnekleri

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
        *    

kurallar

• Standart boşluklar geçerlidir .
• Bu kod golf , bu yüzden bayt en kısa cevap kazanır!

Piton 3 , 127 121 105 103 100 98 bayt

Bu, bir satır listesi döndüren adlandırılmamış bir lambda işlevidir:

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

Çevrimiçi deneyin!

Bu cevabın ana kısmı (o-i+2-i%2*3), bir çizgi üzerindeki çizgi sayısını hesaplamaktır. Cevabın geri kalanı bunu istenen ASCII sanatına dönüştürmektir.

Bay Xcoder'a 6 bayt traş olduğu ve sohbet ederken benimle golf tartıştığı için çok teşekkürler .

Lynn'e 2 bayt daha kısa 3*(i%2)olabileceğini fark ettiği için teşekkürler i%2*3!

C, 163 bayt

#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);}

Çevrimiçi deneyin!

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);
}

Proton , 83 bayt

FlipTack'e 4 bayt kaydettiği ve sohbette işbirliği yaptığınız için teşekkürler (aslında harika bir takım oluşturuyoruz). Lynn sayesinde dolaylı olarak 2 bayt tasarruf etti .

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

Çevrimiçi deneyin!

Odun kömürü , 28 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

__⸿ /⸿|

Tabanı yazdırın.

Ｆ⮌…¹⊘Ｎ«

Giriş numarasının yarısından 1'e kadar döngü yapın.

⸿⊕ι>⸿⊖ι>»

İlki -döngü dizininden bir tane daha , ikincisi bir tane daha az olan iki satır yazdırın .

‖Ｂ←

Ağacı tamamlamak için ayna.

 *

Yıldızı yerleştirin.

SOGL V0.12 , 35 30 bayt

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

Buradan Deneyin!

Neil'in Kömür algoritmasını kullanır , tek sayılarda endeks olarak girdi alır - bu nedenle 13 girdi 7'ye karşılık gelir

Retina , 89 bayt

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

Çevrimiçi deneyin! Açıklama: İlk aşama girişi tekli'ye dönüştürür ve a ekler >. İkinci aşama , hat uzunluğunu düzeltmek için iki -s'yi a ile değiştirir <. Üçüncü aşama daha sonra dalı çoğaltır, ancak dal daha fazla kısaltılamayana kadar her seferinde biraz daha kısadır. Son aşamada üs ve yıldız eklenir.

JavaScript 506 bayt

Golf-sürümü:

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-sürümü:

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;
}

Kullanımı: console.log(tree(13)), console.log(tree(17)),

ES6 165 bayt (arkadaşımdan)

Golf-sürümü:

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-sürümü:

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;
  }
}

Kullanımı: p(31); p(17);

PowerShell , 131 bayt

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

Çevrimiçi deneyin!

Bu, PowerShell'de konuşamayan herkes için doğru bir karışıklık ... bu yüzden, nasıl çalıştığını ne kadar iyi açıklayabileceğimi görelim.

Açıklama için kullanacağım input = 17.

Biz yardımcı değişkeni ayarı ile, basit yeterince başlamak $i=2ve ayar $xiçin <something>birlikte <something>girişten bir aralık olarak başlayan $argsaşağı etmek 5, böylece 17,16,15,...,6,5. Bu aralık bir for döngüsü içine pompalanır.

Her bir yineleme, yardımcı değişkenin $jbir ififadenin sonucu olarak ayarlanmasıyla başlıyoruz if($_%2){$i-2}else{($i++)}. Tuhafsa $j=$i-2, aksi takdirde $j=($i++). Bu, $i=2başlangıçta birleştiğinde bize, 0, 2, 1, 3, 2, 4, 3, 5...ağaç hattımıza kaç boşluk eklememiz gerektiğini tam olarak karşılayan diziyi verir . ;-) Biz ' 'bu sayı ile almak ve string-çarpma.

Sonra şubelerimize ihtiyacımız var. Bu '<'artı orta bölüm '-'çarpılmış artı son yapılır '>'. Çarpma, giriş numarasına dayalı -bir 2, 5, 2, 5, 2...desendeki alternatifin kabul edilmesiyle yapılır $_, bu yüzden o desene dayalı bir sahte üçlüden seçiyoruz.

Daha fazla açıklama için, her bölümdeki ilk çift terimler şunlardır:

$_ = 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

Şimdi $xbir dizi dal (yani, dizeler) olmaya ayarladık . Döngünün dışında, ağaçlarımıza "top" u uygun sayıda boşlukla kurduktan $ysonra şubelerimizi $xve sonra da ağaçla "alt" ı oluşturuyoruz *. Bunların her biri boru hattında bırakılır ve çıktılar, öğeler arasında yeni bir satır ile örtüşür.

JavaScript (ES6), 150 147 bayt

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))

Tuval , 28 bayt

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

Burada deneyin!

Neil'in Kömür cevabının bir limanı olan SOGL cevabımın bir limanı.

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}

JS ESGoogoltriplex'teki girişimim.

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))