รับสตริงตัวอักษร ASCII (ตัวพิมพ์ใหญ่และ / หรือตัวพิมพ์เล็ก), ส่งออก MathJax ดิบที่จำเป็นในการแสดงสตริงนั้นแยกไปสองทางที่อักขระแต่ละตัวลงในตัวยกและตัวห้อย ตัวอย่างเช่นอินพุตcatและhorseจะส่งผลให้ผลลัพธ์ที่ MathJax แสดงผลดังต่อไปนี้ตามลำดับ:

โปรดทราบว่าจำเป็นต้องใช้อินพุตหนึ่งเท่านั้น - ทั้งสองรายการจะแสดงแบบเคียงข้างกันเพื่อประหยัดพื้นที่แนวตั้ง

ความหมายมาร์กอัป

• _ ระบุตัวห้อย
• ^ หมายถึงตัวยก
• การจัดฟันจำเป็นต้องมีรอบ substrings ที่มีการยกหรือห้อยที่มีการยกหรือการห้อยต่อเพื่อป้องกันไม่ให้พวกมันทั้งหมดอยู่ในระดับเดียวกัน

กรณีทดสอบ

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

คุณสามารถดูวิธีเหล่านี้มีการแสดงผลโดยการวางออกเป็นmathurl.com

ไม่มีวงเล็บปีกกาซ้ำซ้อน

MathJax จะแสดงมาร์กอัปอย่างมีความสุขที่มีเครื่องหมายวงเล็บซ้ำซ้อน aตัวอย่างต่อไปนี้ทุกคนจะมีลักษณะเหมือนกันเมื่อแสดงผล: {a}, {}{a}, {{{{a}}}},

อย่างไรก็ตามผลลัพธ์ที่ถูกต้องสำหรับความท้าทายนี้ไม่มีการจัดฟันซ้ำซ้อน โปรดสังเกตว่าอักขระเดี่ยวในเอาต์พุตไม่ถูกล้อมรอบด้วยเครื่องหมายปีกกา

ใบสั่ง

คำสั่งของตัวห้อยและตัวยกนั้นไม่สำคัญ ต่อไปนี้เทียบเท่าและจะแยกไม่ออกเมื่อเรนเดอร์ (และเป็นเอาต์พุตที่ถูกต้องเท่ากัน)

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}

เกณฑ์การให้คะแนน

สำหรับแต่ละภาษาผู้ชนะคือรหัสที่สั้นที่สุดในหน่วยไบต์

_{มีการแจ้งเตือนมากเกินไป? พิมพ์}เป็น unsubscript</sub>

Python, 95 90 86 92 82 ไบต์

บันทึก 10 ไบต์ด้วย @ConnerJohnston

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

ลองออนไลน์!

Mathematica, 72 84 77 76 ไบต์

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

ใช้การเข้ารหัส CP-1252 (Windows) ใช้รายการอักขระเป็นอินพุต

คำอธิบาย

a_±b__:=

กำหนดฟังก์ชั่นที่±มี 2 ​​หรือมากกว่าข้อโต้แย้ง ป้ายอาร์กิวเมนต์แรกและครั้งที่สองและab

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

สร้างListเทียบเท่ากับ"{a_±b^±b}"( ±bถูกประเมินอีกครั้งซ้ำ)

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

กำหนดฟังก์ชั่น±ด้วย 1 หรือ 0 ข้อโต้แย้ง เลเบลอาร์กิวเมนต์แรกaถ้ามีอยู่และกำหนดให้""เป็นaอย่างอื่น

{"",a,""}

สร้างListเทียบเท่า"a", เบาะมีที่ว่างเปล่าStrings

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

ฟังก์ชั่นบริสุทธิ์ที่ใช้±ในการป้อนข้อมูลลดลงเป็นครั้งแรกและองค์ประกอบสุดท้ายและแปลงไปListString

CJam (35 ไบต์)

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

นี่เป็นโปรแกรมเต็ม สาธิตออนไลน์

3 ไบต์แก้ไขข้อผิดพลาดในล่าม (ดูด้านล่าง)

การผ่า

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

โปรดทราบว่าmin(n+1, 3)คือการทำงานรอบข้อผิดพลาดในล่าม: จะต้องมีรูปแบบบางอย่างในอำนาจของ 10 ที่'}มีขนาดเล็กกว่า แต่ก็ไม่ชัดเจน

JavaScript (ES6), 57 55 ไบต์

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

complexity (len) ความซับซ้อน! ตามที่ @PeterTaylor สิ่งนี้เป็นจริงΘ (2 ^ len) ซึ่งยังคงดีที่สุด ...

Haskell , 71 ไบต์

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

ลองออนไลน์!

หากเราเพิ่งจะส่งออกรหัสที่ถูกต้องต่อไปนี้จะทำงานได้ 44 ไบต์

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

ลองออนไลน์!

SOGL V0.12 , 21 ไบต์

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

ลองที่นี่!

คำอธิบาย:

±                      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 ไบต์

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

ลองออนไลน์!

อย่างไร?

การทดแทนในขณะที่เงื่อนไขแบ่งตัวอักษรหลายตัวในตัวอักษรแรกตามด้วยส่วนที่เหลือในวงเล็บเช่นนี้:

abc -> a_{bc}^{bc}

ห่วงในขณะที่ดำเนินการทดแทนจนกว่าจะไม่มีลำดับหลายตัวอักษรยังคงอยู่ การแทนที่ภายในลูปจะลบเครื่องหมายปีกกาออกจากตัวอักษรเดี่ยว

Ruby , 76 73 72 68 67 57 ไบต์

การใช้แลมบ์ดาช่วยประหยัด 4 ไบต์ด้วยTutleman

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

ลองออนไลน์!

Ungolfed:

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 ไบต์

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

ลองออนไลน์!

Pyth , 47 ไบต์

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

ลองออนไลน์!

นี่เป็นพอร์ทตรงของคำตอบ Python ของ @ Uriel จะตีกอล์ฟมันลงเล็กน้อย

PHP, 121 ไบต์

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

ฟังก์ชั่นของมันคือ 104 ไบต์และแสดงให้เห็นถึงประกาศ PHP

เรติน่า 43 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

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

รับลูกบอลกลิ้งโดยการตัดอักขระตัวสุดท้ายออก (แต่ถ้ามันเป็นตัวละครตัวเดียวพวกเขาก็ทิ้งมันไว้คนเดียว)

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

ย้ายอักขระ¶กลับหนึ่งขั้นในแต่ละครั้งที่รับผลลัพธ์ก่อนหน้าและทำให้เป็นตัวห้อยและตัวยกของอักขระถัดไป

¶{|}$

ลบ now ซ้ำซ้อนในขณะนี้และส่วนนอก {} s

Java (OpenJDK 8) , 121 ไบต์

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

ลองออนไลน์!

Javascript, 73 ไบต์

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

คำอธิบาย

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

เนื่องจากมีการระบุไม่มีค่าเริ่มต้นของm, reduceRightเตะองค์ประกอบสุดท้ายของการsเป็นค่าเริ่มต้นและเริ่ม iterating 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>