Number Maze

Core Idea

This problem looks like it wants you to do something fancy with permutation indexing, but the constraints quietly say: absolutely not.

The base code is always one of:

• $12$
• $123$
• $1234$

So the maximum number of permutations is only:

$4! = 24$

That is tiny. Generate all permutations, sort them, grab the requested two, compare them. Done.

Permutation Order

The statement says all permutations are sorted in ascending order.

For fixed-length digit strings with no leading zero issues here, lexicographic order is the same as numeric ascending order. Since the digits in 12, 123, and 1234 are already sorted, we can just use next_permutation starting from the original string.

For example, for 123, the sorted permutations are:

123, 132, 213, 231, 312, 321

So if $j = 2$ and $k = 5$, we compare:

132 vs 312

Counting A

An A means same digit, same position.

So loop over each index $i$:

For 132 and 312:

1 vs 3 -> different
3 vs 1 -> different
2 vs 2 -> same

So $A = 1$.

Counting B

Normally, Bulls and Cows style problems require careful frequency counting for B, especially when digits repeat.

But here, the digits are distinct and both strings are permutations of the same base number. That means every digit in one code appears exactly once in the other code.

So every digit is either:

• in the same position: counts as A
• in a different position: counts as B

Therefore:

where $m$ is the number of digits.

No frequency maps needed. No drama. The problem is literally just implementation.

Algorithm

For each test case:

1. Convert $n$ to a string.
2. Generate all permutations using next_permutation.
3. Store them in a vector.
4. Pick perms[j - 1] and perms[k - 1].
5. Count equal positions for A.
6. Set B = length - A.
7. Print xAyB.

Complexity

At most $24$ permutations are generated per test case, each of length at most $4$.

So the runtime is basically:

which is comically fine for $t \le 1000$.

Memory usage is also tiny.