Encode and Decode (Easy Version)

The problem looks weird because it is a communication problem: your program runs once to encode, dies, then runs again to decode. Memory does not survive. Global variables, files, prayers, all gone. The only bridge between the two runs is the lowercase string you print in the first run.

So the whole task is: design a reversible encoding from arrays to lowercase strings.

Key Observation

In the easy version, every value satisfies:

$1 \le a_i \le 26$

There are exactly 26 lowercase English letters. That is not a coincidence; that's the whole damn problem.

Use this mapping:

$$1 \to \mathtt{a},\quad 2 \to \mathtt{b},\quad \ldots,\quad 26 \to \mathtt{z}$$

For each array element, output one character. For example:

$[1,2,3,4,5] \to \mathtt{abcde}$

The sample uses whileloop, but samples in communication problems are just demonstrating the protocol. They are not telling you to reverse-engineer some mystical phrase generator. That would be nonsense, and not even fun nonsense.

Why $n$ Does Not Need Extra Encoding

A common false assumption is that we must encode $n$ separately. We don't.

Because every array element becomes exactly one character, the length of the encoded string is exactly the array length:

$|s| = n$

So during the second run, once we read $s$, we immediately know:

$n = |s|$

No separators, no padding, no base conversion, no cursed parsing tricks.

Encoding Phase

Input starts with first, then gives $n$ and the array.

For each $a_i$, print:

$\mathtt{'a'} + a_i - 1$

The produced string contains only lowercase letters, and its length is $n$. Since $n \le 10^4$, it easily satisfies the limit $|s| \le 10^5$.

Decoding Phase

Input starts with second, then gives the encoded string $s$.

The original length is:

$n = |s|$

For each character $c$ in $s$, recover the value:

$a_i = c - \mathtt{'a'} + 1$

Then print $n$ and the recovered array.

Correctness Proof

We prove that the algorithm always reconstructs the original array.

During encoding, each original value $a_i$ is mapped to the character

$c_i = \mathtt{'a'} + a_i - 1$

Because $1 \le a_i \le 26$, $c_i$ is always a lowercase English letter from a to z, so the encoded string is valid.

During decoding, each encoded character $c_i$ is mapped back to

$c_i - \mathtt{'a'} + 1$

Substituting the value of $c_i$ from the encoding step gives:

$$(\mathtt{'a'} + a_i - 1) - \mathtt{'a'} + 1 = a_i$$

So every element is recovered exactly.

Also, the encoder writes exactly one character per array element, so the encoded string length is exactly $n$. Therefore the decoder's computed length $|s|$ equals the original $n$.

Thus the decoder outputs the original $n$ and every original $a_i$, so the algorithm is correct.

Complexity

Encoding takes $O(n)$ time and outputs a string of length $n$.

Decoding takes $O(n)$ time.

Memory usage is $O(n)$ for the string, which is tiny here.