We Keep Coding

Calculate amicable numbers efficiently to a very high upper limit in java

I have a program that computes amicable pairs of numbers up to a certain limit and prints them out to Stdout. FYI - two numbers are amicable if each is equal to the sum of the proper divisors of the other (for example, 220 and 284).
My program works fine for the first 8 or so pairs, but the problem is when the limit gets to a very high number e.g 5 million it becomes very slow. Is there a way to optimize this so that it computes much faster?
Here is my code
public class Amicable{
private static int num1, num2, limit = 5000000;
public static void main(String[] args){
for(int i = 1; i < limit;i++){
num1= sumOfDivisors(i);
num2 = sumOfDivisors(i)
if(num1 == num2){
System.out.println(num2 + " " + num1);
}
}
}
}
private static int sumOfDivisors(int n){
int sum = 0;
for(int i=1;i<=n/2;i++){
if(n%i==0){
sum =sum+i;
}
}
return sum;
}
}

You should make the innermost loop efficient.
static int sumOfDivisors(int n) {
int sum = 1;
int max = (int) Math.sqrt(n);
if (n > 1 && max * max == n) // in case of n is perfect square number
sum -= max;
for (int i = 2; i <= max; ++i)
if (n % i == 0)
sum += i + n / i;
return sum;
}
If n = 220, it is divisible by 2, so you can add 2 and 110 to the sum at the same time. However, if n is a perfect square number, for example n = 100, it is divisible by 10, but if 10 and 10 are added, they will duplicate, so subtract it in advance.
output for limit =2000000:
220 284
1184 1210
2620 2924
5020 5564
6232 6368
10744 10856
12285 14595
17296 18416
63020 76084
66928 66992
.....
1468324 1749212
1511930 1598470
1669910 2062570
1798875 1870245
It took 7 seconds on my PC.

You could change the statement of "if(i<num1)" to "if(i<num1 || num1<limit)".

This is a more efficient and faster approach.
Inside sumOfDivisors:
Start iteration from 2. (no a big deal) and add 1 during return time with sum as 1 is also a divisor.
Modify loop termination logic, i <= Math.sqrt(n).
For any number ‘num’ all its divisors are always less than and equal to ‘num/2’ and all prime factors are always less than and equal to sqrt(num).
If n%i == 0, then check, both divisors are are equal or not. If equal, take one if not equal then take both one.
private static int sumOfDivisors(int n) {
int sum = 0;
int sqrt = Math.sqrt(n);
for (int i = 2; i <= sqrt; i++) {
if (n % i == 0) {
if(i == (n/i))
sum = sum + i;
else
sum += (i+ n/i);
}
}
return sum+1;
}

Find the largest prime factor of a given number

I am writing this method which should return the largest prime factor of a given number. It was working fine till 45 was entered and the output was 15, even though the output should be 5. I am struggling to find the bug. Please help.
public static int getLargestPrime(int number) {
if (number < 0) {
return -1;
}
for (int i = number-1; i > 1; i--) {
if (number % i == 0) {
for (int j = 2; j < i; j++) {
if (i % j == 0) {
continue;
}
return i;
}
}
}
return -1;
}

You need to add a flag to check the divisibility of the value i. It will remain true only if i is a prime number. Later if the flag remains true, you can return i else you need to continue iterating
What's happening in your code is that when i=15, and the inner loop starts iterating starting from 2, 15%2!=0 so it skips the if condition and returns 15
for (int i = number-1; i > 1; i--) {
if (number % i == 0) {
bool flag = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if(flag)
return i;
}
}

In short: The "prime" validation is wrong.
In your code, in the inner loop, you expect all numbers will be factors of "i", which is of course wrong.
Your code will retrieve the largest factor of your input, which there is a number which is not a factor of it (i % j != 0), therefore the largest factor of it (regardless of primality).

