นี่คือฟักทอง ASCII ที่แกะสลักไว้ใน Jack-o-Lantern มันน่ารักใช่ไหม

((^v^))

นี่คือผี ASCII ดูสิว่ามันน่ากลัวขนาดไหน!

\{O.O}/

เห็นได้ชัดว่าฟักทองจะต้องอยู่บนพื้นดินมีช่องว่างระหว่างพวกเขาเพื่อให้พวกเขาไม่เน่า

ผีชอบยืนบนฟักทองดังนั้นพวกมันจึงน่ากลัวกว่า อย่างไรก็ตามพวกเขาต้องยืนอยู่บนฟักทองสองลูกมิฉะนั้นน้ำหนักที่น่ากลัวของพวกเขาจะบดขยี้ฟักทองที่อยู่ข้างใต้ แต่เนื่องจากเวทมนตร์ของพวกเขาทำงานอย่างไรผีหลายตัวสามารถซ้อนและแบ่งปันฟักทองได้หากว่าผีถูกแบ่งเท่า ๆ กันบนฟักทองล่างหรือผีล่าง ในคำอื่น ๆ การสร้างรูปร่างเหมือนเป็นมนุษย์ปิรามิด โปรดทราบว่าผีไม่สามารถซ้อนทับผีได้เว้นแต่จะมีฟักทองอยู่ข้างล่าง

กำหนดจำนวนเต็มสองค่าที่ไม่เป็นลบgและpแสดงจำนวนgโฮสต์และpumpkins ส่งออกรูปแบบซ้ายสุดที่กะทัดรัดที่สุดที่เป็นไปได้ตามกฎปิรามิดกองซ้อนข้างต้น ฟักทองและผีที่เหลือ (นั่นคือคนที่ไม่ได้สร้างปิรามิด) ไปที่พื้นทางด้านขวา

สำหรับการชี้แจงการก่อตัวเหล่านี้จะตกลง (ขึ้นบรรทัดใหม่ว่างเปล่า) และทำหน้าที่เป็นตัวอย่าง I / O:

0p 1g
\{O.O}/

1p 0g
((^v^))

1p 1g
((^v^)) \{O.O}/

2p 1g
    \{O.O}/
((^v^)) ((^v^))

2p 2g
    \{O.O}/
((^v^)) ((^v^)) \{O.O}/

3p 1g
    \{O.O}/
((^v^)) ((^v^)) ((^v^))

3p 2g
    \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^))

3p 3g
        \{O.O}/
    \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^))

