给定一串ASCII字母（大写和/或小写），将显示每个字符分叉的字符串所需的原始MathJax输出为上标和下标。例如，输入cat和horse将导致MathJax分别呈现如下的输出：

请注意，只需要输入一个输入-并排列出这两个输入只是为了节省垂直空间。

标记含义

• _ 表示下标。
• ^ 表示上标。
• 在包含进一步的上标或下标的上标或下标子字符串周围需要括号，以防止它们都处于同一级别。

测试用例

测试用例采用格式input : output。第一个测试用例显示空字符串作为输入，应导致空字符串作为输出。

"" : ""
"a" : "a"
"me" : "m_e^e"
"cat" : "c_{a_t^t}^{a_t^t}"
"frog" : "f_{r_{o_g^g}^{o_g^g}}^{r_{o_g^g}^{o_g^g}}"
"horse" : "h_{o_{r_{s_e^e}^{s_e^e}}^{r_{s_e^e}^{s_e^e}}}^{o_{r_{s_e^e}^{s_e^e}}^{r_{s_e^e}^{s_e^e}}}"
"bifurcate" : "b_{i_{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}^{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}}^{i_{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}^{f_{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}^{u_{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}^{r_{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}^{c_{a_{t_e^e}^{t_e^e}}^{a_{t_e^e}^{t_e^e}}}}}}}"

您可以通过将输出粘贴到mathurl.com中来查看它们的呈现方式。

没有多余的括号

MathJax将愉快地渲染具有多余花括号的标记。例如，渲染时下面将所有看起来相同：a，{a}，{}{a}，{{{{a}}}}。

但是，此挑战的有效输出没有多余的花括号。请特别注意，输出中的单个字符不会被花括号包围。

订购

下标和上标的顺序无关紧要。以下是等效的，并且在呈现时将无法区分（并且都是同等有效的输出）：

c_{a_t^t}^{a_t^t}
c_{a^t_t}^{a_t^t}
c_{a_t^t}^{a^t_t}
c_{a^t_t}^{a^t_t}
c^{a_t^t}_{a_t^t}
c^{a^t_t}_{a_t^t}
c^{a_t^t}_{a^t_t}
c^{a^t_t}_{a^t_t}

计分

对于每种语言，获胜者都是以字节为单位的最短代码。

_{通知太多？键入}到unsubscript</sub>

Python，95 90 86 92 82字节

@ConnerJohnston节省了10个字节

f=lambda s:s and s[0]+(s[1:]and'_{0}^{0}'.format(s[2:]and'{'+f(s[1:])+'}'or s[1]))

在线尝试！

Mathematica，72 84 77 76字节

a_±b__:={"{",a,"_",±b,"^",±b,"}"};±(a_:""):={"",a,""};""<>Most@Rest@±##&@@#&

使用CP-1252（Windows）编码。将字符列表作为输入。

说明

a_±b__:=

±使用2个或更多参数定义函数。标记第一个参数a，然后标记第二个b。

{"{",a,"_",±b,"^",±b,"}"}

创建一个List等效于"{a_±b^±b}"（±b递归地再次评估）。

±(a_:""):= ...

±使用1或0参数定义函数。标记第一个参数a（如果存在），然后分配""给a其他参数。

{"",a,""}

创建与List等效的"a"，并用空Strings 填充。

""<>Most@Rest@±##&@@#&

适用±于输入的纯函数，删除第一个和最后一个元素，然后转换List为String。

CJam（35字节）

MqW%{"^{ }_{ }"{AW$,)3e<#<},S/@*+}/

这是一个完整程序。在线演示。

3个字节可解决解释器中的错误（请参见下文）。

解剖

M            e# Start building from the empty string
qW%{         e# For each character in the reversed input
  "^{ }_{ }" e#   Take a template
  {          e#   If the accumulator is of length n, remove all characters whose
    A        e#   codepoints are greater than pow(10,
    W$,)3e<  e#                                   min(n+1, 3))
    #<       e#   When the accumulator is the empty string, that's all of them.
  },         e#   When the accumulator is one character, that's {}
             e#   When the accumulator is any longer, it's none of them.
  S/@*       e#   Substitute the accumulator for the spaces.
  +          e#   Append to the new character.
}/

请注意，min(n+1, 3)可以解决解释器中的错误：10的幂中必须有一些模式'}小于，但并不明显。

JavaScript（ES6），57 55字节

f=([c,...s])=>s+s?c+`_${p=s[1]?`{${f(s)}}`:s}^`+p:c||''

Θ（len）复杂！根据@PeterTaylor，这实际上是Θ（2 ^ len（s）），这仍然是最好的...

