Đưa ra một chuỗi các chữ cái ASCII (chữ hoa và / hoặc chữ thường), xuất MathJax thô cần thiết để hiển thị chuỗi đó chia đôi cho mỗi ký tự, thành các siêu ký tự và các chỉ mục. Ví dụ: các đầu vào catvà horsesẽ dẫn đến kết quả đầu ra mà MathJax biểu hiện như sau:

Lưu ý rằng chỉ có một đầu vào được yêu cầu - hai cái này được liệt kê cạnh nhau đơn giản để tiết kiệm không gian dọc.

Ý nghĩa đánh dấu

• _ chỉ ra một chỉ mục.
• ^ chỉ ra một siêu ký tự.
• Niềng răng được yêu cầu xung quanh các chuỗi con siêu ký tự hoặc ký hiệu có chứa siêu ký tự hoặc ký hiệu phụ để ngăn chặn tất cả chúng ở cùng một cấp độ.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm có định dạng input : output. Trường hợp thử nghiệm đầu tiên cho thấy chuỗi trống là đầu vào sẽ dẫn đến chuỗi trống là đầu ra.

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

Bạn có thể thấy cách chúng được hiển thị bằng cách dán đầu ra vào mathurl.com .

Không có niềng răng dự phòng

MathJax sẽ vui vẻ kết xuất đánh dấu có dấu ngoặc nhọn. Ví dụ, sau đây tất cả sẽ trông giống hệt nhau khi hiển thị: a, {a}, {}{a}, {{{{a}}}}.

Tuy nhiên, đầu ra hợp lệ cho thử thách này không có dấu ngoặc nhọn. Đặc biệt lưu ý rằng các ký tự đơn trong đầu ra không được bao quanh bởi dấu ngoặc nhọn.

Gọi món

Thứ tự của đăng ký và siêu ký tự là không quan trọng. Các mục sau là tương đương và sẽ không thể phân biệt được khi được hiển thị (và đều là các đầu ra hợp lệ như nhau):

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}

Chấm điểm

Đối với mỗi ngôn ngữ, người chiến thắng là mã ngắn nhất tính bằng byte.

_{Quá nhiều thông báo? Nhập}vào bản thảo</sub>

Python, 95 90 86 92 82 byte

10 byte được lưu nhờ @ConnerJohnston

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

Hãy thử trực tuyến!

Toán học, 72 84 77 76 byte

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

Sử dụng mã hóa CP-1252 (Windows). Đưa ra một danh sách các ký tự làm đầu vào.

Giải trình

a_±b__:=

Xác định hàm ±, với 2 hoặc nhiều đối số. Dán nhãn cho đối số đầu tiên a, và thứ hai và trên b.

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

Tạo một Listtương đương với "{a_±b^±b}"( ±bđược đánh giá lại, đệ quy).

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

Xác định hàm ±, với 1 hoặc 0 đối số. Dán nhãn cho đối số đầu tiên a, nếu nó tồn tại và gán ""cho akhác.

{"",a,""}

Tạo một Listtương đương "a", đệm với Strings trống .

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

Một hàm thuần áp dụng ±cho đầu vào, bỏ phần tử đầu tiên và cuối cùng và chuyển đổi Listthành String.

CJam (35 byte)

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

Đây là một chương trình đầy đủ. Bản demo trực tuyến .

3 byte hoạt động xung quanh một lỗi trong trình thông dịch (xem bên dưới).

Mổ xẻ

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

Lưu ý rằng đó min(n+1, 3)là cách khắc phục lỗi trong trình thông dịch: phải có một số mẫu trong các quyền hạn 10 '}nhỏ hơn, nhưng không rõ ràng .

JavaScript (ES6), 57 55 byte

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

(Len (s)) phức tạp! Theo @PeterTaylor, đây thực sự là Θ (2 ^ len (s)), vẫn là tốt nhất có thể ...

Haskell , 71 byte

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

Hãy thử trực tuyến!

Nếu chúng ta chỉ cần xuất mã hợp lệ, phần sau sẽ hoạt động với 44 byte:

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

Hãy thử trực tuyến!

SOGL V0.12 , 21 byte

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

Hãy thử nó ở đây!

Giải trình:

±                      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

Hãy thử trực tuyến!

Làm sao?

Sự thay thế trong điều kiện while phá vỡ sự xuất hiện của nhiều chữ cái trong chữ cái đầu tiên, tiếp theo là phần còn lại trong dấu ngoặc nhọn như sau:

abc -> a_{bc}^{bc}

Vòng lặp while thực hiện thay thế cho đến khi không còn chuỗi nhiều chữ cái nữa. Sự thay thế bên trong vòng lặp loại bỏ dấu ngoặc từ xung quanh các chữ cái đơn.

Ruby , 76 73 72 68 67 57 byte

Sử dụng lambda tiết kiệm 4 byte nhờ Tutman

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

Hãy thử trực tuyến!

Ung dung:

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

Hãy thử trực tuyến!

Bình thường , 47 byte

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

Hãy thử trực tuyến!

Đây gần như là một cổng thẳng của câu trả lời Python của @ Uriel. Đi chơi golf xuống một chút.

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

Hàm này là 104 byte và hiển thị Thông báo PHP.

Võng mạc , 43 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

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

Nhận bóng lăn bằng cách cắt bỏ nhân vật cuối cùng. (Nhưng nếu đó là nhân vật duy nhất, họ để nó một mình.)

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

Di chuyển ký tự back trở lại một bước một lần, mỗi lần lấy kết quả trước đó và biến nó thành một chỉ mục và siêu ký tự của ký tự tiếp theo.

¶{|}$

Xóa phần thừa bây giờ và {} s bên ngoài.

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("^\\{|\\}$","");}

Hãy thử trực tuyến!

Javascript, 73 byte

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

Giải trình

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

Bởi vì không có giá trị ban đầu được chỉ định là m, reduceRightlấy phần tử cuối cùng slàm giá trị ban đầu và bắt đầu lặp lại tại chỉ mục 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>