Biorąc pod uwagę ciąg liter ASCII (wielkie i / lub małe litery), wyprowadzaj surowy MathJax wymagany do wyświetlenia tego łańcucha rozgałęziającego się przy każdym znaku, do indeksu górnego i dolnego. Na przykład dane wejściowe cati horsedają wyniki, które MathJax renderuje odpowiednio:

Należy pamiętać, że należy podjąć tylko jedno wejście - te dwa są wymienione obok siebie, aby zaoszczędzić miejsce w pionie.

Znaczenie znaczników

• _ wskazuje indeks dolny.
• ^ wskazuje indeks górny.
• Nawiasy klamrowe są wymagane wokół indeksów z indeksami górnymi lub dolnymi, które zawierają dalsze indeksy górne lub indeksy dolne, aby zapobiec ich wszystkiemu na tym samym poziomie.

Przypadki testowe

Przypadki testowe mają format input : output. Pierwszy przypadek testowy pokazuje pusty ciąg jako dane wejściowe, które powinny skutkować pustym ciągiem jako wyjściem.

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

Możesz zobaczyć, jak są one renderowane, wklejając dane wyjściowe do mathurl.com .

Brak zbędnych aparatów ortodontycznych

MathJax z przyjemnością wyświetli znaczniki, które mają nadmiarowe nawiasy klamrowe. Na przykład, następujące wszyscy wyglądają identycznie przy wytapianiu: a, {a}, {}{a}, {{{{a}}}}.

Jednak prawidłowe dane wyjściowe dla tego wyzwania nie mają nadmiarowych nawiasów klamrowych. Zwróć uwagę, że pojedyncze znaki na wyjściu nie są otoczone nawiasami klamrowymi.

Zamówienie

Kolejność indeksu dolnego i górnego jest nieistotna. Poniższe są równoważne i będą nierozróżnialne podczas renderowania (i wszystkie są jednakowo poprawnymi wynikami):

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}

Punktacja

Dla każdego języka zwycięzcą jest najkrótszy kod w bajtach.

_{Za dużo powiadomień? Wpisz}do wypisania</sub>

Python, 95 90 86 92 82 bajtów

10 bajtów zapisanych dzięki @ConnerJohnston

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

Wypróbuj online!

Mathematica, 72 84 77 76 bajtów

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

Wykorzystuje kodowanie CP-1252 (Windows). Pobiera na wejściu listę znaków.

Wyjaśnienie

a_±b__:=

Zdefiniuj funkcję za ±pomocą 2 lub więcej argumentów. Oznacz pierwszy argument a, drugi i dalej b.

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

Utwórz Listekwiwalent do "{a_±b^±b}"( ±bjest ponownie oceniany, rekurencyjnie).

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

Zdefiniuj funkcję za ±pomocą 1 lub 0 argumentów. Oznacz pierwszy argument a, jeśli istnieje, i przypisz ""do ainnego.

{"",a,""}

Utwórz Listodpowiednik "a"wypełniony pustymi literami Strings.

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

Czysta funkcja, która ma zastosowanie ±do danych wejściowych, upuszcza pierwszy i ostatni element i konwertuje Listna String.

CJam (35 bajtów)

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

To jest pełny program. Demo online .

3 bajty omijają błąd w tłumaczu (patrz poniżej).

Sekcja

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

Zauważ, że min(n+1, 3)chodzi o obejście błędu w tłumaczu: musi istnieć pewien wzór w potęgach 10, który '}jest mniejszy niż, ale nie jest to oczywiste .

JavaScript (ES6), 57 55 bajtów

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

Complex (len (s)) złożoność! Według @PeterTaylor jest to w rzeczywistości Θ (2 ^ len (s)), co wciąż jest najlepszym możliwym ...

Haskell , 71 bajtów

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

Wypróbuj online!

Gdybyśmy tylko musieli wyprowadzić prawidłowy kod, następujące działania działałyby dla 44 bajtów:

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

Wypróbuj online!

SOGL V0.12 , 21 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

±                      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 bajtów

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

Wypróbuj online!

W jaki sposób?

Podstawienie w warunku while powoduje przerwanie występowania wielu liter w pierwszej literze, a następnie pozostałych w nawiasach klamrowych:

abc -> a_{bc}^{bc}

Pętla while wykonuje podstawienie, dopóki nie pozostaną już sekwencje wieloliterowe. Podstawienie w pętli usuwa nawiasy klamrowe z około pojedynczych liter.

Ruby , 76 73 72 68 67 57 bajtów

Wykorzystanie lambda oszczędza 4 bajty dzięki Tutleman

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

Wypróbuj online!

Nie golfowany:

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 bajtów

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

Wypróbuj online!

Pyth , 47 bajtów

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

Wypróbuj online!

To właściwie prosty port odpowiedzi na Python @ Uriel. Gra w golfa za chwilę.

PHP, 121 bajtów

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

Sama funkcja ma 104 bajty i wyświetla komunikat PHP.

Siatkówka , 43 bajty

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

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

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

Spraw, by piłka toczyła się, odcinając ostatnią postać. (Ale jeśli to jedyna postać, zostaw ją w spokoju.)

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

Przesuwaj znak ¶ z powrotem o krok za każdym razem, za każdym razem biorąc poprzedni wynik i czyniąc go indeksem dolnym i górnym dla następnego znaku.

¶{|}$

Usuń teraz zbędne ¶ i zewnętrzne {} s.

Java (OpenJDK 8) , 121 bajtów

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

Wypróbuj online!

JavaScript, 73 bajtów

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

Wyjaśnienie

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

Ponieważ nie ma określonej wartości początkowej m, reduceRightbierze ostatni element sjako wartość początkową i rozpoczyna iterację od indeksu 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>