How can I make ProjectEuler 23 Solution faster

Question

This is what I have. It is solving the problem, but taking forever. Can I divide the last loop 0 to 28123 into half and run them simultaneously somehow to make it faster, and then in the end add the two sums to get the final result? Will "thread" help? What can I do to make the code solve faster?

/*
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.
 */

public class power {

    public static void main(String[] args){
        System.out.println(bigSum());
    }

    public static boolean isPerfect(int a){
        boolean perfect = false;

        int sum = 0;

        for(int i = 1; i<(a/2)+1; i++)
        {
            if (a%i == 0)
            {
                sum = sum + i;
            }
        }

        if(a == sum){
            perfect = true;
        }

        return perfect;
    }

    public static boolean isAbundant(int a){
        boolean Abundant = false;

        int sum = 0;

        for(int i = 1; i<(a/2)+1; i++)
        {
            if (a%i == 0)
            {
                sum = sum + i;
            }
        }

        if(a < sum){
            Abundant = true;
        }

        return Abundant;
    }

    public static boolean isDeficient(int a){
        boolean Deficient = false;

        int sum = 0;

        for(int i = 1; i<(a/2)+1; i++)
        {
            if (a%i == 0)
            {
                sum = sum + i;
            }
        }

        if(a > sum){
            Deficient = true;
        }

        return Deficient;
    }

    public static boolean isSumOfTwoAbundant(int a){
        boolean SumOfTwoAbundant = false;

        for(int i = 1; i<a; i++){
            if(isAbundant(i) && isAbundant(a-i)){
                SumOfTwoAbundant = true;
            }
        }
        return SumOfTwoAbundant;
    }

    public static long bigSum(){
        int sum = 0;

        for(int i = 0; i<28123; i++){
            if(!isSumOfTwoAbundant(i)){
                sum = sum + i;
                System.out.println("i: " + i + "; " + "Sum: " + sum);
            }
        }
        return sum;
    }
}

Consider finding the abundant numbers first, then finding sums of all possible pairings; look for faster ways to factor; there is a known algorithm to get the sum of the proper factors (aliquot sum) from the prime factors of a number. There's no need for multithreading. A single-threaded Java program can solve this in under a second. — David Conrad, May 07 '14 at 21:10

score 0 · Answer 1 · answered May 07 '14 at 20:59

You're recomputing whether every number < a is abundant with every call of isSumOfTwoAbundant. Try keeping a list of abundant numbers and add to it when you find one. Then you can loop through that list rather than rechecking for abundance for numbers < a. Something like:

public static boolean isSumOfTwoAbundant(int a){
boolean SumOfTwoAbundant = false;
    if(isAbundant(a))
    {
        abundants.add(a);
    }

    for(int i = 0; i<abundants.length; i++) {
        for(int j = 0; j < abundants.length; j++) {
            if(a - abundants[i] == abundants[j]){
                SumOfTwoAbundant = true;
            }
        }
    }
    return SumOfTwoAbundant ;
}

private ArrayList<int> abundants;

There are a lot of other ways to make this better, too, but Project Euler is about learning those through experience.

score 0 · Answer 2 · answered Aug 15 '15 at 00:54

Another Java solution: (takes less than a second)

static int sum_Of_Divisors(int n){
    int limit = n;
    int sum = 0;
    for(int i=1;i<limit;i++){
        if(n%i==0){
            if(i!=1){
                if(i != n/i)  sum += (i + n/i);
                else          sum += i;
            }
            else 
                sum += i;
            limit = n/i;
        }
    }       
    return sum;
}
static boolean isAbundant(int n){
    int sum = sum_Of_Divisors(n);
    return sum>n;
}
static boolean sum_of_Two_Abundant(int n, HashSet<Integer> abundant){
    for(Integer i:abundant){
        if(abundant.contains(n-i)) return true;
    }
    return false;
}
static long q23(){
    long sum = 0;
    HashSet<Integer> abundant = new HashSet<Integer>();
    for(int i=2;i<=28123;i++){
        if(isAbundant(i))
            abundant.add(i);
    }
    for(int i=1;i<=28123;i++)
        if(!sum_of_Two_Abundant(i, abundant)) sum+=i;
    return sum;
}

How can I make ProjectEuler 23 Solution faster

2 Answers2