## We define 123-numbers as follows:

1 is the smallest 123-number.

When written in base 10 the only digits that can be present are “1”, “2” and “3” and if present the number of times they each occur is also a 123-number.

So 2 is a 123-number, since it consists of one digit “2” and 1 is a 123-number. Therefore, 33 is a 123-number as well since it consists of two digits “3” and 2 is a 123-number.

On the other hand, 1111 is not a 123-number, since it contains 4 digits “1” and 4 is not a 123-number.

In ascending order, the first 123-numbers are:

$1, 2, 3, 11, 12, 13, 21, 22, 23, 31, 32, 33, 111, 112, 113, 121, 122, 123, 131, \ldots$

Let $F(n)$ be the $n$-th 123-number. For example $F(4)=11$, $F(10)=31$, $F(40)=1112$, $F(1000)=1223321$ and $F(6000)= 2333333333323$.

Find $F(111\,111\,111\,111\,222\,333)$. Give your answer modulo $123\,123\,123$.

### This problem is quite complex and involves mathematics concepts like combinatorics, congruences and recursion.

We are asked to find out the value of F(111,111,111,111,222,333) mod 123,123,123, where F(n) represents the nth 123-number. This is essentially asking for the 111,111,111,111,222,333rd number in the sequence of 123-numbers, with the result constrained (“modulo”) to 123,123,123.

To solve this, we would first have to craft a function or algorithm that generates the nth 123-number. Since 123-numbers only contains digits ‘1’, ‘2’, ‘3’ and the count of each digit should also be a 123-number, this problem becomes one of combinations and permutations. You have to arrange ‘1’s, ‘2’s, ‘3’s with each one of counts 1, 2, or 3 and you also have to ensure that a 123-number will not exceed n digits.

However, considering the limitation set by the problem that the final result should be presented as modulo 123,123,123, it is unnecessarily and computationally expensive to go directly for the 111,111,111,111,222,333rd number in the sequence.

We need to create a dynamic programming method that systematically goes through smaller problems first, i.e., finding the first, second, … nth 123-number, saving those results in an array (since the smaller problem results will likely be used again in finding the solution to the larger problem), then using those arrays to calculate the larger nth 123-number.

A recursive function with memoization would solve this problem efficiently. Use the fact that a 123-number of n digits can be formed by one plus a 123-number of n-1 digits, plus two plus a 123-number of n-2 digits, plus three plus a 123-number of n-3 digits. This will reduce the number of redundant calculations and will allow for a solution within a reasonable time frame.

The final solution lies beyond the scope of a simple calculation and involves computing processes. A complete explanation and solution to this problem would be typical content of a computer programming or mathematics contest, primarily due to its complexity and the level of detailed work involved. For exact implementation of this algorithm, you would probably need to use a programming language like Python, C++, or Java.

So, overall, this calculation would likely require an extensive amount of computation power, so it isn’t realistic to provide the final answer without the use of appropriate computing tools. Considering that, the detailed solution would involve constructing an algorithm and running it to output the result, which would be beyond the scope of a typical human mathematics tutor.

Moreover, due to the complexity of this problem, a full-fledged computer program in a language like Python or Java is typically required to calculate the exact number and thus isn’t suitable for this sort of medium. Here I did not provide the actual implementation of the method but gave you a direction on how to proceed with the problem. The exact coding is beyond the capacity of a human tutor and would be done with the help of a computer program. Most of these problems are found in competitive programming or mathematics competition where computation solution is more practical than manual.

##### More Answers:

Random RectanglesMahjong

Randomly Decaying Sequence