Zumkeller Numbers in Java

A number N is said to be the Zumkeller number if one can partition all the factors of the number N into two sets, such that the sum of the numbers (factors) in the first set is equal to the sum of the numbers (factors)in the second set. The sets must be non-empty. Let's see a few examples to understand it. In the input, the number N will be given to us.

Example 1:

Input: N = 84

Output: Yes, 84 is a Zumkeller number.

Explanation: The factors of 84 are: 1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84. Now, if we partition these factors into two sets like the following, we get

(28, 84) and (1, 2, 3, 4, 6, 7, 12, 14, 21, 42). Now, the sum of elements of the first set gives 28 + 84 = 112

The sum of elements of the second set gives:

1 + 2 + 3 + 4 + 6 + 7 + 12 + 14 + 21 + 42 = 112. Since the sum of elements of these two sets is the same, the number 84 is a Zumkeller number.

Example 2:

Input: N = 108

Output: Yes, 108 is a Zumkeller number.

Explanation: The factors of 108 are: 1, 2, 3, 4, 6, 9, 12, 18, 27, 36, 54, 108. Now, if we partition these factors into two sets like the following, we get

(2, 3, 27, 108) and (1, 4, 6, 9, 12, 18, 36, 54). Now, the sum of elements of the first set gives 2 + 3 + 27 + 108 = 140

The sum of elements of the second set gives:

1 + 4 + 6 + 9 + 12 + 18 + 36 + 54 = 140. Since the sum of elements of these two sets is the same, the number 108 is a Zumkeller number.

Example 3:

Input: N = 200

Output: No, 200 is not a Zumkeller number.

Explanation: The factors of 200 are: 1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200. Now, if we partition these factors into any two sets, we will not get that pair of sets whose sum of elements will be equal to each other. Hence, 200 is not a Zumkeller number.

Naïve Approach

The approach is straightforward. First of all, we will find all of the factors of the number N and store them in an array. Also, compute the sum of the elements stored in the array and store it in a variable called totalSum. Now, we will compute all of the possible sets that are possible and store them in the 2-dimensional array. Iterate over the 2-dimensional array and find the sum of the sets one by one in each iteration. Let's store it in a variable called setSum. Now, subtract totalSum and setSum, and whatever value is obtained if it matches with the setSum, then the number N is the Zumkeller number. If not, repeat the above-mentioned process for the other iterations too. If all the iteration is exhausted and at not a single iteration, we get the value of totalSum - setSum equal to setSum, then we can say that N is not the Zumkeller number.

FileName: ZumkellerNaive.java

// importing ArrayList
import java.util.ArrayList;
public class ZumkellerNaive
{
ArrayList<Integer> al;
void findFactors(int n)
{
int range = (int)Math.sqrt(n);
al = new ArrayList<Integer>();
// finding the factors and 
// storing it in the list al
for(int i = 1; i <= range; i++)
{
if((n % i) == 0)
{
    al.add(i);
    if((n / i) != i)
    {
        al.add(n / i);
    }
}
}
}

boolean isZumkeller()
{
int totalSum = 0;
int size = al.size();

// sum of all the factors of the number n
for(int i = 0; i < size; i++)
{
    totalSum = totalSum + al.get(i);
}

// if the sum of elements of the first set
// is equal to the sum of elements of the second set
// then it means the sum of all the elements, including the first
// and the second subset should be even. Otherwise, we can say that the 
// number is not the Zumkeller number
if((totalSum % 2) != 0)
{
    return false;
}

// for storing all the subsets
ArrayList<ArrayList<Integer>> twoDmnslAl = new ArrayList<ArrayList<Integer>>();

// for storing the current subsets
ArrayList<Integer> oneDmnslAl = new ArrayList<Integer>();

findSubsets(0, size, al, oneDmnslAl, twoDmnslAl);

// iterating over all the subsets present 
// in the two-dimensional array list
for(int i = 0; i < twoDmnslAl.size(); i++)
{
    oneDmnslAl = twoDmnslAl.get(i);
    size = oneDmnslAl.size();
    int setSum = 0;
    
    // iterating over the subset present
    // at the index i
    // the elements of the subset are 
    // considered as the first set
    // remaining elements consist of the second set
    for(int j = 0; j < size; j++)
    {
        // finding the sum of elements of the first set
        setSum = setSum + oneDmnslAl.get(j);
    }
    
    // totalSum - setSum consists of the sum of elements
    // of the second set
    if((totalSum - setSum) == setSum)
    {
        return true;
    }
}

return false;
    
}

void findSubsets(int i, int s, ArrayList<Integer> factors, ArrayList<Integer> temp, ArrayList<ArrayList<Integer>> alSubsets)
{
// handling the base case
if(i >= s)
{
    ArrayList<Integer> a = new ArrayList<Integer>();
    
    for(int j = 0; j < temp.size(); j++)
    {
        a.add(temp.get(j));
    }
    alSubsets.add(a);
    
    return;
}

// for finding the subsets
// first, we will include the element located at the index i
// and then we will exclude the element located at the index i

temp.add(factors.get(i)); // including the element 
findSubsets(i + 1, s, factors, temp, alSubsets);
temp.remove(temp.size() - 1); // excluding the element
findSubsets(i + 1, s, factors, temp, alSubsets);

    
}
// main method
public static void main(String argvs[]) 
{
// instantiating the class ZumkellerNaive
ZumkellerNaive obj = new ZumkellerNaive();
int n = 84; // first input
obj.findFactors(n);
boolean ans = obj.isZumkeller();
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}

n = 108; // second input
obj.findFactors(n);
ans = obj.isZumkeller();
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}

 n = 200; // third input

