Dada una cadena de letras ASCII (mayúsculas y / o minúsculas), genera el MathJax sin procesar requerido para mostrar esa cadena bifurcada en cada carácter, en superíndices y subíndices. Por ejemplo, las entradas caty horsedarían como resultado salidas que MathJax representa de la siguiente manera, respectivamente:

Tenga en cuenta que solo se requiere una entrada: estas dos se enumeran una al lado de la otra simplemente para ahorrar espacio vertical.

Significado de marcado

• _ indica un subíndice.
• ^ indica un superíndice.
• Se requieren llaves alrededor de las subcadenas con superíndice o subíndice que contienen más superíndice o subíndice para evitar que todas estén al mismo nivel.

Casos de prueba

Los casos de prueba están en el formato input : output. El primer caso de prueba muestra la cadena vacía como entrada debe dar como resultado la cadena vacía como salida.

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

Puede ver cómo se procesan pegando la salida en mathurl.com .

Sin llaves redundantes

MathJax felizmente representará el marcado que tiene llaves redundantes. Por ejemplo, lo siguiente será todo un aspecto idéntico cuando se representa: a, {a}, {}{a}, {{{{a}}}}.

Sin embargo, la salida válida para este desafío no tiene llaves redundantes. Tenga en cuenta en particular que los caracteres individuales en la salida no están rodeados por llaves.

Orden

El orden del subíndice y el superíndice no es importante. Los siguientes son equivalentes y serán indistinguibles cuando se procesen (y son todos productos igualmente válidos):

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}

Tanteo

Para cada idioma, el ganador es el código más corto en bytes.

_{¿Demasiadas notificaciones? Escriba}para cancelar la suscripción</sub>

Python, 95 90 86 92 82 bytes

10 bytes guardados gracias a @ConnerJohnston

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

Pruébalo en línea!

Mathematica, 72 84 77 76 bytes

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

Utiliza la codificación CP-1252 (Windows). Toma una lista de caracteres como entrada.

Explicación

a_±b__:=

Defina la función ±, con 2 o más argumentos. Rotula el primer argumento a, y el segundo y más b.

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

Cree un Listequivalente a "{a_±b^±b}"( ±bse evalúa nuevamente, de forma recursiva).

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

Defina la función ±, con 1 o 0 argumentos. Etiquete el primer argumento a, si existe, y asígnelo ""a lo acontrario.

{"",a,""}

Cree un Listequivalente a "a", rellenado con Strings vacío .

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

Una función pura que se aplica ±a la entrada, elimina el primer y el último elemento y convierte Lista String.

CJam (35 bytes)

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

Este es un programa completo. Demo en línea .

3 bytes evitan un error en el intérprete (ver más abajo).

Disección

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

Tenga en cuenta que min(n+1, 3)es para evitar un error en el intérprete: debe haber algún patrón en las potencias de 10 que '}sea ​​menor que, pero no es obvio .

JavaScript (ES6), 57 55 bytes

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

Complexity (len (s)) complejidad! Según @PeterTaylor, esto es en realidad Θ (2 ^ len (s)), que sigue siendo el mejor posible ...

Haskell , 71 bytes

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

Pruébalo en línea!

Si solo tuviéramos que generar un código válido, lo siguiente funcionaría para 44 bytes:

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

Pruébalo en línea!

SOGL V0.12 , 21 bytes

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

Pruébalo aquí!

Explicación:

±                      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 bytes

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

Pruébalo en línea!

¿Cómo?

La sustitución en la condición while rompe las apariciones de varias letras en la primera letra, seguidas del resto en llaves como esta:

abc -> a_{bc}^{bc}

El ciclo while ejecuta la sustitución hasta que no queden más secuencias de varias letras. La sustitución dentro del bucle elimina llaves de alrededor de letras individuales.

Ruby , 76 73 72 68 67 57 bytes

Uso de lambda ahorrando 4 bytes gracias a Tutleman

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

Pruébalo en línea!

Sin golf:

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 bytes

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

Pruébalo en línea!

Pyth , 47 bytes

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

Pruébalo en línea!

Esto es más o menos un puerto directo de la respuesta Python de @Uriel. Ir al golf en un poco.

PHP, 121 bytes

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

La función en sí es de 104 bytes y muestra un aviso PHP.

Retina , 43 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

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

Haz que la pelota ruede cortando al último personaje. (Pero si es el único personaje, lo dejan en paz).

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

Mueva el carácter ¶ hacia atrás un paso a la vez, cada vez tomando el resultado anterior y convirtiéndolo en un subíndice y superíndice del siguiente carácter.

¶{|}$

Elimine el ahora redundante ¶ y el exterior {} s.

Java (OpenJDK 8) , 121 bytes

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

Pruébalo en línea!

Javascript, 73 bytes

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

Explicación

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

Como no hay un valor inicial especificado de m, reduceRighttoma el último elemento de scomo valor inicial y comienza a iterar en el índice 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>