Thử thách

Chúng ta đều biết về cây Giáng sinh bình thường - nhưng về cây Giáng sinh lộn ngược ! Đây là một thử thách theo chủ đề Giáng sinh khá dễ dàng. Mục tiêu của thử thách này là biến tôi thành một cây thông Giáng sinh lộn ngược của ASCII. Dưới đây là các quy tắc cho thử thách này:

1. Chấp nhận một số nguyên lẻ, dương. Bạn có thể cho rằng nó sẽ luôn ở giữa 7và 51.

2. Cơ sở của cây sẽ được tạo thành từ các nhân vật:

   ___
   \ /
    |
   

3. Đỉnh của cây (ngôi sao), sẽ được tạo thành từ một * .

4. Mỗi dòng của cây sẽ được xây dựng bằng cách sử dụng định dạng <?>mà ?là bất kỳ số lượng -s. Ví dụ, nếu tạo một dòng có độ dài 5, dòng nên là <--->. Hoặc nếu tạo một dòng có chiều dài8 , dòng nên được <------>.

5. Đây là cách thân cây nên được xây dựng:

   1. Lấy số lẻ nđược đưa ra làm đầu vào và tạo một dòng của cây có chiều dài.

   2. Trừ 4từ nvà tạo ra một dòng của cây mà chiều dài.

   3. Trừ 2từ nvà tạo ra một dòng của cây mà chiều dài.

   4. Giảm ntheo 2. Sau đó, trừ khi nbằng5 , quay lại bước 2.

6. Cơ sở (xem bước 2.) ngôi sao (xem bước 3.) và mỗi dòng của cây (xem bước 4. và 5.) đều phải được căn giữa bằng cách sử dụng đầu vào số lẻ ban đầu (xem bước 1.) làm mức tối đa chiều rộng.

Ví dụ / Trường hợp kiểm tra

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
        *    

Quy tắc

• Tiêu chuẩn áp dụng .
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Python 3 , 127 121 105 103 100 98 byte

Đây là một hàm lambda không tên, trả về một danh sách các dòng:

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

Hãy thử trực tuyến!

Phần chính của câu trả lời này là (o-i+2-i%2*3) , tính ra số lượng dấu gạch ngang có trên một dòng. Phần còn lại của câu trả lời chỉ đơn giản là chuyển đổi điều này thành nghệ thuật ASCII mong muốn.

Rất cám ơn ông Xcoder , vì đã cạo 6 byte và thảo luận về golf với tôi khi trò chuyện.

Cũng cảm ơn Lynn vì đã nhận thấy rằng 3*(i%2)có thể i%2*3, ngắn hơn 2 byte!

C, 163 byte

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

Hãy thử trực tuyến!

Chưa được kiểm soát:

#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 byte

Cảm ơn FlipTack vì đã lưu 4 byte và cộng tác trong trò chuyện (chúng tôi thực sự tạo thành một nhóm tuyệt vời). Lưu gián tiếp 2 byte nhờ Lynn .

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

Hãy thử trực tuyến!

than củi , 28 byte

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

Hãy thử trực tuyến!Liên kết là phiên bản dài dòng của mã. Giải trình:

__⸿ /⸿|

In cơ sở.

Ｆ⮌…¹⊘Ｎ«

Lặp lại từ một nửa số đầu vào xuống 1.

⸿⊕ι>⸿⊖ι>»

In hai dòng, dòng đầu tiên có nhiều -hơn một chỉ số vòng lặp, dòng thứ hai có ít hơn một dòng.

‖Ｂ←

Gương để hoàn thành cây.

 *

Đặt ngôi sao.

SOGL V0.12 , 35 30 byte

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

Hãy thử nó ở đây!

Sử dụng thuật toán Char than của Neil , lấy đầu vào làm chỉ số trong các số lẻ - vì vậy 13 sẽ tương ứng với đầu vào 7

Võng mạc , 89 byte

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

Hãy thử trực tuyến! Giải thích: Giai đoạn đầu tiên chuyển đổi đầu vào thành unary và nối thêm a >. Giai đoạn thứ hai thay thế hai -s bằng a <để sửa độ dài dòng. Giai đoạn thứ ba sau đó sao chép nhánh nhưng mỗi lần ngắn hơn một chút cho đến khi nhánh không thể rút ngắn thêm nữa. Giai đoạn cuối cùng thêm cơ sở và ngôi sao.

Javascript 506 byte

Phiên bản golf:

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}

Phiên bản 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;
}

Sử dụng: console.log(tree(13)), console.log(tree(17)),

ES6 165 byte (từ bạn tôi)

Phiên bản golf:

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

Phiên bản 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;
  }
}

Sử dụng: p(31); p(17);

PowerShell , 131 byte

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

Hãy thử trực tuyến!

Chà, đây là một mớ hỗn độn đúng với bất kỳ ai không nói chuyện trong PowerShell ... vì vậy, hãy xem tôi có thể giải thích nó hoạt động tốt như thế nào.

Để giải thích, tôi sẽ sử dụng input = 17.

Chúng tôi bắt đầu đủ đơn giản, với cách đặt biến helper $i=2và thiết lập $xđể <something>, với sự <something>bắt đầu như một loạt từ đầu vào $argsxuống 5, vì vậy 17,16,15,...,6,5. Phạm vi đó được bơm vào một vòng lặp for.

Mỗi lần lặp, chúng ta bắt đầu với việc đặt biến của trình trợ giúp $jlà kết quả của một ifcâu lệnh if($_%2){$i-2}else{($i++)}. Nếu nó là lạ $j=$i-2, nếu không $j=($i++). Điều này, cùng với $i=2lúc ban đầu, cung cấp cho chúng ta trình tự 0, 2, 1, 3, 2, 4, 3, 5...xảy ra tương ứng chính xác với số lượng không gian chúng ta cần để thêm vào dòng cây của chúng ta. ;-) Chúng tôi lấy ' 'và nhân chuỗi đó với số đó.

Tiếp theo chúng ta cần các chi nhánh của chúng tôi. Điều này được thực hiện với '<'cộng với phần giữa được '-'nhân ra, cộng với phần cuối '>'. Phép nhân được thực hiện bằng cách nhận ra rằng sự -thay thế trong một 2, 5, 2, 5, 2...mẫu dựa trên số đầu vào$_ , vì vậy chúng tôi đang chọn từ một giả giả dựa trên mẫu đó.

Để làm rõ hơn, đây là các thuật ngữ cặp đôi đầu tiên trong mỗi phần:

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

Vì vậy, bây giờ chúng ta đã thiết lập thành $xmột mảng các nhánh (tức là các chuỗi). Bên ngoài vòng lặp, bây giờ chúng ta xây dựng cây "trên cùng" với số lượng khoảng trống thích hợp được lưu vào $y, sau đó hiển thị các nhánh của chúng ta $xvà sau đó là cây "dưới cùng" với cây *. Mỗi trong số đó được để lại trên đường ống và đầu ra được ẩn với một dòng mới giữa các mục.

JavaScript (ES6), 150 147 byte

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

Canvas , 28 byte

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

Hãy thử nó ở đây!

Một cổng của câu trả lời SOGL của tôi, đó là một cổng của câu trả lời Char than của Neil.

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}

Nỗ lực của tôi tại JS 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))