A perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.

A number n is called deficient if the sum of its proper divisors is less than n and it is called abundant if this sum exceeds n.

As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number that can be written as the sum of two abundant numbers is 24. By mathematical analysis, it can be shown that all integers greater than 28123 can be written as the sum of two abundant numbers. However, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit.

Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers.

i have been trying to debug this code ever since i wrote it. all i managed to do is speed it up
that is a good thing but getting wrong answer is not. i added a HashSet to eliminate duplicates and it gave a smaller answer, but still much greater than correct answer. i changed the limit to 30000 and i am getting 29999 as a number that cannot be written as the sum of two abundant numbers. so i am definately doing something wrong but i can't see it. my ArrayList of abundant numbers looks ok, as does the listing of all the positive integers which cannot be written as the sum of two abundant numbers(24 is missing as is 30 etc.

Have you considered using an approach like the Sieve of Erastosthenes algorithm instead? Line 61 doesn't look right. You're adding up the index, not the values themselves.

My first inclination is to refactor for clarity -- make solve() a composed method. That will allow me to attack the problem one step at a time.

However, if you don't want to do that, I would look carefully at Line 31 and the breaks you are doing on Lines 37, 43, and 48. There are good reasons to discourage the use of breaks and I suspect the way you are using them and the bug that you are seeing is one of them.

Can you describe your algorithm? How are you actually trying to solve the problem? I find your code hard to follow, so i'm not sure what you are doing. And since it isn't a complete program, I can't run and debug it.

A couple of suggestions...take out the performance enhancements and try running it. a working slow program is always better than a fast program that doesn't. If it then works, put them back one at a time and see which breaks it - the look carefully at that bit to see why.

System.out.println() is always your best friend. put some in to see what your code is really doing. are you adding up the abundant numbers, or their index? are you adding in a number you think you should skip? Are you generating the correct list of abundant numbers?

FWIW, my entire class for Euler23 is 72 lines. That includes an eight-line method that I wrote for debugging - it's not called in my program to come up with the solution.

There are only two hard things in computer science: cache invalidation, naming things, and off-by-one errors

the problem was line 43
break label;
should be
break;
i should only break out of the inner loop at that point.
it is slower now(about 2 minutes on my old laptop) but the answer is correct

I’ve looked at a lot of different solutions, and in my humble opinion Aspose is the way to go. Here’s the link: http://aspose.com