There are several optimisations that can be performed on the brute force algorithm on the most obvious search space, for finding strings like this.

The solution to the problem contains 10 digits, and each digit contains a number from to 9. This means the most obvious search space is the set of all strings 0000000000 to 9999999999, or 10,000,000,000 search items. This space can be drastically reduced with some logic applied to the problem in advance.

First, as has been pointed out by m_turner, the sum of all the digits must be 10 (in Eindhoven notation, using N-Wing's symbols, (+ : 0 ≤ i < 10 : di) = 10). So, if values are chosen for digits d9 to d1, there is only one possible valid value for d0 = 10 - (+ : 0 < i < 10 : di). This reduces the search space by a factor of 10. (If the computed value for d0 is negative, then the chosen values for d9 to d1 are invalid. Indeed, if the computed value is 0, then you don't have a valid string either.)

Second, as has been pointed out by N-Wing, the sum of all the digits di multiplied by their position in the string i must be 10, i.e. (+ : 0 ≤ i < 10 : (i * di)) = 10. Since 0 * x = x for all x, this expression is equivalent to (+ : 0 < i < 10 : (i * di)) = 10. d1 can be isolated from the equation, d1 = 10 - (+ : 1 < i < 10 : (i * di)). This reduces the search space by another factor of 10. (Again, if the computed value for d1 is negative, then the previously chosen values for the string cannot make a valid solution.)

Applying the same formula in the above paragraph in a different way, we have that for each i, (i * di) ≤ 10. This leads to the third optimisation (also suggested by N-Wing): instead of checking every digit di with values 0 to 9, check di with values 0 to floor(10 / i). d9 cannot be 2 or greater, because then (9 * d9) > 10 so (+ : 1 < i < 10 : (i * di)) > 10. Similarly, d8, d7, and d6 cannot be 2 or greater. d5 and d4 cannot be 3 or higher, d3 cannot be 4 or higher, and d2 cannot be 6 or higher. This reduces the search space to 2 * 2 * 2 * 2 * 3 * 3 * 4 * 6, or 27 * 33 = 128 * 27 = 3456.

This final optimisation can be pursued even more aggressively, in that, for example, at most one of d9, d8, d7, and d6 can be 1 (because if d7 and d6 were both one, 7 * d7 + 6 * d6 = 7 * 1 + 6 * 1 = 7 + 6 = 13 > 10). This reduces the search space to 40.

The following is a Lua program for showing all these types of strings in any specified base.

```-- To run, type:
-- lua -f Problem.lua B
-- where Problem.lua is the name of this file
-- and B is the base

Problem = {}

Problem.Show = function()
write ("Solution:")
local i = Problem.B
while (i > 0) do
i = (i - 1)
write (" " .. Problem.A[i])
end
write ("\n")
end

Problem.Check = function()
local Test, i, success = {}, Problem.B, 0
while (i > 0) do
i = (i - 1)
Test[i] = 0
end
i = Problem.B
while (i > 0) do
i = (i - 1)
local x = Problem.A[i]
Test[x] = (Test[x] + 1)
end
i = Problem.B
while ((i > 0) and (success ~= nil)) do
i = (i - 1)
if (Test[i] ~= Problem.A[i]) then
success = nil
end
end
Problem.Checked = (Problem.Checked + 1)
return (success)
end

Problem.Solve1 = function(n, Total0, Total1)
if (n < 2) then
Problem.A[1] = (Problem.B - Total1)
if (Problem.A[1] >= 0) then
Total0 = (Total0 + Problem.A[1])
Problem.A[0] = (Problem.B - Total0)
if (Problem.A[0] > 0) then
if (Problem.Check() ~= nil) then
Problem.Show()
end
end
end
else
Problem.A[n] = 0
repeat
Problem.Solve1((n - 1), Total0, Total1)
Problem.A[n] = (Problem.A[n] + 1)
Total0 = (Total0 + 1)
Total1 = (Total1 + n)
until ((Total0 >= N) or (Total1 > N))
end
end

Problem.Solve = function(b)
Problem.A = {}
Problem.B = b
Problem.Checked = 0
Problem.Solve1((b - 1), 0, 0)
end

B = tonumber(arg[1])
if ((arg.n ~= 1) or (type(B) ~= "number") or (B <= 0)) then
write ("I need a base, B (and nothing more)\n")
else
Problem.Solve(B)
write ("Size of search space : " .. Problem.Checked .. "\n")
end
```

One final tweak would be to implement N-Wing's final point; fix db - 1 (Problem.A[b - 1]) to 0.