Diberikan string huruf ASCII (huruf besar dan kecil), menghasilkan MathJax mentah yang diperlukan untuk menampilkan string yang bercabang dua pada setiap karakter, menjadi superskrip dan subskrip. Misalnya, input catdan horseakan menghasilkan output yang dirender MathJax sebagai berikut, masing-masing:

Perhatikan bahwa hanya satu input yang harus diambil - keduanya terdaftar berdampingan hanya untuk menghemat ruang vertikal.

Makna markup

• _ menunjukkan suatu subskrip.
• ^ menunjukkan superskrip.
• Kawat gigi diperlukan di sekitar substring superskrip atau subskrip yang berisi superskrip atau subskrip lebih lanjut untuk mencegah mereka semua berada di level yang sama.

Uji kasus

Kasing uji ada dalam format input : output. Kasing uji pertama menunjukkan string kosong sebagai input harus menghasilkan string kosong sebagai 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}}}}}}}"

Anda dapat melihat bagaimana ini dirender dengan menempelkan output ke mathurl.com .

Tidak ada kawat gigi yang berlebihan

MathJax dengan senang hati akan membuat markup yang memiliki kawat gigi yang berlebihan. Sebagai contoh, berikut ini semua akan terlihat sama ketika diberikan: a, {a}, {}{a}, {{{{a}}}}.

Namun, keluaran yang valid untuk tantangan ini tidak memiliki kawat gigi yang berlebihan. Perhatikan khususnya bahwa karakter tunggal dalam output tidak dikelilingi oleh kawat gigi.

Memesan

Urutan subskrip dan superskrip tidak penting. Berikut ini adalah setara dan akan tidak bisa dibedakan ketika diberikan (dan semuanya sama-sama keluaran yang valid):

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}

Mencetak gol

Untuk setiap bahasa, pemenangnya adalah kode terpendek dalam byte.

_{Terlalu banyak notifikasi? Ketik}untuk berhenti berlangganan</sub>

Python, 95 90 86 92 82 byte

10 byte disimpan berkat @ConnerJohnston

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

Cobalah online!

Mathematica, 72 84 77 76 byte

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

Menggunakan pengkodean CP-1252 (Windows). Mengambil daftar karakter sebagai input.

Penjelasan

a_±b__:=

Tentukan fungsi ±, dengan 2 atau lebih argumen. Beri label pada argumen pertama a, dan kedua dan seterusnya b.

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

Buat yang Listsetara dengan "{a_±b^±b}"( ±bdievaluasi lagi, secara rekursif).

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

Tentukan fungsi ±, dengan argumen 1 atau 0. Label argumen pertama a, jika ada, dan menetapkan ""untuk asebaliknya.

{"",a,""}

Buat yang Listsetara dengan "a", diisi dengan Strings kosong .

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

Fungsi murni yang berlaku ±untuk input, menjatuhkan elemen pertama dan terakhir, dan mengubahnya Listmenjadi String.

CJam (35 byte)

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

Ini adalah program lengkap. Demo online .

3 byte bekerja di sekitar bug di interpreter (lihat di bawah).

Pembedahan

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

Perhatikan bahwa min(n+1, 3)ini adalah untuk mengatasi bug dalam juru bahasa: harus ada beberapa pola dalam kekuatan 10 yang '}lebih kecil dari, tetapi tidak jelas .

JavaScript (ES6), 57 55 byte

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

Θ kompleksitas (len)! Menurut @PeterTaylor, ini sebenarnya Θ (2 ^ len (s)), yang masih merupakan yang terbaik ...

Haskell , 71 byte

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

Cobalah online!

Jika kita hanya harus mengeluarkan kode yang valid, berikut ini akan bekerja untuk 44 byte:

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

Cobalah online!

SOGL V0.12 , 21 byte

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

Coba Di Sini!

Penjelasan:

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

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

Cobalah online!

Bagaimana?

Substitusi dalam kondisi while memecah kemunculan beberapa huruf pada huruf pertama, diikuti oleh yang lainnya dalam kurung kurawal seperti ini:

abc -> a_{bc}^{bc}

Loop sementara menjalankan substitusi hingga tidak ada lagi urutan multi-huruf yang tersisa. Substitusi di dalam loop menghilangkan kawat gigi dari sekitar satu huruf.

Ruby , 76 73 72 68 67 57 byte

Penggunaan tabungan lambda 4 byte berkat Tutleman

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

Cobalah online!

Tidak Disatukan:

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 byte

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

Cobalah online!

Pyth , 47 byte

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

Cobalah online!

Ini adalah port langsung dari jawaban Python @ Uriel. Pergi ke golf turun sedikit.

PHP, 121 byte

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

Fungsi itu sendiri 104 byte dan menunjukkan Pemberitahuan PHP.

Retina , 43 byte

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

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

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

Dapatkan bola bergulir dengan memotong karakter terakhir. (Tapi jika itu satu-satunya karakter, mereka biarkan saja.)

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

Pindahkan karakter ¶ mundur satu langkah pada satu waktu, setiap kali mengambil hasil sebelumnya dan menjadikannya subskrip dan superskrip dari karakter berikutnya.

¶{|}$

Hapus ¶ yang sekarang berlebih dan bagian luar {} s.

Java (OpenJDK 8) , 121 byte

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

Cobalah online!

Javascript, 73 Bytes

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

Penjelasan

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

Karena tidak ada nilai awal yang ditentukan m, reduceRightambil elemen terakhir ssebagai nilai awal, dan mulai iterasi pada indeks 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>