Usted es transportado en un universo paralelo donde las personas escriben ecuaciones matemáticas en computadoras como arte ASCII a mano. Como adicto a LaTeX, esto es totalmente inaceptable, y debería automatizar este proceso de alguna manera.

Su objetivo es escribir un programa que genere una versión ASCII de una ecuación incorporada como un comando matemático LaTeX.

Comandos obligatorios de LaTeX para admitir

• Suma: el comando LaTeX para una suma es \sum_{lower bound}^{upper bound}

  La cifra ASCII que debe usar para sumas es:

  upper bound
      ___ 
      \  `
      /__,
  lower bound
  

• Producto: el comando LaTeX para un producto es \prod_{lower bound}^{upper bound}

  La cifra ASCII que debe usar para los productos es:

  upper bound
      ____
      |  |
      |  |
  lower bound
  

• Fracción: el comando LaTeX para fracciones es \frac{numerator}{denominator}

  La cifra ASCII que debes usar para las fracciones es:

   numerator
  -----------
  denominator
  

Todo lo que no sea uno de esos tres comandos se muestra tal cual. Por ejemplo, \sum{i=3}^{e^10}\frac{3x+5}{2}debe mostrarse como

e^10
___  3x+5
\  ` ----
/__,  2
i=3

Entradas

La entrada es un comando LaTeX pasado como una cadena (o el equivalente de su idioma a las cadenas). Los comandos LaTeX se pueden anidar, por ejemplo, \frac{\frac{1}{2}}{3}es una entrada válida. Se supone que las entradas siempre son correctas (no es necesario verificar la sintaxis de LaTeX en su código). Las entradas solo consistirán en los tres comandos LaTeX presentados anteriormente y el 'texto' que no necesitará formatear.

Los comandos LaTeX siempre vendrán con la sintaxis presentada anteriormente, es decir, las sumas y los productos siempre tendrán límites superior e inferior (aunque pueden estar vacíos) y siempre habrá un numerador y un denominador para las fracciones.

Suponemos que los límites de las sumas y los productos tienen una longitud máxima de 4 caracteres (= el ancho de los símbolos de suma y producto), por lo que no tiene que preocuparse por posibles problemas de superposición. Por razones similares, asumimos que los límites son solo 'texto' y nunca serán comandos LaTeX, por ejemplo, \sum_{\sum_{1}^{2}}^{1}no es una entrada válida.

Salidas

La salida de su programa es la representación ASCII del comando LaTeX que recibió como entrada.

Su programa debe tener en cuenta la alineación horizontal: por ejemplo, los límites de la suma o el producto deben estar alineados horizontalmente con la suma o el símbolo del producto (que tienen 4 caracteres de ancho). Si el límite tiene un número impar de caracteres, no importa si está un carácter a la derecha o a la izquierda del centro, lo que esté bien. La línea de la fracción debe ser tan larga como el numerador o el denominador, el que sea más largo.

Su programa debe tener en cuenta la alineación vertical: por ejemplo, \frac{\frac{1}{2}}{3} = \frac{1}{6}debe mostrarse como

1
-
2   1
- = -
3   6

Para sumas y productos, dado que los símbolos tienen 4 caracteres de alto, se supone que el centro vertical es la segunda línea desde la parte superior.

Se supone que el espaciado horizontal es correcto en la entrada dada, es decir, los espacios en la entrada deben mostrarse en la salida.

Casos de prueba

• Entrada abc = 2

  Salida abc = 2

• Entrada e = \sum_{n=0}^{+inf} \frac{1}{n!}

  Salida

      +inf
      ___  1
  e = \  ` --
      /__, n!
      n=0
  

• Entrada e^x = 1 + \frac{x}{1 - \frac{x}{2 + x - ...}}

  Salida

                   x
  e^x = 1 + ---------------
                     x
            1 - -----------
                2 + x - ...
  

• Entrada \prod_{i=1}^{n} \frac{\sum_{j=0}^{m} 2j}{i + 1}

  Salida

         m
        ___
        \  ` 2j
   n    /__,
  ____  j=0
  |  |  -------
  |  |   i + 1
  i=1
  

• Entrada \frac{sum}{prod} = \sum_{frac}^{prod} sum

  Salida

         prod
  sum    ___
  ---- = \  ` sum
  prod   /__,
         frac
  

Tanteo

Este es el código de golf , por lo que gana el código más corto.

Python 2, 656 627 618 bytes

M=max
O=lambda l,o=2:[(p+o,c)for p,c in l]
def C(s,m=0):
 if''<s<'}'[m:]:f,w,h,d,s=C(s,1);F,W,H,D,s=C(s);e=M(d,D);return[O(f,e-d)+O(F,w*1j+e-D),w+W,M(h-d,H-D)+e,e,s]
 if'\\'!=s[:1]:return[[(0,s[:1])]*m,m,m,0,s[1:]]
 t=s[1]<'s';e=s[1]>'f';f,w,h,d,s=C(s[5+t+e:]);F,W,H,D,s=C(s[1+e:]);g=M(w,W);G=C('-'*g)[0]
 if e:f,w,h,F,W,H=F,W,H,f,w,h;g=4;p=C('|  |')[0];G=C('_'*(3+t))[0]+[O(C('/__,')[0])+[(1,'\\'),(1+3j,'`')],O(p,1)+O(p)][t]
 x=M(w,W,g);return[O(f,(x-w)/2*1j)+O(F,(x-W)/2*1j+h+3**e)+O(G,(x-g)/2*1j+h),x,h+3**e+H,h+e,s]
