如何优化此代码？ （也许使用LINQ？）

Question

I have this code:

ArrayList arrayA = new ArrayList();
ArrayList arrayB = new ArrayList();
ArrayList arrayC = new ArrayList();
ArrayList arrayD = new ArrayList();
ArrayList arrayE = new ArrayList();
ArrayList arrayF = new ArrayList();
ArrayList arrayG = new ArrayList();
ArrayList arrayH = new ArrayList();
ArrayList arrayI = new ArrayList();
ArrayList arrayJ = new ArrayList();

int n = 0;

for (decimal a = 0.1m; a <= 100m; a += 0.1m)
{
    for (decimal b = 100m - a; b > 0m; b -= 0.1m)
    {
        for (decimal c = 100m - b; c > 0m; c -= 0.1m)
        {
            for (decimal d = 100m - c; d > 0m; d -= 0.1m)
            {
                for (decimal e = 100m - d; e > 0m; e -= 0.1m)
                {
                    for (decimal f = 100m - e; f > 0m; f -= 0.1m)
                    {
                        for (decimal g = 100m - f; g > 0m; g -= 0.1m)
                        {
                            for (decimal h = 100m - g; h > 0m; h -= 0.1m)
                            {
                                for (decimal i = 100m - h; i > 0m; i -= 0.1m)
                                {
                                    for (decimal j = 100m - i; j > 0m; j -= 0.1m)
                                    {
                                        if ((a + b + c + d + e + f + g + h + i + j) == 100)
                                        {
                                            ++n;
                                            arrayA.Add(a);
                                            arrayB.Add(b);
                                            arrayC.Add(c);
                                            arrayD.Add(d);
                                            arrayE.Add(e);
                                            arrayF.Add(f);
                                            arrayG.Add(g);
                                            arrayH.Add(h);
                                            arrayI.Add(i);
                                            arrayJ.Add(j);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Any ideas how to optimize this? this is taking forever to execute.

Basically what is needed is to know the number of combination for 10 numbers between 0.1 and 100 where the sum of them is exactly 100. (I need to know the number of combinations and the combinations themselves)

Thanks in advance

Answer 1

I do not think there is a straightforward solution for this problem especially with this type of numbers. But here is a very general idea to help you develop your own algorithm:

1. Learn about Gosper's Hack . It can generate combinations in O(n) complexity.
2. You'll realize that you need to generate C(1000,10) combinations, which is not doable directly with primitive data types. To overcome this you can implement your own class that can represent large bit sequences with necessary operations like adding and shifting etc. (Or you can find a similar class in your standard library and extend it.)

I am aware that this is not an easy task and I would not want to implement this myself. But it will give you an O(n) time complexity, you just iterate over the combinations in linear time, use that bit sequence to pick numbers between 0.1 and 100 with step 0.1 and check if their sum is 100. And add the bit sequence to the final ArrayList.

Edit after Ronan Thibaudau's warning: I am sorry that I jumped into Java directly, but I think you can find the respective approach in your preferred language/framework.

Yet another edit: Now the post is language-independent. Idea is completely same... All I am saying is; if you are looking at such a problem with large combinations, this idea can give you O(n) time complexity and O(n) memory requirement. Which virtually guarantees that it will run in a feasible time, consuming feasible amount of memory given any sufficiently large n.

Self edit: I am still thinking about it and have to make a correction. (I am preserving the somewhat wrong algorithmic analysis)

Gosper's Hack will definitely give you O(n) time complexity to generate the combinations, which is essential to have an acceptably optimized implementation. However, as you will have to create your own class to represent bit sequence, you have to implement your own shifters, adders, ands and whatnot(ie you cannot directly use your hardware for those operations). For that, you will need another n-loop. Which would probably make your algorithmic complexity O(n ² )

It is definitely not as good as O(n), but should still satisfy your execution time demands.

Answer 2

If you'd really like to optimize proposed algorithm, I'd start by omitting unnecessary loops, it doesn't make sense to continue if the sum is >= 100, eg:

for (decimal a = 0.1m; a <= 100m; a += 0.1m)
{
    for (decimal b = 100m - a; b > 0m; b -= 0.1m)
    {
        if (a + b >= 100m)
             continue;

             for (decimal c = 100m - b; c > 0m; c -= 0.1m)
             {
                 if (a + b + c >= 100m)
                     continue;
                 ...

Anyway, you'll be never able to store all combinations. Eg, if you have only three numbers, the output would consist of 1000^2 results. The first number you can choose arbitrarily (0.1 .. 100, so you have 1000 choices), the same with the second one, eg, I'll choose 0.5 and 42 - the third one I have fixed, 57.5 - so it's 1000 * 1000 * 1 good results. Now extend it on 10 numbers.

Answer 3

I've come up with this as the best way to do this with LINQ:

var n = 1000;
var query =
    from a in Enumerable.Range(1, n)
    from b in Enumerable.Range(1, n - a)
    from c in Enumerable.Range(1, n - a - b)
    from d in Enumerable.Range(1, n - a - b - c)
    from e in Enumerable.Range(1, n - a - b - c - d)
    from f in Enumerable.Range(1, n - a - b - c - d - e)
    from g in Enumerable.Range(1, n - a - b - c - d - e - f)
    from h in Enumerable.Range(1, n - a - b - c - d - e - f - g)
    from i in Enumerable.Range(1, n - a - b - c - d - e - f - g - h)
    let j = n - a - b - c - d - e - f - g - h - i
    where j >= 1
    select new { a, b, c, d, e, f, g, h, i, j };

I've opted to use int and multiply the numbers by 10 rather than using decimal with 0.1 increments.

Now running this with 1,000 seems to take forever.

So I started running it with smaller numbers and got these results:

10  1
11  10
12  55
13  220
14  715
15  2002
16  5005
17  11440
18  24310
19  48620
20  92378

That's n & the number of combinations returned.

It turns out that this progression is C(n - 1, n - 10) . So plugging in n = 1000 I get 2,634,095,604,619,700,000,000 combinations.

Now, on my computer if I run with n = 30 it takes 11.551 seconds to compute the 10,015,005 combinations.

If you do the maths on that, assuming there are 365.25 days per year, then you come up with the figure that it would take 96,271,110 years to compute for n = 1000 .

Even "Deep Thought" was quicker at computing 42. Good luck waiting for it.

Answer 4

Here's an answer (from 1 to 1000 instead of 0.1 to 100 for simplicity, simply divide all items by 10 to get the value from 0.1 to 100)

First off we'll work with generator enumerables and lazy operators to avoid memory issues, everything will get streamed 1 possibility by 1 into the pipeline so memory should be fixed while the code runs

var kitems = Enumerable.Range(1,1000);
var q = from a in kitems
        from b in kitems
        from c in kitems
        from d in kitems
        from e in kitems
        from f in kitems
        from g in kitems
        from h in kitems
        from i in kitems
        from j in kitems
        where a+b+c+d+e+f+g+h+i+j == 1000
        select new {a,b,c,d,e,f,g,h,i,j};
// Since everything is lazy evaluated, the 10 first results are near immediate (nothing past those is evaluate, this is good for testing, remove the take operator if you want the full dataset)
foreach(var item in q.Take(10))
{
    // Do whatever you want with the result here
}

Answer 5

Let us reason on integer numbers (1 to 1000, sum 1000). Let C(K, N) be the number of combinations involving K variables for a total of N.

With a single variable, we have 1 possibility (a=1000), ie C(1, 1000)=1. More generally, C(1, N)=1.

With two variables, we have 999 combinations (a=1, b=999 to a=999, b=1) and we see that C(2, 1000)= C(1, 999) + C(1, 998) + C(1, 997) + ... C(1, 1). More generally, C(2, N) = N-1.

With three variables, we have C(2, 999) combinations with a=1, C(2, 998) with a=2... and C(2, 2) with a=998. By the formula of triangular numbers, C(3, N) = N.(N-1)/2.

With four variables, we have C(3, 999) combinations with a=1, C(3, 998) with a=2... and C(3, 3) with a=997. By the formula of tetrahedral numbers C(4, N)= N.(N-1).(N-2) / 6.

And so on (this is just Pascal's triangle), until:

C(10, N) = N.(N-1).(N-2).(N-3).(N-4).(N-4).(N-6).(N-7).(N-8).(N-9) / 9!

C(10, 1000) = 2634095604619702128324000

No hope to compute this astronomical number by enumeration !