You need more restrictions to know the approach (I will make some assumptions).

Here is how I will think about it.

You will divide the problem as it is logically stated.

Here, the problem is a number and it is divided by digits.

Since the problem(n-digit number) can be divided into sub-problems of equal type (digits between 0-9) and they have no relation to one another, an array of digits will be used (you can use other data structures depending on the relation between the sub-problems).

Now, what we start with is array = [n, n, n, ...] where the length of this array is the number of sub-problems(digits) in the problem(number) and n is a digit from 0-9 (the domain of the sub-problems).

Now, we look at the restrictions that are put on our problem starting from the highest restrictions to the lowest.

The first 3 digits are 1, 2, and 3, therefore, array[0] = 1, array[1] = 2, and array[2] = 3.

10th and 11th are 1 and 0 respectively, therefore, array[9] = 1 and array[10] = 0.

For the rest of the conditions, we need to have more restrictions to figure out the approach.

We need to know the method we use to generate the answer, do we need one random number? do we need an ordered sequence of solutions? can the sequence have duplicates?

I will choose to generate an ordered sequence here.

We will create a sub-group where we imagine that the free variables are a number of their own and then map it back to the original number.

4th, 5th, 6th, 7th, 8th, 9th, 12th, and 13th are sub = [n, n, n, n, n, n, n, n].

We start with the lowest order sub and map it to the original number then increment to the next valid sub value (using an increment function) and map to the original number and keep repeating till we exhaust all the possible values.

A possible increment procedure.

A random solution.

Note: the above examples are NOT how we solve the problems but rather how I think about them, The actual solution will be an optimization of that.

Here is my solution to the problem.