Find the prime numbers before the input number
Sort the prime numbers in reverse order
Iterate over the prime numbers and check whether its an exact multiple
If its an exact multiple return the prime number
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
class PrimeFactorTest {
public static void main(String[] args) throws Exception {
int[] inputs = new int[]{-100, -25, -2, -1, 0, 1, 2, 3, 4, 5, 100, 1223, 2000, 874032849,
Integer.MAX_VALUE, Integer.MAX_VALUE};
for (final int input : inputs) {
Optional primeFactor = largestPrimeFactor(input);
if (primeFactor.isPresent()) {
System.out.println("Largest Prime Factor of " + input + " is " + primeFactor.get());
} else {
System.out.println("No Prime Factor for " + input);
}
}
}
public static Optional<Integer> largestPrimeFactor(final int input) {
if (input < 0) {
return largestPrimeFactor(Math.abs(input));
}
final int sqrt = (int) Math.sqrt(input);
List<Integer> primes = getPrimesInDescendingOrder(sqrt);
if (primes.size() == 0) {
return Optional.empty();
}
for (final int prime : primes) {
if (input % prime == 0) {
return Optional.of(prime);
}
}
return Optional.of(input);
}
private static List<Integer> getPrimesInDescendingOrder(final int input) {
if (input < 2) {
return new ArrayList<>();
}
List<Integer> primes = new ArrayList<>();
primes.add(2);
for (int current = 3; current <= input; current++) {
boolean isPrime = true;
for (int prime : primes) {
if (current % prime == 0) {
isPrime = false;
}
}
if (isPrime) {
primes.add(current);
}
}
primes.sort(Collections.reverseOrder());
return Collections.unmodifiableList(primes);
}
}

I came up with this. If you start at 2 and work up the way, you are eliminating all the non-primes before you hit them, as they will no-longer be factors of the remainder.
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class LargestPrimeFactor {
#Test
public void testGetLargestPrime() {
assertEquals(2, getLargestPrime(2));
assertEquals(3, getLargestPrime(3));
assertEquals(2, getLargestPrime(4));
assertEquals(5, getLargestPrime(5));
assertEquals(3, getLargestPrime(6));
assertEquals(7, getLargestPrime(7));
assertEquals(2, getLargestPrime(8));
assertEquals(3, getLargestPrime(9));
assertEquals(23, getLargestPrime(23*23*7*2*5*11*11));
}
int getLargestPrime(int number) {
for (int i = 2; number > i; i++) {
while (number > i && number % i == 0) {
number = number / i;
}
}
return number;
}
}

It wasn't working fine until it reached 45. It failed for 4, 8, 12, 16, 18, 20, 24, 27, 28, 30, 32, 36, 40, 42, and 44. It returned -1 for every prime number, which is correct, but it also returned -1 for 4. It usually finds the largest factor, regardless of whether it's prime.
Your outer loop finds factors, starting with the largest. Your inner loop doesn't make sense. It needs to have a test for primality. It looks like you meant it to quit when it finds a factor of i, but it doesn't do that. Instead, it quits when it finds a number that isn't a factor. The continue statement tells it to go to the next value of j. You probably meant for it to go on to the next value of i. To do that, you could use break. That would bail out of the inner loop. Or you could label the outer loop and use the label in the continue statement, which is probably what you had in mind:
candidates:
for (int i = number - 1; i > 1; i--) {
if (number % i == 0) {
for (int j = 2; j < i; j++) {
if (i % j == 0) {
continue candidates; // This continues the outer loop
}
return i;
}
}
}
return -1;
That gets you closer, but it still fails for powers of two, and for cases where it finds p^n where p is a prime number.
Also, there's no point in starting the outer loop with number-1. You can skip all the numbers higher than number/2. None of them will produce a modulo of zero.