f,w,h,d,s=C(raw_input())
for y in range(h):print"".join(dict(f).get(y+x*1j,' ')for x in range(w))

Toma entrada en STDIN y escribe la salida en STDOUT.

El programa asume que no hay otra secuencia de control que \frac, \sumo \prodaparece en la entrada (es decir, no se mostrará como texto normal) y eso ~tampoco aparece ( tiene un significado especial en modo matemático de todos modos). por otra parte, el programa hace apoyar fórmulas arbitrarias como límites para \sumy \prod.

Explicación

¡Funciona igual que TeX! (bueno, más o menos ...) Cada subformula (comenzando desde caracteres individuales y construyendo hasta fórmulas más complejas) se convierte en un cuadro, con un ancho, alto y profundidad asociados (línea de base). Las cajas de fórmulas más simples se combinan en cajas más grandes para formar fórmulas complejas, y así sucesivamente. El contenido de cada cuadro se representa como una lista de pares de posición / carácter, en relación con la esquina superior izquierda del cuadro; cuando las cajas se combinan en una caja más grande, las posiciones se compensan de acuerdo con las posiciones relativas de las cajas más pequeñas dentro de la más grande, y las listas se concatenan.

Finalmente, terminamos con un cuadro de nivel superior, que se convierte en una forma imprimible.

Para darle un poco de sabor, la siguiente versión también admite raíces cuadradas:

M=max;R=range
O=lambda l,o=2:[(p+o,c)for p,c in l]
def C(s,m=0):
 if''<s<'}'[m:]:f,w,h,d,s=C(s,1);F,W,H,D,s=C(s);e=M(d,D);return[O(f,e-d)+O(F,w*1j+e-D),w+W,M(h-d,H-D)+e,e,s]
 if'\\'!=s[:1]:return[[(0,s[:1])]*m,m,m,0,s[1:]]
 t=s[1]<'s';e=s[1]>'f';f,w,h,d,z=C(s[5+t+e:])
 if'r'>s[2]:return[O(f,1j+h*1j+1)+O(C('_'*w)[0],1j+h*1j)+[(h,'\\')]+[(h-y+y*1j+1j,'/')for y in R(h)],w+1+h,h+1,d+1,z]
 F,W,H,D,s=C(z[1+e:]);g=M(w,W);G=C('-'*g)[0]
 if e:f,w,h,F,W,H=F,W,H,f,w,h;g=4;p=C('|  |')[0];G=C('_'*(3+t))[0]+[O(C('/__,')[0])+[(1,'\\'),(1+3j,'`')],O(p,1)+O(p)][t]
 x=M(w,W,g);return[O(f,(x-w)/2*1j)+O(F,(x-W)/2*1j+h+3**e)+O(G,(x-g)/2*1j+h),x,h+3**e+H,h+e,s]
f,w,h,d,s=C(raw_input())
for y in R(h):print"".join(dict(f).get(y+x*1j,' ')for x in R(w))

Ejemplos:

• \frac{-b +- \sqrt{b^2 - 4ac}}{2a}

          _________
  -b +- \/b^2 - 4ac
  -----------------
         2a
  

• |v| = \sqrt{ \sum_{i}^{} v[i]^2 }

             _____________
            / ___
  |v| =    /  \  ` v[i]^2
          /   /__,
        \/     i
  

LaTeX, 540 532 caracteres

Descargo de responsabilidad: esto no es perfecto y podría decirse que no cuenta como una respuesta válida.

\ usepackage [LGRgreek] {mathastext}
\newcommand {\ sum} {\ kern-1ex \ displaystyle \ mathop {\ vphantom {\ int} \ begin {array} {l} \ mbox {\ underline {\ hspace {12pt}}} \\ \ mbox {\ textbackslash } \ hspace {8pt} `\\\ mbox {/ \ underline {\ hspace {8pt}},} \ end {array}} \ displaylimits}
\newcommand {\ prod} {\ kern-1ex \ displaystyle \ mathop {\ vphantom {\ int} \ begin {array} {c} \ mbox {\ underline {\ hspace {16pt}}} \\ | \ \ \ \ El | \\ | \ \ \ \ | \ end {array}} \ displaylimits}
\newcommand {\ frac} [2] {\ mathop {\ xleaders \ hbox {-} \ hfill \ kern0pt} \ limits ^ {# 1} _ {# 2}}
\ DeclareMathSizes {10} {10} {10} {10}

Algo de ayuda de @Fatalize, vea los comentarios para más detalles.

Prueba:

Entrada: \prod_{i=1}^{n} \frac{\sum_{j=0}^{m} 2j}{i + 1}

Salida:

Como puede ver, la salida no sigue exactamente las especificaciones. Esto puede descalificar mi respuesta, pero sigo pensando que vale la pena publicarlo.

Escribí esto en sharelatex.com. Puedes jugar con eso aquí .