obj.findFactors(n);
ans = obj.isZumkeller();
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
}
}

Output:

Yes, 84 is a Zumkeller number.
Yes, 108 is a Zumkeller number.
No, 200 is not a Zumkeller number.

Complexity Analysis: The above program uses tree-recursion, making the time complexity of the program exponential, which is O(2f), and the space complexity of the program is also exponential, which is O(f * 2f), where f is the total number of factors of the input number n.

The space and time complexities of the above program are very high and is not suitable for those numbers which have a large number of factors. For such numbers, we may get the time limit exceeded, or the memory limit exceeded. Therefore, some optimization is required.

Approach: Using Dynamic Programming

We can do better with the help of dynamic programming. Observe the steps to solve the problem with the help of dynamic programming.

Step 1: First, check whether the sum of factors of the number N is even or not. If the sum is not even, we can conclude that the number is not the Zumkeller number.

Step 2: Declare a 2-D array dp[][] of size (sumofFactors / 2) + 1 * (size + 1), where size is the total number of factors.

Step 3: Run a for loop for 0 <= j <= size and set dp[0][j] with a true value. It is because zero-sum is always feasible.

Step 4: Using a for loop, for 1 <= j <= sumofFactors / 2 and set dp[j][0] as zero as any sum with the sum of elements as zero is not possible.

Step 5: Run a nested for loop for 1 <= k <= sumofFactors / 2 and 1 <= k <= size, and dp[j][k] equal to dp[j][k - 1]

Step 6: If j is larger than or equal to arr[k-1], if dp[j - arr[k - 1]][k - 1] is true, then assign a value true to dp[j][k].

Now, let's do the implementation of the above steps.

FileName: ZumkellerDP.java

import java.util.ArrayList; // importing ArrayList
public class ZumkellerDP
{
boolean findFactors(int n)
{
// creating an ArrayList for storing factors of n
ArrayList<Integer> al = new ArrayList<Integer>();
int range = (int)Math.sqrt(n);
// finding the factors and 
// storing it in the list al
for(int i = 1; i <= range; i++)
{
if((n % i) == 0)
{
al.add(i);
if((n / i) != i)
{
al.add(n / i);
}
}
}
int size = al.size(); // size of the array list
int factors[] = new int[size];
for(int i = 0; i < size; i++)
{
    factors[i] = al.get(i);
}
return findPartition(factors, size);
}
// Returns true if factors[] can be partitioned in two
// subsets of equal sum, otherwise false
boolean findPartition(int factors[], int size)
{
int sumOfFactor = 0;
int j, k;
// Calculate the sum of all elements
for (j = 0; j < size; j++)
{
sumOfFactor = sumOfFactor + factors[j];
}
// sumOfFactor should be even so that the number n 
// is a Zumkeller number
if (sumOfFactor % 2 != 0)
{
return false;
}
// boolean array
boolean dp[][] = new boolean[sumOfFactor / 2 + 1][size + 1];
// initializing the top row as true
for (k = 0; k <= size; k++)
{
dp[0][k] = true;
}
// initializing the leftmost column, except dp[0][0], as 0
for (j = 1; j <= sumOfFactor / 2; j++)
{
dp[j][0] = false;
}
// Filling the partition table in a bottom-up manner
for (j = 1; j <= sumOfFactor / 2; j++) 
{
for (k = 1; k <= size; k++) 
{
	dp[j][k] = dp[j][k - 1];
	if (j >= factors[k - 1])
	{
		dp[j][k] = dp[j][k] || dp[j - factors[k - 1]][k - 1];
	}
}
}

return dp[sumOfFactor / 2][size];
}