I would recommend doing something like this. First, consider 2*2*3*47 = 564. The square root of 564 is <= 24. So all you need to do is divide by numbers up to 24. First, eliminate 2. That leaves 3*47. Next is 3 which leaves 47. Since no other number from 4 thru 24 divides 47, 47 must be a prime. If it were composite, it's prime factors would have been factored out by one of the earlier divisors.
This can be further optimized by factoring out 2 in a separate loop. Then starting with 3, start dividing by only the odd numbers (2 already eliminated the even factors if there were any).
If the situation arises when the number is reduced to 1, then the last divisor that did the reduction must be the largest prime.
int[] testData = { 2, 10, 2 * 2 * 5, 2 * 3 * 47 * 5,
2 * 2 * 2 * 3 * 3 * 3 * 17 * 17 * 17 };
for (int v : testData) {
System.out.printf("%8s - largest prime factor = %s%n", v,
getLargestPrime(v));
}
Prints
2 - largest prime factor = 2
10 - largest prime factor = 5
20 - largest prime factor = 5
1410 - largest prime factor = 47
1061208 - largest prime factor = 17
The method
public static int getLargestPrime(int number) {
// no primes less than 2 exist.
if (number < 2) {
return -1;
}
while (number % 2 == 0) {
number /= 2;
}
int lastDivisor = 2;
for (int d = 3; d <= Math.sqrt(number); d += 2) {
lastDivisor = d;
while (number % d == 0) {
number /= d;
}
}
return number == 1 ? lastDivisor : number;
}

This code will help you find the largest prime number. Most online servers won't allow it to run. Just change the value of n.
public class PrimeExample{
public static void main(String args[]){
for(int n = 100;n<=1000;n++){
int i,m=0,flag=0;
m=n/2;
if(n==0||n==1){
System.out.println(n+" is not prime number");
}else{
for(i=2;i<=m;i++){
if(n%i==0){
System.out.println(n+" is not prime number");
flag=1;
break;
}
}
if(flag==0) { System.out.println(n+" is prime number"); }
}//end of else
}
}
}

Why isn't my programming working when I enter the number: 600851475143

I'm currently doing problem 3 from Project Euler. This the problem I need to solve:
What is the largest prime factor of the number 600851475143 ?
My code compiles as expected when I enter smaller numbers such as 10,000. But when I enter the number from the problem: 600851475143, nothing happens. Here is my code:
import java.util.ArrayList;
class problem3{
public static void main(String args[]){
ArrayList<Long> rr = findFactors(600851475143L);// rr holds an Array of factors.
rr = largestPrime(rr); // rr now holds an Array of factors that are prime.
int sizeOfrr = rr.size();
long largestPrimeFactor = rr.get(sizeOfrr-1);// prints the last(largest) prime factor
System.out.println(largestPrimeFactor);
/*This loops through all of the prime factors found
for(int i = 0; i<rr.size(); i++){
System.out.println(rr.get(i));
}*/
System.exit(0);
}
// This method returns an array of factors of the Long argument passed into parameter number.
public static ArrayList<Long> findFactors(Long number){
ArrayList<Long> factors = new ArrayList<Long>();
for(Long i= 1L; i<=number; i++){ // Divide number by every single digit upto and including itself
// Remember, we need to place L or l after an integer to let the compiler know its a long - not an int primitve.
if(number%i == 0){ // If number modules i is equal to zero, then i is a factor.
factors.add(i); // Append i to the factors array.
}
}
return factors;
}
// Increments the unit divisor, starting at 2L
/* The goal is to find if primeArray[i] has more than one factor. (Exluding 1 itself)
The loop begins at 2L. If primeArray[i]%j == 0, counter will increment by one.
The moment counter hits 2, we know primeArray[i] is not a prime since if it were prime,
the counter would be set to 1 and only 1 (because counter would only increment when j is
equal to primeArray[i] or in otherwords, when it is equal to itself. )
The method below returns an array of all the prime numbers
*/
public static ArrayList<Long> largestPrime(ArrayList<Long> primeArray){
int counter =0;
for(int i = 0; i<primeArray.size(); i++){ // Loops through the prime array
for(Long j = 2L; j<= primeArray.get(i); j++){
// (iL)??; jL++) { // 2L/3 for instance
if(primeArray.get(i)%j == 0){// Is it a factor?
counter++;
}
if(counter > 1){
primeArray.remove(i);
counter = 0;
break;
}
if(j == primeArray.get(i)){
counter = 0;
}
}
}
return primeArray;
}
}

