Anda diangkut dalam alam semesta paralel di mana orang menulis persamaan matematika di komputer sebagai karya ASCII dengan tangan. Sebagai pecandu LaTeX, ini sama sekali tidak dapat diterima, dan Anda harus mengotomatiskan proses ini.

Tujuan Anda adalah untuk menulis sebuah program yang mengeluarkan versi ASCII dari persamaan yang dimasukkan sebagai perintah matematika LaTeX.

Perintah LaTeX wajib untuk mendukung

• Sum: perintah LaTeX untuk penjumlahan adalah \sum_{lower bound}^{upper bound}

  Angka ASCII yang harus Anda gunakan untuk penjumlahan adalah:

  upper bound
      ___ 
      \  `
      /__,
  lower bound
  

• Produk: perintah LaTeX untuk suatu produk adalah \prod_{lower bound}^{upper bound}

  Sosok ASCII yang harus Anda gunakan untuk produk adalah:

  upper bound
      ____
      |  |
      |  |
  lower bound
  

• Fraksi: perintah LaTeX untuk fraksi adalah \frac{numerator}{denominator}

  Angka ASCII yang harus Anda gunakan untuk fraksi adalah:

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

Apa pun yang bukan salah satu dari tiga perintah itu ditampilkan apa adanya. Sebagai contoh, \sum{i=3}^{e^10}\frac{3x+5}{2}harus ditampilkan sebagai

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

Input

Inputnya adalah perintah LaTeX yang diteruskan sebagai string (atau bahasa Anda setara dengan string). Perintah LaTeX dapat disarangkan, misalnya \frac{\frac{1}{2}}{3}adalah input yang valid. Input seharusnya selalu benar (tidak perlu memeriksa sintaksis LaTeX dalam kode Anda). Input hanya akan terdiri dari tiga perintah LaTeX yang disajikan di atas dan 'teks' yang tidak perlu Anda format.

Perintah LaTeX akan selalu datang dengan sintaks yang disajikan di atas, yaitu jumlah dan produk akan selalu memiliki batas atas dan bawah (meskipun mereka dapat kosong) dan akan selalu ada pembilang dan penyebut untuk pecahan.

Kami berasumsi bahwa batas jumlah dan produk paling banyak 4 karakter (= lebar jumlah dan simbol produk), sehingga Anda tidak perlu khawatir tentang kemungkinan masalah yang tumpang tindih. Untuk alasan yang sama, kami mengasumsikan bahwa batas hanyalah 'teks' dan tidak akan pernah menjadi perintah LaTeX, misalnya \sum_{\sum_{1}^{2}}^{1}bukan input yang valid.

Keluaran

Output program Anda adalah representasi ASCII dari perintah LaTeX yang Anda berikan sebagai input.

Program Anda harus mempertimbangkan perataan horizontal: misalnya, batas-batas jumlah atau produk harus sejajar secara horizontal dengan jumlah atau simbol produk (yang keduanya lebar 4 karakter). Jika ikatan memiliki jumlah karakter ganjil, tidak masalah apakah itu satu karakter di sebelah kanan atau ke kiri dari tengah, yang mana yang baik-baik saja. Garis fraksi harus sepanjang pembilang atau penyebutnya, mana yang paling panjang.

Program Anda harus mempertimbangkan penyelarasan vertikal: misalnya, \frac{\frac{1}{2}}{3} = \frac{1}{6}harus ditampilkan sebagai

1
-
2   1
- = -
3   6

Untuk penjumlahan dan produk, karena simbol memiliki 4 karakter, pusat vertikal dianggap sebagai garis kedua dari atas.

Spasi horizontal diasumsikan benar dalam input yang diberikan, yaitu spasi di input harus ditampilkan dalam output.

Uji kasus

• Memasukkan abc = 2

  Keluaran abc = 2

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

  Keluaran

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

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

  Keluaran

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

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

  Keluaran

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

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

  Keluaran

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

Mencetak gol

Ini kode-golf , jadi kode terpendek menang.

Python 2, 656 627 618 byte

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

Mengambil input pada STDIN dan menulis output ke STDOUT.

Program ini mengasumsikan bahwa tidak ada urutan kontrol selain \frac, \sumatau \prodmuncul dalam input (yaitu, tidak akan ditampilkan sebagai teks normal), dan itu ~tidak muncul juga (ia memiliki makna khusus dalam mode matematika .) di sisi lain, program ini memang mendukung formula sewenang-wenang sebagai batasan untuk \sumdan \prod.

Penjelasan

Ini berfungsi seperti halnya TeX! (yah, semacam ...) Setiap subformula (mulai dari karakter tunggal dan membangun hingga formula yang lebih kompleks) diubah menjadi sebuah kotak, dengan lebar, tinggi, dan kedalaman yang terkait (garis dasar). Kotak-kotak formula sederhana digabungkan menjadi kotak-kotak besar untuk membentuk formula kompleks, dan sebagainya. Isi setiap kotak direpresentasikan sebagai daftar pasangan posisi / karakter, relatif terhadap sudut kiri atas kotak; ketika kotak digabungkan menjadi kotak yang lebih besar, posisi diimbangi sesuai dengan posisi relatif dari kotak yang lebih kecil di dalam yang lebih besar, dan daftar tersebut digabungkan.

Akhirnya, kita berakhir dengan kotak tingkat atas, yang dikonversi menjadi bentuk yang dapat dicetak.

Untuk sedikit meningkatkannya, versi berikut ini juga mendukung akar kuadrat:

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

Contoh:

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

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

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

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

Getah, 540 532 karakter

Penafian: Ini tidak sempurna dan bisa dibilang tidak dihitung sebagai jawaban yang valid.

\ usepackage [LGRgreek] {mathastext}
\ renewcommand {\ 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}
\ renewcommand {\ prod} {\ kern-1ex \ displaystyle \ mathop {\ vphantom {\ int} \ begin {array} {c} \ mbox {\ underline {\ hspace {16pt}}} \\ | \ \ \ \ \ | \\ | \ \ \ \ | \ end {array}} \ displaylimits}
\ renewcommand {\ frac} [2] {\ mathop {\ xleaders \ hbox {-} \ hfill \ kern0pt} \ limit ^ {# 1} _ {# 2}}
\ DeclareMathSizes {10} {10} {10} {10}

Beberapa bantuan dari @Fatalize, lihat komentar untuk detailnya.

Uji:

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

Keluaran:

Seperti yang Anda lihat, output tidak persis mengikuti spesifikasi. Ini mungkin mendiskualifikasi jawaban saya, tetapi saya masih berpikir itu layak untuk dikirim.

Saya menulis ini di sharelatex.com. Anda dapat bermain dengannya di sini .