0p 4g
\{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/

3p 0g
((^v^)) ((^v^)) ((^v^))

7p 6g
            \{O.O}/
        \{O.O}/ \{O.O}/
    \{O.O}/ \{O.O}/ \{O.O}/
((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^))

การก่อตัวเหล่านี้จะไม่ตกลง

\{O.O}/
((^v^))

    \{O.O}/
((^v^))

((^v^)) ((^v^)) \{O.O}/

    \{O.O}/
    \{O.O}/
((^v^)) ((^v^))

            \{O.O}/
\{O.O}/ ((^v^)) ((^v^))

    ((^v^))
((^v^)) ((^v^))

      \{O.O}/
((^v^)) ((^v^))

อินพุต

สอง integers เชิงลบในรูปแบบที่สะดวกใด ๆ ตัวเลขอย่างน้อยหนึ่งตัวจะไม่ใช่ศูนย์ คุณสามารถรับอินพุตในลำดับใดก็ได้ (เช่นในตัวอย่างที่ฉันมีฟักทองก่อน) - โปรดระบุวิธีที่คุณป้อนข้อมูลในคำตอบของคุณ

เอาท์พุต

การแทน ASCII-art ของผีและฟักทองตามกฎข้างต้น ขึ้นบรรทัดใหม่ / ตามหลังหรือช่องว่างอื่น ๆ เป็นตัวเลือกโดยที่ผีและฟักทองเข้าแถวอย่างเหมาะสม

กฎระเบียบ

• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการตีกอล์ฟตามปกติและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

JavaScript (ES7), 166 164 159 ไบต์

บันทึก 5 ไบต์ด้วย Neil

f=(p,g,j=(g*2)**.5+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

จัดรูปแบบและแสดงความคิดเห็น

f = (                                    // given:
  p,                                     // - p = number of pumpkins
  g,                                     // - g = number of ghosts
  j = (g * 2) ** .5 + .5 | 0,            // - j = ceil(triangular root of g)
  G = j > p - 1 ? p ? p - 1 : 0 : j,     // - G = max(0, min(p - 1, j))
  P = '\n',                              // - P = padding string (+ line-break)
  i = ~j ?                               // - i =
    g - G * ++G / 2                      //   first iteration: g - G * (G + 1) / 2
  : G,                                   //   next iterations: G
  n = i > 0 ? i > g ? g : i : 0          // - n = max(0, min(i, g)) = number of
) =>                                     //   ghosts to print at this iteration
p | g ?                                  // if there's still something to print:
  f(                                     //   do a recursive call with:
    0,                                   //   - no pumpkin anymore
    g - n,                               //   - the updated number of ghosts
    -1,                                  //   - j = -1 (so that ~j == 0)
    G - 1,                               //   - one less ghost on the pyramid row
    P + '    '                           //   - updated padding string
  ) +                                    //   
  P +                                    //   append padding string
  '((^v^)) '.repeat(p) +                 //   append pumpkins
  '\\{O.O}/ '.repeat(n)                  //   append ghosts
: ''                                     // else: stop

คณิตศาสตร์พื้นฐาน

ส่วนที่ยุ่งยากคือการหาความกว้างที่เหมาะสมGของปิรามิดผี

จำนวนของผีgในปิรามิดเช่นนั้นได้รับจาก:

g = 1 + 2 + 3 + ... + G = G(G + 1) / 2

ซึ่งกันและกันความกว้างของปิรามิดที่มีgผีเป็นรากที่แท้จริงของสมการกำลังสองที่เกิดขึ้น:

G² + G - 2g = 0

Δ = 1² - 4(-2g)
Δ = 8g + 1

G = (-1 ± √Δ) / 2

ซึ่งนำไปสู่รูทจริงต่อไปนี้ (หรือที่เรียกว่ารูตสามเหลี่ยม ):

G = (√(8g + 1) - 1) / 2

อย่างไรก็ตามความกว้างของปิรามิดนั้นถูก จำกัด ด้วยจำนวนของฟักทอง: เราสามารถมีp-1ผีได้มากกว่าpฟักทอง ดังนั้นสูตรสุดท้ายที่ใช้ในรหัส:

j = ⌈(√(8g + 1) - 1) / 2⌉
G = max(0, min(p - 1, j))

รุ่น ES6, 173 171 166 ไบต์

f=(p,g,j=Math.pow(g*2,.5)+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

กรณีทดสอบ (ES6)

f=(p,g,j=Math.pow(g*2,.5)+.5|0,G=j>p-1?p?p-1:0:j,P=`
`,i=~j?g-G*++G/2:G,n=i>0?i>g?g:i:0)=>p|g?f(0,g-n,-1,G-1,P+'    ')+P+'((^v^)) '.repeat(p)+'\\{O.O}/ '.repeat(n):''

console.log(f(0, 1));
console.log(f(1, 0));
console.log(f(1, 1));
console.log(f(2, 1));
console.log(f(2, 2));
console.log(f(3, 1));
console.log(f(3, 2));
console.log(f(3, 3));
console.log(f(0, 4));
console.log(f(3, 0));
console.log(f(7, 6));

Perl, 246 ไบต์ (บรรทัดใหม่ไม่ได้เป็นส่วนหนึ่งของรหัสและมีไว้เพื่อการอ่านเท่านั้น)

($c,$d)=<>=~/(\d+)/g;
$p="((^v^)) ";$g="\\{O.O}/ ";
for($f[0]=$c;$d>0;$d--){$f[$b+1]+1<$f[$b]?$f[++$b]++:$f[$b]++;$f[0]+=$d,$d=0 if$b==$c-1;$f[$b]==1?$b=0:1}
$h[0]=($p x$c).$g x($f[0]-$c);$h[$_].=$"x(4*$_).$g x$f[$_]for(1..$#f);
say join$/,reverse@h;

ยอมรับตัวเลขสองตัว: ฟักทองก่อนตามด้วยผี ตัวอย่างอินพุต:

5 20

ตัวอย่างผลลัพธ์:

                \{O.O}/ 
            \{O.O}/ \{O.O}/ 
        \{O.O}/ \{O.O}/ \{O.O}/ 
    \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ 
((^v^)) ((^v^)) ((^v^)) ((^v^)) ((^v^)) \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/ \{O.O}/