Einführung

Das LaTeX-Schriftsatzsystem verwendet Makros zum Definieren von Akzenten. Zum Beispiel wird der Buchstabe ê von erzeugt \hat{e}. Bei dieser Herausforderung besteht Ihre Aufgabe darin, eine ASCII-Version dieser Funktionalität zu implementieren.

Eingang

Ihre Eingabe ist eine nicht leere Zeichenfolge mit druckbaren ASCII-Zeichen. Es enthält keine Zeilenumbrüche.

Ausgabe

Ihre Ausgabe ist eine Zeichenfolge, die aus zwei Zeilen besteht. Die erste Zeile enthält Akzente und die zweite Zeile die Zeichen, zu denen sie gehören. Es wird aus der Eingabe wie folgt erhalten ( Abezeichnet ein beliebiges Zeichen):

• Jeder \bar{A}wird ersetzt durch Amit _oben drauf.
• Jeder \dot{A}wird ersetzt durch Amit .oben drauf.
• Jeder \hat{A}wird ersetzt durch Amit ^oben drauf.
• Für einen 10% Bonus: jeder \tilde{A}wird ersetzt durch die Amit ~oben drauf.
• Alle anderen Zeichen haben ein Leerzeichen darüber.

Zum Beispiel die Eingabe

Je suis pr\hat{e}t.

führt zur Ausgabe

          ^
Je suis pret.

Regeln und Wertung

Sie können davon ausgehen , dass die Zeichen \{}nur in dem Makros auftreten \bar{}, \dot{}und \hat{}(und \tilde{}wenn Sie sich für den Bonus zu gehen). Alle Makroargumente sind genau ein Zeichen lang \dot{foo}und \dot{}kommen daher in der Eingabe nicht vor. Die Ausgabe kann eine durch Zeilenumbrüche getrennte Zeichenfolge oder eine Liste / ein Paar von zwei Zeichenfolgen sein. Jede Anzahl von nachgestellten und vorangestellten Leerzeichen ist zulässig, solange sich die Akzente an den richtigen Stellen befinden. Insbesondere wenn keine Akzente vorhanden sind, kann die Ausgabe eine einzelne Zeichenfolge sein.

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl (nach Boni) gewinnt und Standardschlupflöcher sind nicht zulässig.

Testfälle

Ohne Bonus:

Input:
No accents.
Output:

No accents.
Input:
Ch\hat{a}teau
Output:
  ^
Chateau
Input:
Som\bar{e} \dot{a}cc\hat{e}nts.
Output:
   _ .  ^
Some accents.
Input:
dot hat\dot{h}a\hat{t}\hat{ }x\bar{x}dot
Output:
       . ^^ _