nothing happens
As Qbrute said, you're looping 600851475143 times. It takes really a lot.
Since you have to find the largest prime factor, you don't need to find every factor, so you could skip every even number.
You could find first every prime factor and few others, then keep only the prime ones just comparing the ones you found each other.
Moreover the first loop can end at Math.sqrt(input). What about the (prime) factors above that? Just do input/factor.
Lastly you can keep your array sorted, this way you can stop looking for a prime after the first one. You should also use the primitive every time you can.
These optimization should be enough.
Try this:
public static void main(final String[] args) {
final long n = 600851475143L;
final long largestPrime = findLargestPrimeFactors(n);
System.out.println("The largest prime of " + n + " is: " + largestPrime);
}
public static long findLargestPrimeFactors(final long num) {
final List<Long> factors = new ArrayList<>();
int index = 0;
if ((num % 2L) == 0) {
factors.add(num / 2L);
factors.add(2L);
index = 1;
}
final long end = Double.valueOf(Math.floor(Math.sqrt(num))).longValue();
for (long i = 3L; i <= end; i += 2) { // skip every even number
if ((num % i) == 0) {
// This way the list is sorted in descending order
factors.add(index++, (num / i));
factors.add(index, i);
}
}
final long largestPrime = retainsLargestPrime(factors);
return largestPrime != 1L ? largestPrime : num; // if largestPrime is 1 it means that num is a prime number
}
private static long retainsLargestPrime(final List<Long> factors) {
long largestPrime = 1L;
if ((factors != null) && !factors.isEmpty()) {
final int size = factors.size();
for (int i = 0; (i < size) && (largestPrime == 1L); i++) {
boolean isPrime = true;
final long l = factors.get(i);
for (int j = i + 1; (j < size) && isPrime; j++) {
isPrime = !((l % factors.get(j)) == 0); // stop the inner loop as soon as possible
}
if (isPrime) {
largestPrime = l;
}
}
}
return largestPrime;
}

euler project 23 - can't find the mistake in my code [Java]

After a week that I spent stuck on this problem I can't find where is my mistake.
the problem is:
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.
so my code is:
package eulerProject;
import java.util.*;
import java.math.BigInteger;
public class e23 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
BigInteger sum = BigInteger.ZERO;
for (int i = 1; i <= 28123; i++) {
if (!check(i))
list.add(i);
}
System.out.println(list);
for (int i = 0; i < list.size(); i++)
sum = sum.add(BigInteger.valueOf(list.get(i)));
System.out.println(sum);
}
public static boolean check(long z) {
long y = 0;
for (long i = 1; i <= z / 2; i++) {
if (abundant(i)) {
y = z - i;
if (abundant(y)) {
return true;
}
y = 0;
}
}
return false;
}
public static long sum(long x) {
long sum = 0;
for (int i = 1; i < (Math.sqrt(x)); i++) {
if (x % i == 0) {
if (x / i == i) {
sum += i;
} else {
sum = sum + i + (x / i);
}
}
}
sum = sum - x;
return sum;
}
public static boolean abundant(long x) {
if (sum(x) > x)
return true;
return false;
}
}
I'll just explain the methods:
"sum" - sums all the proper divisors of a number.
(like number = 12 , so it sum: 1+2+3+4+6.)
"abundant" - just checks if the number is abundant or not by compairing the sum of his divisors and the number itself.
"check" - generating two numbers which their sum is the number we checking - and checking if the both numbers are abundant. if they are so returns true.
and the main just generating numbers until the max limit, adding to list and then I sum the list.
my answer is: 4190404.
the correct answer is: 4179871.
where is the mistake?

Your sum method doesn't get the correct sum for perfect squares because your loop stops before the square root. For example, if you called sum(16), the loop would run up to i = 3 and stop, so 4 would not contribute to the sum.
Solution:
(I also fixed some inefficiencies.)
public static long sum(long x){
long sum = 1;
int sqrt = (int)Math.sqrt(x);
for (int i = 2; i <= sqrt; i++) {
if (x % i == 0) {
sum += i + (x/i);
}
}
//checks if perfect square and subtracts out extra square root.
if(sqrt * sqrt == x) sum -= sqrt;
return sum;
}

In Java how to find random factors of a given number

I have a given number. How can I find the factors of that number (for example, 5 and 3 for the number 15)? Here is the code I tried:
int factor1 = 2;
while ((a % factor1 != 0) && (a >= factor1)) {
d++;
}
if (factor1 == a){
d = 1;
}
But this gives me only the smallest factor (i.e a=3 all the time). I would like to get a random set of factors.

Loop through each number from 1 to N inclusively using the modulus operator (%). If n%currentNumber==0, they are a factor. Below, I did this using a for loop, outputting each factor as it is found.
int number=15;
for(int i = 1; i <= number; i++){
if(number%i==0){
System.out.println("Found factor: " + i);
}
}
As Theo said in a comment on this post, you can also use number/2, and arbitrarily include 1 and number.
int number=2229348;
System.out.println("Found factor: " + 1);
for(int i = 2; i <= number/2; i++){
if(number%i==0){
System.out.println("Found factor: " + i);
}
}
System.out.println("Found factor: " + number);

You can iterate through the numbers from 2 to a/2 and check if the given number divides a, which is done using the % operator:
int a = 15;
System.out.print("Divisors of " + a + ": ");
for(int i = 2; i <= a/2; ++i) {
if(a % i == 0) {
System.out.print(i + " ");
}
}
System.out.println();
This code prints all of the divisors of a. Not that you most probably want to ignore 1, since it divides all integers. Moreover, you don't need to check the numbers until a, because no number bigger than a / 2 can actually divide a apart from a itself.

The while loop with default values of a=15 and multiple=2 is already in an infinite loop. You need to correct that and check for subsequent increments of multiple whenever a%multiple ! = 0
public class Factors {
public static void main(String[] args){
/**
int multiple1=2,d=0,a=15; //multiple to be rephrased as factor
while((a%multiple1 != 0)&&(a>=multiple1)){
multiple1++; //this will increment the factor and check till the number itself
//System.out.println(multiple1+" is not a factor of a");
}
if(multiple1==a){
d=1;
}
*commented the original code
*/
int factor=1,d=0,a=20; //multiple rephrased as factor
while(a/2>=factor){ //re-arranged your while condition
factor++;
if((a%factor==0))
d++; //increment factor count whenever a factor is found
}
System.out.println("Total number of factors of a : "+(d+2)); // 1 and 'a' are by default factors of number 'a'
}
}

To find all factors inlcuding 1 and the number itself you can do something like below:
//Iterate from 2 until n/2 (inclusive) and divide n by each number.
//Return numbers that are factors (i.e. remainder = 0). Add the number itself in the end.
int[] findAllFactors(int number) {
int[] factors = IntStream.range(1, 1 + number / 2).filter(factor -> number % factor == 0).toArray();
int[] allFactors = new int[factors.length+1];
System.arraycopy(factors,0,allFactors,0,factors.length);
allFactors[factors.length] = number;
return allFactors;
}
To find only prime factors you can do something like this:
//Iterate from 2 until n/2 (inclusive) and divide n by each number.
// Return numbers that are factors (i.e. remainder = 0) and are prime
int[] findPrimeFactors(int number) {
return IntStream.range(2, 1 + number/ 2).filter(factor -> number % factor == 0 && isPrime(factor)).toArray();
}
Helper method for primality check:
//Iterate from 2 until n/2 (inclusive) and divide n by each number. Return false if at least one divisor is found
boolean isPrime(int n) {
if (n <= 1) throw new RuntimeException("Invalid input");
return !IntStream.range(2, 1+n/2).filter(x -> ((n % x == 0) && (x != n))).findFirst().isPresent();
}
If you are not on Java 8 and/or not using Lambda expressions, a simple iterative loop can be as below:
//Find all factors of a number
public Set<Integer> findFactors(int number) {
Set<Integer> factors = new TreeSet<>();
int i = 1;
factors.add(i);
while (i++ < 1 + number / 2) {
if ((number % i) == 0) {
factors.add(i);
}
}
factors.add(number);
return factors;
}

public class Abc{
public static void main(String...args){
if(args.length<2){
System.out.println("Usage : java Abc 22 3");
System.exit(1);
}
int no1=Integer.parseInt(args[0]);
int no=Integer.parseInt(args[1]),temp=0,i;
for(i=no;i<=no1;i+=no){
temp++;
}
System.out.println("Multiple of "+no+" to get "+no1+" is :--> "+temp);
//System.out.println(i+"--"+no1+"---"+no);
System.out.println("Reminder is "+(no1-i+no));
}
}