Étant donné une chaîne de lettres ASCII (majuscules et / ou minuscules), affichez le MathJax brut requis pour afficher cette chaîne bifurquant à chaque caractère, en exposants et indices. Par exemple, les entrées catet horseentraîneraient des sorties que MathJax rend respectivement comme suit:

Notez qu'une seule entrée est nécessaire pour être prise - ces deux sont listées côte à côte simplement pour économiser de l'espace vertical.

Signification du balisage

• _ indique un indice.
• ^ indique un exposant.
• Des accolades sont requises autour des sous-chaînes en exposant ou en indice qui contiennent d'autres exposants ou indices afin d'éviter qu'ils ne soient tous au même niveau.

Cas de test

Les cas de test sont au format input : output. Le premier cas de test montre la chaîne vide en entrée devrait entraîner la chaîne vide en sortie.

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

Vous pouvez voir comment ils sont rendus en collant la sortie dans mathurl.com .

Aucun appareil dentaire redondant

MathJax rendra avec plaisir le balisage qui a des accolades redondantes. Par exemple, ce qui suit tous semblent identiques lorsqu'ils sont rendus: a, {a}, {}{a}, {{{{a}}}}.

Cependant, une sortie valide pour ce défi n'a pas d'accolades redondantes. Notez en particulier que les caractères uniques dans la sortie ne sont pas entourés d'accolades.

Ordre

L'ordre des indices et des exposants est sans importance. Les éléments suivants sont équivalents et ne peuvent être distingués lors du rendu (et sont tous des résultats également valides):

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}

Notation

Pour chaque langue, le gagnant est le code le plus court en octets.

_{Trop de notifications? Tapez}pour vous désinscrire</sub>

Python, 95 90 86 92 82 octets

10 octets économisés grâce à @ConnerJohnston

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

Essayez-le en ligne!

Mathematica, 72 84 77 76 octets

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

Utilise le codage CP-1252 (Windows). Prend une liste de caractères en entrée.

Explication

a_±b__:=

Définissez la fonction ±, avec 2 arguments ou plus. Étiquetez le premier argument a, le deuxième et le suivant b.

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

Créez un Listéquivalent à "{a_±b^±b}"( ±best évalué à nouveau, récursivement).

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

Définissez la fonction ±, avec 1 ou 0 arguments. Étiquetez le premier argument a, s'il existe, et affectez- ""le aautrement.

{"",a,""}

Créez un Listéquivalent à "a", rempli de Strings vides .

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

Une fonction pure qui s'applique ±à l'entrée, supprime le premier et le dernier élément et se convertit Listen String.

CJam (35 octets)

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

Ceci est un programme complet. Démo en ligne .

3 octets contournent un bug dans l'interpréteur (voir ci-dessous).

Dissection

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

Notez que min(n+1, 3)c'est pour contourner un bug dans l'interpréteur: il doit y avoir un modèle dans les puissances de 10 qui '}soit plus petit que, mais ce n'est pas évident .

JavaScript (ES6), 57 55 octets

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

Complexity (len (s)) complexité! Selon @PeterTaylor, il s'agit en fait de Θ (2 ^ len (s)), ce qui est toujours le meilleur possible ...

Haskell , 71 octets

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

Essayez-le en ligne!

Si nous devions simplement sortir du code valide, ce qui suit fonctionnerait pour 44 octets:

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

Essayez-le en ligne!

SOGL V0.12 , 21 octets

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

Essayez-le ici!

Explication:

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

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

Essayez-le en ligne!

Comment?

La substitution dans la condition while rompt les occurrences de plusieurs lettres dans la première lettre, suivies du reste entre accolades comme ceci:

abc -> a_{bc}^{bc}

La boucle while exécute la substitution jusqu'à ce qu'il ne reste plus de séquences de plusieurs lettres. La substitution à l'intérieur de la boucle supprime les accolades autour des lettres simples.

Rubis , 76 73 72 68 67 57 octets

Utilisation de lambda économisant 4 octets grâce à Tutleman

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

Essayez-le en ligne!

Non golfé:

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 octets

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

Essayez-le en ligne!

Pyth , 47 octets

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

Essayez-le en ligne!

C'est à peu près un port direct de la réponse Python de @ Uriel. Aller jouer au golf un peu plus tard.

PHP, 121 octets

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

La fonction elle-même fait 104 octets et affiche un avis PHP.

Rétine , 43 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

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

Faites rouler la balle en coupant le dernier personnage. (Mais si c'est le seul personnage, laissez-le tranquille.)

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

Reculez le caractère ¶ d'une étape à la fois, en prenant à chaque fois le résultat précédent et en faisant un indice et un exposant du caractère suivant.

¶{|}$

Supprimez le ¶ désormais redondant et les {} s externes.

Java (OpenJDK 8) , 121 octets

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

Essayez-le en ligne!

Javascript, 73 octets

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

Explication

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

Parce qu'il n'y a pas de valeur initiale spécifiée de m, reduceRightprend le dernier élément de scomme valeur initiale et commence l'itération à l'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>