Split the Number String into Primes in Java

A string is given that is made only of digits, such that the string represents a number. Our task is to split the number string in such a way that each segment of the number that is formed after the split is a prime number. Also, we have to take care to minimize the number of splits. Note that if the input string itself represents a prime number, then the minimum split is 1 as we are taking it as a whole. The prime numbers found have to be in the range of 1 to 10 ^ 6. Let's understand it with the help of a few examples.

Example 1:

Input: "13477317"

Output: 2

Explanation: If we take 1 split, then we have to take 13477317 as a whole, and the number 13477317 is divisible by 3. Hence, 1 split is not possible. Now, we take 2 splits, and we see that 13477 is a prime number and 317 is also a prime number. Thus, in 2 splits, we got all the segments as prime numbers.

Example 2:

Input: "17"

Output: 1

Explanation: If we take 1 split, then we have to take 17 as a whole, and the number 13477317 is a prime number. Hence, 1 split will suffice.

Let's see different approaches to find the splits.

Using Recursion

The concept is to take into consideration each prefix up to 6 digits (as it is already known that the prime numbers are < 10 ^ 6) and validate whether it is a prime number or not. If it is a prime number, then recursively invoke the method to validate the string that is remaining. If any of the combinations do not give the appropriate arrangement, then an appropriate message is shown on the console.

FileName: SplitStringPrimes.java

// import statement
import java.util.*;
public class SplitStringPrimes
{
// method for checking whether the  
// string num is a prime number 
// or not
public boolean isPrime(String num)
{
int no = Integer.valueOf(num);
for (int j = 2; j * j <= no; j++)
{
if ((no % j) == 0)
{
// apart from 1 and the number itself
// a factor is found. Hence, the answer
// is false
return false;
}
}
// if the control reaches here it means the number is 
// a prime number
return true;
}
// A recursive method for looking after the minimum number
// of segments of the string str such that each segment 
// is a prime
public int splitIntoPrimes(String str)
{
// If there is no number in the string str
if (str.length() == 0)
{
return 0;
}

// isPrime() method is invoked to check whether the
// number is a prime or not.
if (str.length() <= 6 && isPrime(str))
{
return 1;
}

else 
{
int numLength = str.length();

// A large number for denoting the maximum
int answer = 1000000;

// as the maximum input number is 10 ^ 7 which is not 
// a prime number therefore the maximum number of digits present
// in a prime number is 6
for (int j = 1; j <= 6 && j <= numLength; j++) 
{
if (isPrime(str.substring(0, j))) 
{

// Recursively invoke the method
// for checking the rest of the string
int value = splitIntoPrimes(str.substring(j));
if (value != -1) 
{

// computing the minimum splits
// into the Primes for the suffix
answer = Math.min(answer, 1 + value);
}
}
}

// Checking whether the combination is found
if (answer == 1000000)
{
return -1;
}
return answer;
}
}

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

String inputStr = "343";

int ans = obj.splitIntoPrimes(inputStr);

if(ans != -1)
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
else
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
inputStr = "37";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
else
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");

inputStr = "44";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
else
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");

inputStr = "367555";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}

}
}

Output:

For the number 343, the minimum number of splits is: 2
For the number 37, the minimum number of splits is: 1
For the number 44, the minimum number of splits is not possible.
For the number 367555, the minimum number of splits is: 4

Complexity Analysis

The time complexity of the above program is O(N^{5 / 2}), where O(N²) time is taken to recursively find all the possible combinations. As we also have to check whether the number is prime or not, and this task takes the time complexity of O(N^{1 / 2}). Thus, the total time complexity of the above program is O(N²) * O(N^{1 / 2}) = O(N^{5 / 2}), where N is the total number of digits present in the input string.

Using Iteration

Using iteration, one can solve the problem with the help of dynamic programming.

We can define an array splitArr[] and use it where splitArr[q] represents the minimum number of splits that are required in the prefix string of the length 'q' to split it into the subdivision of prime.

The array splitArr[] is getting filled in the following manner:

A loop is used for iterating through all of the indices of the input string.
For each index 'q' from the above loop, another loop begins from 1 to 6 to check whether the substring from the (p + q)th index makes a prime number or not.
If a prime number is formed, then the value at the array splitArr[] can be updated as: splitArr [p + q] = min(splitArr[p + q], 1 + splitArr[p]);

When all of the values are updated, the value present at the last index is our answer as it contains the least splits number for the complete input string.

FileName: SplitStringPrimes1.java

// important import statement
import java.util.*;

public class SplitStringPrimes1
{

// a method for checking whether the input string num is a
// prime number or not
public boolean isPrime(String num)
{
if(num.length() == 0)
{
return true;
}
int nmbr = Integer.parseInt(num);
for (int i = 2; i * i <= nmbr; i++)
{
// we have found a number that divides the nmbr
// completely. Also, that number is not equal to 
// 1 or nmbr. Hence, the number nmbr is not a prime number.
if ((nmbr % i) == 0)
{
return false;
}
}

// if the control reaches here, then the number nmbr is a prime number		
return true;
}

// A method that finds the minimum number
// of splits such that each segment that is formed after the split
// of the input String represents a prime number
public int splitIntoPrimes(String num)
{
int numLength = num.length();

// Declaring an array splitArr[]
// and initializing it to -1
int splitArr[] = new int[numLength + 1];
Arrays.fill(splitArr, -1);

// Building the table in the
// bottom-up manner
for (int j = 1; j <= numLength; j++) 
{

// At first, we check whether the entire prefix is a prime number or not
if (j <= 6 && isPrime(num.substring(0, j)))
{
splitArr[j] = 1;
}

// If it is possible to split into Primes, then
// then check for the remaining String from j to i
// if prime or not. If yes, then compute the minimum split 
// untill i
if (splitArr[j] != -1) 
{
for (int i = 1; i <= 6 && j + i <= numLength; i++) 
{

// checking whether the sub string from j to i
// is the prime number or not
if (isPrime(num.substring(j, j + i))) 
{

// If it is a prime, then update the split array
if (splitArr[j + i] == -1)
{
splitArr[j + i] = 1 + splitArr[j];
}
else
{
splitArr[j + i] = Math.min(splitArr[j + i], 1 + splitArr[j]);
}
}
}
}
}

// Returning the least number of splits
// for the complete input String
return splitArr[numLength];
}

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

String inputStr = "343";

int ans = obj.splitIntoPrimes(inputStr);

if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}
inputStr = "37";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}

