这是刻在Jack-o-Lantern中的ASCII南瓜。可爱吗？

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

输入值

任何方便格式的两个非负整数。至少一个数字将为非零。您可以按任何顺序输入（即，在我先有南瓜的示例中）-请指定您在答案中的输入方式。

输出量

遵循上述规则，用ASCII艺术表示鬼影和南瓜。前导/尾随换行符或其他空格是可选的，但前提是幽灵和南瓜可以正确排列。

规则

• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常见的高​​尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

的JavaScript（ES7），166个 164 159字节

由于尼尔节省了5个字节

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