ทำให้ฉันเป็นต้นคริสต์มาสคว่ำ!

15

ท้าทาย

เราทุกคนรู้เกี่ยวกับต้นคริสต์มาสปกติ - แต่ต้นคริสต์มาสกลับหัวกลับหาง ! นี่เป็นความท้าทายในรูปแบบคริสมาสต์ที่ค่อนข้างง่าย วัตถุประสงค์ของความท้าทายนี้คือทำให้ฉันเป็นต้นคริสต์มาส ASCII คว่ำ นี่คือกฎสำหรับการท้าทายนี้:

  1. ยอมรับจำนวนเต็มคี่และบวก คุณสามารถสันนิษฐานได้ว่ามันก็จะอยู่ระหว่างและ751

  2. ฐานของต้นไม้จะทำจากตัวละคร:

    ___
\ /
 |

  3. ด้านบนของต้นไม้ (ดาว) *จะถูกสร้างขึ้นจากเดียว

  4. แต่ละบรรทัดของต้นไม้จะถูกสร้างโดยใช้รูปแบบ<?>ที่?มีจำนวน-s ใด ๆ ตัวอย่างเช่นถ้าทำเส้นความยาวเส้นที่ควรจะเป็น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
        *

กฎระเบียบ

  • ช่องโหว่ตามมาตรฐาน
  • นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ!
code-golf  string  ascii-art 
— คริสเตียนดีน
แหล่งที่มา
3
การเห็นว่าอินพุตถูกรับประกันว่าเป็นเลขคี่เราสามารถหาดัชนีในลำดับเลขคี่ได้หรือไม่?
— FlipTack
นอกจากนี้ - repeat the above steps until the odd number minus 2 equals 5- ในการป้อนข้อมูลครั้งแรกจำนวนคี่คือ 7 และ 7-2 = 5 ดังนั้นต้นไม้ควรจะจบลงทันที (ฉันรู้ว่าคุณหมายถึงอะไร แต่มันต้องการการใช้
— ถ้อยคำใหม่
@FlipTack ฉันไม่แน่ใจว่าคุณหมายถึงอะไร ถ้าเป็นเลขคี่7เข้าต่ำสุดที่คุณจะเป็นครั้งแรกสร้างสามบรรทัดต้นไม้ (ย่อยขั้นตอน .1.1, .1.2, .1.3) แล้วลบจากเลขคี่และการทดสอบถ้ามันเท่ากับ2 5คำแนะนำในการตรวจสอบว่า "เลขคี่ลบ 2 เท่ากับ 5" เป็นที่สิ้นสุดหรือไม่ควรดำเนินการสามขั้นตอนอื่นก่อน แต่เพื่อตอบความคิดเห็นแรกของคุณนั่นน่าจะดี
— Christian Dean
1
@FlipTack ฉันคิดว่าเขาถามว่าคุณต้องยอมรับ7เป็นอินพุตหรือถ้าคุณสามารถยอมรับ4ได้เช่นเดียวกับในเลขคี่ที่สี่ (หรือ3ถ้าเป็นดัชนี 0)
— DonielF
4
จากชื่อ: "โอเคตอนนี้คุณเป็นต้นคริสต์มาสคว่ำแล้ว"
— dkudriavtsev

คำตอบ:

10

Python 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-art ที่ต้องการ

ขอขอบคุณMr. Xcoder ที่ช่วยให้คุณโกนหนวดได้ 6 ไบต์และพูดคุยเรื่องกอล์ฟกับฉันในการแชท

ขอขอบคุณLynn ที่สังเกตเห็นว่า3*(i%2)มีความยาวi%2*32 ไบต์!

— FlipTack
แหล่งที่มา
— Mr. Xcoder
2
เมื่อใดก็ตามที่ฉันโพสต์คำตอบของหลามไม่ว่าจะเป็นเวลากลางวันหรือที่ตั้งปัจจุบันของเขา @ Mr.Xcoder มีสนามกอล์ฟที่จะให้ :)
— FlipTack
Welpนี่ง่ายกว่าการแก้ปัญหา 250 bytes + Python ของฉัน งานที่ดี! +1
— คริสเตียนดีน
o-i+2-i%2*3บันทึกสองไบต์
— Lynn
@Lynn จุดที่ดีได้รับการปรับปรุง
— FlipTack
7

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

ลองออนไลน์!

คลี่:

#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);
}
— Steadybox
แหล่งที่มา
6

โปรตอน , 83 ไบต์

ขอบคุณFlipTackสำหรับการบันทึก 4 ไบต์และสำหรับการทำงานร่วมกันในการแชท (เราเป็นทีมที่ยอดเยี่ยมจริงๆ) ทางอ้อมที่บันทึกไว้ 2 ไบต์ขอบคุณที่ลินน์

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

ลองออนไลน์!

— นาย Xcoder
แหล่งที่มา
5

ถ่าน 28 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

__⸿ /⸿|

พิมพ์ฐาน

Ｆ⮌…¹⊘Ｎ«

วนซ้ำจากครึ่งหนึ่งของหมายเลขอินพุตลงเหลือ 1

⸿⊕ι>⸿⊖ι>»

พิมพ์สองบรรทัดบรรทัดแรกที่มีมากกว่าหนึ่ง-ลูปดัชนีหนึ่งที่สองที่น้อยกว่าหนึ่งรายการ

‖Ｂ←

กระจกเงาเพื่อให้ต้นไม้สมบูรณ์

 *

วางดาว

— นีล
แหล่งที่มา
3

เรติน่า , 89 ไบต์

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

ลองออนไลน์! คำอธิบาย: >ขั้นตอนแรกแปลงป้อนข้อมูลไปยังเอกและผนวก สเตจที่สองแทนที่สอง-s ด้วย a <เพื่อแก้ไขความยาวบรรทัด ขั้นตอนที่สามจะทำซ้ำสาขา แต่จะสั้นลงเล็กน้อยในแต่ละครั้งจนกว่าสาขาจะไม่สามารถย่อให้สั้นลงได้อีก ขั้นตอนสุดท้ายจะเพิ่มฐานและดาว

— นีล
แหล่งที่มา
2

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

— NTCG
แหล่งที่มา
1
คุณสามารถตีกอล์ฟได้มากโดยใช้ชื่อตัวแปรเพียงตัวอักษร 1 ตัวการลบconstคำหลัก ฯลฯ
— FlipTack
1

PowerShellขนาด 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ให้เป็นอาเรย์ของกิ่ง (เช่นสตริง) นอกห่วงตอนนี้เราสร้างต้นไม้ของเรา "top" ที่มีจำนวนที่เหมาะสมของพื้นที่บันทึกลง$yแล้วแสดงสาขาของเรา$xแล้วต้นไม้ "ด้านล่าง" *กับ แต่ละรายการจะถูกทิ้งไว้บนไปป์ไลน์และเอาท์พุทจะมีความหมายโดยขึ้นบรรทัดใหม่ระหว่างรายการ

— AdmBorkBork
แหล่งที่มา
1

JavaScript (ES6), 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}

แสดงตัวอย่างรหัส

— darrylyeo
แหล่งที่มา
0 
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

แสดงตัวอย่างรหัส

— user75200
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.