Data una stringa di lettere ASCII (maiuscole e / o minuscole), genera il MathJax grezzo richiesto per visualizzare quella stringa biforcante su ciascun carattere, in apice e pedice. Ad esempio, gli input cate horseporterebbero a output che MathJax rende rispettivamente come segue:

Si noti che è necessario prendere solo un input: questi due sono elencati uno accanto all'altro semplicemente per risparmiare spazio verticale.

Significato del markup

• _ indica un pedice.
• ^ indica un apice.
• Sono necessarie parentesi graffe attorno a sottostringhe con iscrizione in maiuscolo o in abbonamento che contengono ulteriori abbreviazioni o abbonamenti per evitare che siano tutte allo stesso livello.

Casi test

I casi di test sono nel formato input : output. Il primo caso di test mostra la stringa vuota come input dovrebbe risultare nella stringa vuota come 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}}}}}}}"

Puoi vedere come vengono visualizzati incollando l'output in mathurl.com .

Nessun apparecchio ridondante

MathJax renderà felicemente il markup con parentesi ridondanti. Ad esempio, il seguente saranno tutti guardare identico se fusi: a, {a}, {}{a}, {{{{a}}}}.

Tuttavia, un output valido per questa sfida non ha parentesi ridondanti. Si noti in particolare che i singoli caratteri nell'output non sono racchiusi tra parentesi graffe.

Ordine

L'ordine di pedice e apice non è importante. Di seguito sono equivalenti e saranno indistinguibili quando resi (e sono tutti ugualmente validi output):

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}

punteggio

Per ogni lingua, il vincitore è il codice più breve in byte.

_{Troppe notifiche? Digitare}su unsubscript</sub>

Python, 95 90 86 92 82 byte

10 byte salvati grazie a @ConnerJohnston

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

Provalo online!

Mathematica, 72 84 77 76 byte

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

Utilizza la codifica CP-1252 (Windows). Accetta un elenco di caratteri come input.

Spiegazione

a_±b__:=

Definire la funzione ±, con 2 o più argomenti. Etichetta il primo argomento a, il secondo e il successivo b.

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

Crea un Listequivalente a "{a_±b^±b}"( ±bviene valutato di nuovo, ricorsivamente).

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

Definire la funzione ±, con 1 o 0 argomenti. Etichettare il primo argomento a, se esiste, e assegnare ""a aaltrimenti.

{"",a,""}

Crea un Listequivalente a "a", imbottito con Strings vuoti .

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

Una funzione pura che si applica ±all'input, rilascia il primo e l'ultimo elemento e li converte Listin String.

CJam (35 byte)

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

Questo è un programma completo. Demo online .

3 byte aggirano un bug nell'interprete (vedi sotto).

Dissezione

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

Si noti che min(n+1, 3)è necessario aggirare un bug nell'interprete: nei poteri di 10 deve esserci un modello '}più piccolo di, ma non è ovvio .

JavaScript (ES6), 57 55 byte

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

Complexity (len (s)) complessità! Secondo @PeterTaylor, questo è in realtà Θ (2 ^ len (s)), che è ancora il migliore possibile ...

Haskell , 71 byte

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

Provalo online!

Se dovessimo solo generare un codice valido, il seguente funzionerebbe per 44 byte:

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

Provalo online!

SOGL V0.12 , 21 byte

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

Provalo qui!

Spiegazione:

±                      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

Provalo online!

Come?

La sostituzione nella condizione while interrompe le occorrenze di più lettere nella prima lettera, seguite dal resto tra parentesi graffe come questa:

abc -> a_{bc}^{bc}

Il ciclo while esegue la sostituzione fino a quando non rimangono più sequenze di più lettere. La sostituzione all'interno del ciclo rimuove le parentesi graffe attorno alle singole lettere.

Rubino , 76 73 72 68 67 57 byte

Uso di lambda risparmiando 4 byte grazie a Tutleman

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

Provalo 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 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

Provalo online!

Pyth , 47 byte

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

Provalo online!

Questa è praticamente una porta diretta della risposta Python di @Uriel. Andare a golf un po '.

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

La stessa funzione è di 104 byte e mostra un avviso PHP.

Retina , 43 byte

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

Provalo online! Il link include casi di test. Spiegazione:

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

Fai rotolare la palla tagliando l'ultimo personaggio. (Ma se è l'unico personaggio, lo lasciano in pace.)

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

Sposta il carattere back indietro di un passo alla volta, ogni volta prendendo il risultato precedente e rendendolo un pedice e un apice del personaggio successivo.

¶{|}$

Rimuovi la ridondante ¶ e la {} s esterna.

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

Provalo online!

Javascript, 73 byte

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

Spiegazione

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

Poiché non esiste un valore iniziale specificato di m, reduceRightaccetta l'ultimo elemento scome valore iniziale e inizia a scorrere nell'indice 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>