Haskell，71个字节

f[x,y]=x:'_':y:'^':y:[]
f(x:y@(_:_))=x:"_{"++f y++"}^{"++f y++"}"
f x=x

在线尝试！

如果我们只需要输出有效的代码，则以下内容将适用于44个字节：

f[a]=[a]
f(a:b)=a:"_{"++f b++"}^{"++f b++"}"

在线尝试！

SOGL V0.12，21个字节

±K;{╔+;lH?"{ŗ}”}1 ^Ο+

在这里尝试！

说明：

±                      reverse the string
 K                     take off the first letter - will slowly convert to the output
  ;                    get the rest of the string ontop
   {                   iterate over the rest of the characters
    ╔+                   append "_" to it
      ;                  get the output string ontop
       lH?     }         if it's length - 1 [isn't 0]
          "{ŗ}”            push the string "{ŗ}" where ŗ is replaced by the output string
                1 ^Ο     wrap "^" around with the output string
                    +    prepend to it the current character + "_"

Perl 5、54 + 1（-p）= 55个字节

s/\{(.)\}/$1/g while s/([a-z])([a-z]+)/$1_{$2}^{$2}/ig

在线尝试！

怎么样？

while条件中的替换会中断第一个字母中多个字母的出现，然后其余的都用大括号括起来，如下所示：

abc -> a_{bc}^{bc}

while循环执行替换，直到没有更多的多字母序列剩余为止。循环内的替换可删除单个字母周围的花括号。

Ruby，76 73 72 68 67 57字节

使用Tumbman节省了4个字节的lambda使用

f=->s{(r=s[1..-1])[0]?s[0]+?_+[r[1]??{+f[r]+?}:r]*2*?^:s}

在线尝试！

取消高尔夫：

def f(s)
  r = s[1..-1]
  if r.size > 0
    if r.size > 1
      x = "{" + f(r) + "}"
    else
      x = r
    end
    return s[0] + "_" + [x, x].join("^")
  else
    return s
  end
end

Python 2，84个字节

def b(s):q=s and(s[2:]and'{%s}'or'%s')%b(s[1:]);return s[1:]and s[0]+'^%s_'%q+q or s

在线尝试！

Pyth，47个字节

Ljk[hb|&ttbs[\_\{ytb"}^{"ytb\})&tbs[\_htb\^htb;

在线尝试！

这几乎是@Uriel的Python答案的直接入口。一会儿去打高尔夫球。

PHP，121字节

function b($s){return $s[0].($s[1]?'_'.($s[2]?'{'.($b=b(substr($s,1))).'}^{'.$b.'}':"$s[1]^$s[1]"):'');}echo b($argv[1]);

该函数本身为104个字节，并显示PHP声明。

视网膜，43字节

(.)(.)$
$1¶$2
+`(.)¶(.*)
¶{$1_$2^$2}
¶{|}$

在线尝试！链接包括测试用例。说明：

(.)(.)$
$1¶$2

切下最后一个字符，使球滚动。（但是，如果这是唯一的角色，他们会不理会它。）

+`(.)¶(.*)
¶{$1_$2^$2}

一次将¶字符后退一步，每次获取前一个结果并将其作为下一个字符的下标和上标。

¶{|}$

删除现在多余的¶和外部的{}。

Java（OpenJDK 8），121字节

s->{int l=s.length;String r=--l<0?"":""+s[l];for(;l-->0;)r="{"+s[l]+"_"+r+"^"+r+"}";return r.replaceAll("^\\{|\\}$","");}

在线尝试！

Javascript，73个字节

s=>[...s].reduceRight((m,c)=>`${c}_{${m}}^{${m}}`).replace(/{(.)}/g,'$1')

说明

s=>                                  // take the input string
    [...s]                           // split the string into an array
    .reduceRight(                    // reduce the array in reverse order
        (m,c)=>`${c}_{${m}}^{${m}}`  // storing the result of each iteration in the memo m
    )                                // and returning m at the end
    .replace(/{(.)}/g,'$1')          // replace redundant {}

因为没有指定的初始值m，所以reduceRight将的最后一个元素s作为初始值，然后从index开始迭代s.length-2。

const f=s=>[...s].reduceRight((m,c)=>`${c}_{${m}}^{${m}}`).replace(/{(.)}/g,'$1');

const input = document.querySelector('#input');
const output = document.querySelector('#output');
output.textContent = f(input.value);
input.addEventListener('keyup', e => output.textContent = f(input.value));

Enter text to bifurcate: <input type="text" id="input" value="cat" />
<br />
<span id="output"></span>