Wenn Sie eine Zeichenfolge aus ASCII-Buchstaben (Groß- und / oder Kleinbuchstaben) angeben, geben Sie das unformatierte MathJax aus, das erforderlich ist, um diese Zeichenfolge bei jedem Zeichen in hochgestellte und tiefgestellte Zeichen aufzuteilen. Beispielsweise führen die Eingaben catund horsezu Ausgaben, die von MathJax wie folgt dargestellt werden:

Beachten Sie, dass nur eine Eingabe erforderlich ist - diese beiden werden nebeneinander aufgelistet, um vertikalen Platz zu sparen.

Markup bedeutet

• _ kennzeichnet einen Index.
• ^ kennzeichnet einen hochgestellten Text.
• Um hochgestellte oder tiefgestellte Teilzeichenfolgen, die weitere hochgestellte oder tiefgestellte Zeichenfolgen enthalten, sind geschweifte Klammern erforderlich, um zu verhindern, dass sich alle auf derselben Ebene befinden.

Testfälle

Testfälle liegen im Format vor input : output. Der erste Testfall zeigt, dass die leere Zeichenfolge als Eingabe zu der leeren Zeichenfolge als Ausgabe führen soll.

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

Sie können sehen, wie diese gerendert werden, indem Sie die Ausgabe in mathurl.com einfügen .

Keine überflüssigen Klammern

MathJax rendert gerne Markups mit überflüssigen Klammern. Zum Beispiel wird im Folgenden alle identisch aussehen , wenn wiedergegeben: a, {a}, {}{a}, {{{{a}}}}.

Eine gültige Ausgabe für diese Abfrage enthält jedoch keine redundanten Klammern. Beachten Sie insbesondere, dass einzelne Zeichen in der Ausgabe nicht von geschweiften Klammern umgeben sind.

Bestellung

Die Reihenfolge von tiefgestellt und hochgestellt ist unwichtig. Die folgenden Angaben sind äquivalent und können beim Rendern nicht unterschieden werden (und sind alle gleichermaßen gültige Ausgaben):

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}

Wertung

Für jede Sprache ist der Gewinner der kürzeste Code in Bytes.

_{Zu viele Benachrichtigungen? Geben Sie}auf unsubscript</sub>

Python, 95 90 86 92 82 Bytes

10 Bytes gespart dank @ConnerJohnston

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

Probieren Sie es online!

Mathematica, 72 84 77 76 Bytes

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

Verwendet die CP-1252-Codierung (Windows). Nimmt eine Liste von Zeichen als Eingabe.

Erläuterung

a_±b__:=

Definieren Sie die Funktion ±mit 2 oder mehr Argumenten. Beschriften Sie das erste Argument aund das zweite und weitere b.

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

Erstellen Sie ein ListÄquivalent zu "{a_±b^±b}"( ±bwird erneut rekursiv ausgewertet).

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

Definieren Sie die Funktion ±mit 1 oder 0 Argumenten. Beschriften Sie das erste Argument a, falls vorhanden, und weisen Sie es ""dem aanderen zu.

{"",a,""}

Erstellen Sie ein ListÄquivalent zu "a", aufgefüllt mit leeren Strings.

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

Eine reine Funktion, trifft ±auf den Eingang fällt erstes und letztes Element, und wandelt Listauf String.

CJam (35 Bytes)

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

Dies ist ein volles Programm. Online-Demo .

3 Bytes umgehen einen Fehler im Interpreter (siehe unten).

Präparation

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

Beachten Sie, dass dies dazu min(n+1, 3)dient, einen Fehler im Interpreter zu umgehen: Es muss ein Muster in Potenzen von 10 geben, '}das kleiner ist als, aber es ist nicht offensichtlich .

JavaScript (ES6), 57-55 Byte

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

Θ (len (s)) Komplexität! Laut @PeterTaylor ist dies tatsächlich Θ (2 ^ len (s)), was immer noch das bestmögliche ist ...

Haskell , 71 Bytes

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

Probieren Sie es online!

Wenn wir nur gültigen Code ausgeben müssten, würde das folgende für 44 Bytes funktionieren:

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

Probieren Sie es online!

SOGL V0.12 , 21 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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

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

Probieren Sie es online!

Wie?

Die Ersetzung in der while-Bedingung unterbricht das Auftreten mehrerer Buchstaben im ersten Buchstaben, gefolgt vom Rest in geschweiften Klammern wie folgt:

abc -> a_{bc}^{bc}

Die while-Schleife führt die Ersetzung durch, bis keine Mehrbuchstabenfolgen mehr übrig sind. Durch die Ersetzung innerhalb der Schleife werden Klammern um einzelne Buchstaben entfernt.

Ruby , 76 73 72 68 67 57 Bytes

Die Verwendung von Lambda spart dank Tutleman 4 Byte

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

Probieren Sie es online!

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 Bytes

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

Probieren Sie es online!

Pyth , 47 Bytes

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

Probieren Sie es online!

Dies ist so ziemlich ein direkter Port von @ Uriels Python-Antwort. Ich gehe gleich Golf spielen.

PHP, 121 Bytes

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

Die Funktion selbst hat 104 Bytes und zeigt einen PHP-Hinweis.

Retina , 43 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

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

Bringe den Ball ins Rollen, indem du den letzten Charakter abschneidest. (Aber wenn es der einzige Charakter ist, lassen sie es in Ruhe.)

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

Bewegen Sie das Zeichen ¶ schrittweise zurück, wobei Sie jeweils das vorherige Ergebnis als tiefgestellten und hochgestellten Wert des nächsten Zeichens verwenden.

¶{|}$

Entfernen Sie die jetzt redundanten ¶ und die äußeren {} 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("^\\{|\\}$","");}

Probieren Sie es online!

Javascript, 73 Bytes

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

Erläuterung

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

Da es keinen angegebenen Anfangswert von gibt m, reduceRightwird das letzte Element von sals Anfangswert verwendet und die Iteration beginnt bei Index 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>