inputStr = "44";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}

inputStr = "367555";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}
}
}

Output:

For the number 343, the minimum number of splits is: 2
For the number 37, the minimum number of splits is: 1
For the number 44, the minimum number of splits is not possible. 
For the number 367555, the minimum number of splits is: 4

Complexity Analysis

The time complexity of the above program is O(N^{3 / 2}), where O(N) time is taken to traverse through all the indices. We also have to check whether the number is prime or not, and this task takes the time complexity of O(N^{1 / 2}). Thus, the total time complexity of the above program is O(N) * O(N^{1 / 2}) = O(N^{3 / 2}), where N is the total number of digits present in the input string.

We know that the prime numbers range from 1 to 10 ^ 6 in this problem. We can use this information for further optimization. Further optimization is possible when we precompute the checks of the prime number and store it in an array. The precomputation is possible with the help of the sieve of the Eratosthenes technique. Observe the following program.

FileName: SplitStringPrimes2.java

// important import statement
import java.util.*;

public class SplitStringPrimes2
{

// method for precomputing all of the primes
// upto 1000000 and keep it in the hash set
// using the technique of Sieve of Eratosthenes
public void retrievePrimesFromSeive(HashSet<String> hashSetPrm)
{
boolean []primeArr = new boolean[1000001];
Arrays.fill(primeArr, true);
primeArr[0] = primeArr[1] = false;

for (int j = 2; j * j <= 1000000; j++) 
{
if (primeArr[j] == true) 
{
// multiple of a number can never be a prime number
// for example, 2 is a prime number. However, 4, 6, 8, 10, ... 
// are not prime numbers as they are multiple of 2
for (int i = j * j; i <= 1000000; i += j)
{
primeArr[i] = false;
}
}
}

// first converting the prime numbers into string
// and then adding it to the hash set
for (int i = 2; i <= 1000000; i++) 
{
if (primeArr[i] == true)
{
hashSetPrm.add(String.valueOf(i));
}
}
}

// A method that finds the minimum number
// of splits such that each segment that is formed after the split
// of the input String represents a prime number

public int splitIntoPrimes(String num)
{
int numLength = num.length();

// Declaring an array splitArr[]
// and initializing it to -1
int splitArr[] = new int[numLength + 1];
Arrays.fill(splitArr, -1);


// invoking the sieve method in order to keep the prime numbers in
// the hash set
HashSet<String> hashSetPrm = new HashSet<String>();

retrievePrimesFromSeive(hashSetPrm);

// Building the dynamci programming table in the bottom-up manner
for (int j = 1; j <= numLength; j++) 
{

// If prefix is the prime number then prefix found will be
// will be there in the hash set
if (j <= 6 && (hashSetPrm.contains(num.substring(0, j))))
splitArr[j] = 1;

// If the Given Prefix can be split into Primes
// then check for the remaining String from i to j
// Check if Prime. If yes calculate
// the minimum split till j
if (splitArr[j] != -1) 
{
for (int i = 1; i <= 6 && j + i <= numLength; i++) 
{

// Checking whether the sub String from j to i
// is the prime number or not
if (hashSetPrm.contains(num.substring(j, j + i))) 
{

// If prime is found, then split array has to be updated
if (splitArr[i + j] == -1)
{
splitArr[i + j] = 1 + splitArr[j];
}
else
{
splitArr[i + j] = Math.min(splitArr[i + j], 1 + splitArr[j]);
}
}
}
}
}

// Returning the least number of splits
// for the complete input String
return splitArr[numLength];

}

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

String inputStr = "343";

int ans = obj.splitIntoPrimes(inputStr);

if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of split is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of split is not possible. \n");
}
inputStr = "37";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}

inputStr = "44";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}
inputStr = "367555";
ans = obj.splitIntoPrimes(inputStr);
if(ans != -1)
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is: " + ans + "\n");
}
else
{
System.out.print("For the number " + inputStr + ", the minimum number of splits is not possible. \n");
}

}
}

Output:

For the number 343, the minimum number of split is: 2
For the number 37, the minimum number of split is: 1
For the number 44, the minimum number of split is not possible. 
For the number 367555, the minimum number of split is: 4

Complexity Analysis

It is the most optimized approach as the time complexity of the above program is O(N), where N is the total number of digits present in the input string. Though the time complexity of computing the sieve is O(N * log(N)), we can ignore it as it is computed only once. Thus, unlike other programs, we can check whether a number is a prime number or not in just O(1) time.

Next TopicJava Cron Expression

← prev next →