	// main method
public static void main(String argvs[]) 
{
// instantiating the class ZumkellerDP
ZumkellerDP obj = new ZumkellerDP();

int n = 84; // first input

boolean ans = obj.findFactors(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
n = 108; // second input
ans = obj.findFactors(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
n = 200; // third input

ans = obj.findFactors(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
}
}

Output:

Yes, 84 is a Zumkeller number.
Yes, 108 is a Zumkeller number.
No, 200 is not a Zumkeller number.

Complexity Analysis: The program uses a nested for-loop. The outer loops run sumOfFactors / 2 times, and the inner loop runs from 1 to size times. Thus making the time complexity of the program O(size * sumOfFactors). The space complexity of the program is also O(size * sumOfFactors) because of the two-dimensional array used in the program.

We can still do optimization to reduce the space complexity. The following program illustrates the same.

FileName: ZumkellerDP.java

import java.util.ArrayList; // importing ArrayList
public class ZumkellerDP
{
boolean isZumkeller(int n)
{
// creating an ArrayList for storing factors of n
ArrayList<Integer> al = new ArrayList<Integer>();
int range = (int)Math.sqrt(n);
// finding the factors and 
// storing it in the list al
for(int i = 1; i <= range; i++)
{
if((n % i) == 0)
{
al.add(i);
if((n / i) != i)
{
al.add(n / i);
}
}
}
int size = al.size(); // size of the array list
int factors[] = new int[size];
for(int i = 0; i < size; i++)
{
    factors[i] = al.get(i);
}
return findPartition(factors, size);
}

boolean findPartition(int factors[], int size)
{
int sumOfFactor = 0;
int j, k;
// Calculate sum of all elements
for (j = 0; j < size; j++)
{
sumOfFactor = sumOfFactor + factors[j];
}
// sumOfFactor should be even so that the number n 
// is a Zumkeller number
if (sumOfFactor % 2 != 0)
{
return false;
}
// boolean array
boolean dp[] = new boolean[sumOfFactor / 2 + 1];
// initializing all the elements with a false value
for (j = 1; j <= sumOfFactor / 2; j++)
{
dp[j] = false;
}
// Filling up in the bottom-up manner
for (j = 0; j < size; j++) 
{

// The element to be included
// in the sum cannot be
// greater than the sum
for (k = sumOfFactor / 2; k >= factors[j]; k--) 
{
// Check if sum - arr[i] could be
// formed from a subset using elements
// before index i
if (dp[k - factors[j]] == true || k == factors[j])
	dp[k] = true;
}
}
return dp[sumOfFactor / 2];
}
// main method
public static void main(String argvs[]) 
{
// instantiating the class ZumkellerDP
ZumkellerDP obj = new ZumkellerDP();

int n = 84; // first input

boolean ans = obj.isZumkeller(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
n = 108; // second input
ans = obj.isZumkeller(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
n = 200; // third input

ans = obj.isZumkeller(n);
if(ans)
{
    System.out.println("Yes, " + n + " is a Zumkeller number.");
}
else
{
    System.out.println("No, " + n + " is not a Zumkeller number.");
}
}
}

Output:

Yes, 84 is a Zumkeller number.
Yes, 108 is a Zumkeller number.
No, 200 is not a Zumkeller number.

Complexity Analysis: The time complexity of the program is the same as the previous program. The space complexity of the program is the O(sumOfFactor), where sumOfFactor is the total sum of factors of the input number n.

Finding Zumkeller Numbers Within a Range

The following program illustrates how one can find the Zumkeller numbers within a range.

FileName: ZumkellerNumbersRange.java

import java.util.ArrayList; // importing ArrayList
public class ZumkellerNumbersRange
{
boolean isZumkeller(int n)
{
// creating an ArrayList for storing factors of n
ArrayList<Integer> al = new ArrayList<Integer>();
int range = (int)Math.sqrt(n);
// finding the factors and 
// storing it in the list al
for(int i = 1; i <= range; i++)
{
if((n % i) == 0)
{
al.add(i);
if((n / i) != i)
{
al.add(n / i);
}
}
}
int size = al.size(); // size of the array list
int factors[] = new int[size];
for(int i = 0; i < size; i++)
{
    factors[i] = al.get(i);
}
return findPartition(factors, size);
}

boolean findPartition(int factors[], int size)
{
int sumOfFactor = 0;
int j, k;
// Calculate sum of all elements
for (j = 0; j < size; j++)
{
sumOfFactor = sumOfFactor + factors[j];
}
// sumOfFactor should be even so that the number n 
// is a Zumkeller number
if (sumOfFactor % 2 != 0)
{
return false;
}
// boolean array
boolean dp[] = new boolean[sumOfFactor / 2 + 1];
// initializing all the elements with a false value
for (j = 1; j <= sumOfFactor / 2; j++)
{
dp[j] = false;
}
// Filling up in the bottom-up manner
for (j = 0; j < size; j++) 
{

// The element to be included
// in the sum cannot be
// greater than the sum
for (k = sumOfFactor / 2; k >= factors[j]; k--) 
{
// Check if sum - arr[i] could be
// formed from a subset using elements
// before index i
if (dp[k - factors[j]] == true || k == factors[j])
	dp[k] = true;
}
}
return dp[sumOfFactor / 2];
}

// main method
public static void main(String argvs[]) 
{
// creating an object of the class ZumkellerNumbersRange
ZumkellerNumbersRange obj = new ZumkellerNumbersRange();

// input 1
int n = 100;

System.out.println("Zumkeller Numbers from 1 to " + n + " are:");
for(int i = 1; i <= n; i++)
{
if(obj.isZumkeller(i))
System.out.print(i + " ");
}
}
}

Output:

Zumkeller Numbers from 1 to 100 are:
6 12 20 24 28 30 40 42 48 54 56 60 66 70 78 80 84 88 90 96

Next TopicTypes of Layout Manager in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Zumkeller Numbers in Java

Example 1:

Example 2:

Example 3:

Naïve Approach

Approach: Using Dynamic Programming

Finding Zumkeller Numbers Within a Range

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA