Giới thiệu

Hệ thống sắp chữ LaTeX sử dụng macro để xác định dấu. Ví dụ, chữ ê được sản xuất bởi \hat{e}. Trong thử thách này, nhiệm vụ của bạn là triển khai phiên bản ASCII của chức năng này.

Đầu vào

Đầu vào của bạn là một chuỗi các ký tự ASCII có thể in trống. Nó sẽ không chứa dòng mới.

Đầu ra

Đầu ra của bạn là một chuỗi bao gồm hai dòng. Dòng đầu tiên chứa dấu và dòng thứ hai là các ký tự mà chúng thuộc về. Nó được lấy từ đầu vào như sau ( Abiểu thị một ký tự tùy ý):

• Mỗi \bar{A}được thay thế bằng Avới _trên đầu trang của nó.
• Mỗi \dot{A}được thay thế bằng Avới .trên đầu trang của nó.
• Mỗi \hat{A}được thay thế bằng Avới ^trên đầu trang của nó.
• Đối với một tiền thưởng -10%: mỗi \tilde{A}được thay thế bằng Avới ~trên đầu trang của nó.
• Tất cả các nhân vật khác có một không gian phía trên họ.

Ví dụ: đầu vào

Je suis pr\hat{e}t.

kết quả trong đầu ra

          ^
Je suis pret.

Quy tắc và tính điểm

Bạn có thể giả định rằng các nhân vật \{}chỉ xuất hiện trong các macro \bar{}, \dot{}và \hat{}(và \tilde{}nếu bạn đi cho tiền thưởng). Tất cả các đối số macro dài chính xác một ký tự, vì vậy \dot{foo}và \dot{}sẽ không xảy ra trong đầu vào. Đầu ra có thể là một chuỗi được phân tách bằng dòng mới hoặc một danh sách / cặp hai chuỗi. Bất kỳ số lượng dấu vết và khoảng trắng trước được cho phép, miễn là các dấu nằm ở vị trí chính xác. Đặc biệt, nếu không có dấu, đầu ra có thể là một chuỗi đơn.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất (sau phần thưởng) sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

Không có tiền thưởng:

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

Có thưởng

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 byte

Tôi loại bỏ các dấu ngoặc nhọn và tách ra \, giống như câu trả lời CJam của Reto Koradi. Các mã bar, dotvà hatđược công nhận chỉ đơn giản bằng các chữ số thập phân cuối cùng của mã ký tự của ký tự đầu tiên, modulo 3. Tôi chỉ cần thêm ^_(RIP) để phần đầu và loại bỏ nó cuối cùng để lưu mã để xử lý phần đầu đặc biệt .barf """"

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

Hãy thử trực tuyến. Bộ thử nghiệm.

Julia, 204 184 byte * 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))

Đây là một hàm ẩn danh chấp nhận một chuỗi và trả về một chuỗi các chuỗi tương ứng với các dòng trên cùng và dưới cùng. Dòng trên cùng sẽ có khoảng trắng ở cuối. Để gọi hàm, đặt tên cho nó, vdf=x->...

Ung dung:

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 byte

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

Dùng thử trực tuyến

Giải trình:

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 byte

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

Ví dụ sử dụng:

*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`

Cách thức hoạt động: đi qua ký tự chuỗi đầu vào theo ký tự và xây dựng danh sách các cặp ký tự, bên trái cho chuỗi đầu ra phía trên, bên phải cho chuỗi đầu ra thấp hơn. Nếu a \được tìm thấy, lấy dấu thích hợp, không gian khác cho phần tử bên trái. Cuối cùng biến đổi danh sách các cặp thành một chuỗi duy nhất.

Python 3, 203 byte

Không có tiền thưởng:

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

Tôi thực sự hy vọng có một phiên bản ngắn hơn.