dot hathat xxdot
Input:
\hat{g}Hmi\hat{|}Su5Y(\dot{G}"\bar{$}id4\hat{j}gB\dot{n}#6AX'c\dot{[}\hat{)} 6\hat{[}T~_sR\hat{&}CEB
Output:
^   ^     . _   ^  .      .^  ^     ^
gHmi|Su5Y(G"$id4jgBn#6AX'c[) 6[T~_sR&CEB

Mit Bonus:

Input:
Ma\tilde{n}ana
Output:
  ~
Manana
Input:
\dot{L}Vz\dot{[}|M.\bar{#}0\hat{u}U^y!"\tilde{I} K.\bar{"}\hat{m}dT\tilde{$}F\bar{;}59$,/5\bar{'}K\tilde{v}R \tilde{E}X`
Output:
.  .   _ ^     ~   _^  ~ _      _ ~  ~
LVz[|M.#0uU^y!"I K."mdT$F;59$,/5'KvR EX`

Pyth, 51 46 45 43 41 40 Bytes

Ich entferne die geschweiften Klammern und spalte an \, genau wie es Reto Koradis CJam-Antwort tut. Die Codes und werden einfach an der letzten Dezimalstelle des Zeichencodes des ersten Zeichens, Modulo 3 bar, erkannt. Ich füge einfach ^_(RIP) zum ersten Teil hinzu und entferne ihn am Ende, um den Code für die spezielle Behandlung des ersten Teils zu speichern .dothatbarf """"

jtMsMCm,+@".^_"eChd*\ -ld4>d3c-+*4Nz`H\\

Probieren Sie es online aus. Testsuite.

Julia, 204 184 Bytes * 0,9 = 165,6

x->(r=r"\\(\w)\w+{(\w)}";t=[" "^endof(x)...];while ismatch(r,x) m=match(r,x);(a,b)=m.captures;t[m.offsets[1]-1]=a=="b"?'_':a=="d"?'.':a=="h"?'^':'~';x=replace(x,r,b,1)end;(join(t),x))

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und ein Tupel von Zeichenfolgen zurückgibt, die der oberen und unteren Zeile entsprechen. Die oberste Zeile enthält nachgestellte Leerzeichen. Um die Funktion aufzurufen, geben Sie ihr einen Namen, zf=x->...

Ungolfed:

function f(x::AbstractString)
    # Store a regular expression that will match the LaTeX macro call
    # with capture groups for the first letter of the control sequence
    # and the character being accented
    r = r"\\(\w)\w+{(\w)}"

    # Create a vector of spaces by splatting a string constructed with
    # repetition
    # Note that if there is anything to replace, this will be longer
    # than needed, resulting in trailing whitespace
    t = [" "^endof(x)...]

    while ismatch(r, x)
        # Store the RegexMatch object
        m = match(r, x)

        # Extract the captures
        a, b = m.captures

        # Extract the offset of the first capture
        o = m.captures[1]

        # Replace the corresponding element of t with the accent
        t[o-1] = a == "b" ? '_' : a == "d" ? '.' : a == "h" ? '^' : '~'

        # Replace this match in the original string
        x = replace(x, r, b, 1)
    end

    # Return the top and bottom lines as a tuple
    return (join(t), x)
end

CJam, 53 Bytes

Sl+'\/(_,S*\@{(i2/49-"_. ^"=\3>'}-_,(S*@\+@@+@@+\}/N\

Probieren Sie es online aus

Erläuterung:

S       Leading space, to avoid special case for accent at start.
l+      Get input, and append it to leading space.
'\/     Split at '\.
(       Split off first sub-string, which does not start with an accent.
_,      Get length of first sub-string.
S*      String of spaces with the same length.
\       Swap the two. First parts of both output lines are now on stack.
@       Rotate list of remaining sub-strings to top.
{       Loop over sub-strings.
  (       Pop first character. This is 'b, 'd, or 'h, and determines accent.
  i       Convert to integer.
  2/      Divide by two.
  49-     Subtract 49. This will result in 0, 1, or 4 for the different accents.
  "_. ^"  Lookup string for the accents.
  =       Get the correct accent.
  \       Swap string to top.
  3>      Remove the first 3 characters, which is the rest of the accent string
          and the '{.
  '}-     Remove the '}. All the macro stuff is removed now.
  _,(     Get the length, and subtract 1. This is the number of spaces for the first line.
  S*      Produce the spaces needed for the first line.
  @\+     Bring accent and spaces to top, and concatenate them.
  @@+     Get previous second line and new sub-string without formatting to top,
          and concatenate them.
  @@+     Get previous first line and new accent and spacing to top,
          and concatenate them.
  \       Swap the two lines to get them back in first/second order.
}/      End loop over sub-strings.
N\      Put newline between first and second line.

Haskell, 156 * 0,9 = 140,4 Bytes

g('\\':a:r)=(q,l):g s where q|a=='b'='_'|a=='d'='.'|a=='h'='^'|a=='t'='~';(_,_:l:_:s)=span(<'{')r
g(a:b)=(' ',a):g b
g""=[('\n','\n')]
f=uncurry(++).unzip.g

Anwendungsbeispiel:

*Main> putStr $ f "\\dot{L}Vz\\dot{[}|M.\\bar{#}0\\hat{u}U^y!\"\\tilde{I} K.\\bar{\"}\\hat{m}dT\\tilde{$}F\\bar{;}59$,/5\\bar{'}K\\tilde{v}R \\tilde{E}X`"
.  .   _ ^     ~   _^  ~ _      _ ~  ~  
LVz[|M.#0uU^y!"I K."mdT$F;59$,/5'KvR EX`

So funktioniert es: Gehen Sie die Eingabezeichenfolge Zeichen für Zeichen durch und erstellen Sie eine Liste von Zeichenpaaren, links für die obere Ausgabezeichenfolge, rechts für die untere Ausgabezeichenfolge. Wenn a \gefunden wird, nehmen Sie den entsprechenden Akzent, andernfalls ein Leerzeichen für das linke Element. Transformieren Sie schließlich die Liste der Paare in eine einzelne Zeichenfolge.

Python 3, 203 Bytes

Ohne Bonus:

l=list(input())
b=list(" "*len(l))
try:
 while 1:s=l.index("\\");t=l[s+1];del l[s+6];del l[s:s+5];b[s] = "b"==t and "_" or "d"==t and "." or "h"==t and "^" or "*";
except:print("".join(b)+"\n"+"".join(l));

Ich hoffe wirklich, dass es eine kürzere Version gibt.