Homework

We start with a string $a$. Then we process string $b$ one character at a time, in its original order.

For each character $b_i$, string $c$ says who handles it:

• V: Vlad adds it to the front of the current string.
• D: Dima adds it to the back of the current string.

That is literally the whole problem. The only trap is thinking “append all characters from $b$ in any order” means we choose an order. We do not. The statement later pins it down: they add characters in the order they appear in $b$. So we just simulate that process.

Simulation

Let ans = a.

For every index $i$ from $0$ to $m-1$:

• If $c_i = \texttt{'V'}$, do ans.insert(ans.begin(), b[i]).
• Otherwise, do ans.push_back(b[i]).

After all $m$ operations, ans is the final string.

Example with the first sample:

• Start: ot
• b[0] = a, c[0] = D, append to back: ota
• b[1] = d, c[1] = V, insert to front: dota

So the answer is dota.

Why this works

The process described by the statement is sequential. At step $i$, exactly one known character $b_i$ is added to exactly one known side of the current string. There are no choices and no hidden optimization. So directly performing those operations produces exactly the same string Vlad and Dima produce.

A useful way to think about the Vlad side: every time Vlad inserts a character, it goes before everything currently in the string, including previous Vlad insertions. So if Vlad handles characters x, then later y, the final prefix has y before x. Front insertion naturally handles this without needing to reason about reversal separately.

Complexity

Here $n,m \le 10$, so even the most direct string insertion is absolutely fine.

For each test case, the answer length is at most $n+m$, and we do $m$ operations. Front insertion into a C++ string can shift characters, but with these constraints that is nothing. Complexity is comfortably within limits: $O(m(n+m))$ using direct string insertion, with tiny constants. Basically, this problem is asking you to follow directions, not invent a NASA launch sequence.