Partition a number into two divisible parts

Given a numeric string s and two integers a and b.

Split s into two non-empty parts such that:

The integer represented by the first part is divisible by a, and
The integer represented by the second part is divisible by b.

If multiple valid splits exist, return the one in which the first part has the minimum possible length. If no valid split exists, return -1.

Examples:

Input: s = "1200", a = 4, b = 3
Output: "12 00"
Explanation: 12 is divisible by 4, and 00 is divisible by 3.
Input: s= "125", a = 12, b = 5
Output: "12 5"
Explanation: 12 is divisible by 12, and 5 is divisible by 5.

Try It Yourself

Table of Content

[Naive Approach] Direct Split Check - O(n²) Time and O(1) Space
[Expected Approach] Prefix-Suffix Remainder - O(n) Time and O(n) Space

[Naive Approach] Direct Split Check - O(n²) Time and O(1) Space

Try every possible split position. For each split, compute remainder of left part modulo a and remainder of right part modulo b using digit-by-digit processing. Return first valid split.

Iterate split from 1 to n-1
Compute remainder of first split digits modulo a
If remainder is not zero, skip to next split
Compute remainder of remaining digits modulo b
If remainder is zero, return two parts separated by space
Return -1 if no valid split found

C++

#include <iostream>
#include <string>
using namespace std;

string stringPartition(string &s, int a, int b) {

    int n = s.size();

    for (int split = 1; split < n; split++) {

        int remA = 0;
        
        // Calculate remainder of left part modulo a
        for (int i = 0; i < split; i++)
            remA = (remA * 10 + (s[i] - '0')) % a;

        if (remA != 0)
            continue;

        int remB = 0;
        
        // Calculate remainder of right part modulo b
        for (int i = split; i < n; i++)
            remB = (remB * 10 + (s[i] - '0')) % b;

        if (remB == 0)
            return s.substr(0, split) + " " + s.substr(split);
    }

    return "-1";
}

int main() {

    string s = "1236";
    int a = 12, b = 3;

    cout << stringPartition(s, a, b);

    return 0;
}

Java

class GFG {
    
    static String stringPartition(String s, int a, int b) {
        int n = s.length();
        
        for (int split = 1; split < n; split++) {
            int remA = 0;
            
            // Calculate remainder of left part modulo a
            for (int i = 0; i < split; i++) {
                remA = (remA * 10 + (s.charAt(i) - '0')) % a;
            }
            
            if (remA != 0)
                continue;
            
            int remB = 0;
            
            // Calculate remainder of right part modulo b
            for (int i = split; i < n; i++) {
                remB = (remB * 10 + (s.charAt(i) - '0')) % b;
            }
            
            if (remB == 0)
                return s.substring(0, split) + " " + s.substring(split);
        }
        
        return "-1";
    }
    
    public static void main(String[] args) {
        String s = "1236";
        int a = 12, b = 3;
        
        System.out.println(stringPartition(s, a, b));
    }
}

Python

def stringPartition(s, a, b):
    n = len(s)
    
    for split in range(1, n):
        remA = 0
        
        # Calculate remainder of left part modulo a
        for i in range(split):
            remA = (remA * 10 + int(s[i])) % a
        
        if remA != 0:
            continue
        
        remB = 0
        
        # Calculate remainder of right part modulo b
        for i in range(split, n):
            remB = (remB * 10 + int(s[i])) % b
        
        if remB == 0:
            return s[:split] + " " + s[split:]
    
    return "-1"

# Driver code
if __name__ == "__main__":
    s = "1236"
    a, b = 12, 3
    
    print(stringPartition(s, a, b))

using System;

class GFG {
    
    static string stringPartition(string s, int a, int b) {
        int n = s.Length;
        
        for (int split = 1; split < n; split++) {
            int remA = 0;
            
            // Calculate remainder of left part modulo a
            for (int i = 0; i < split; i++) {
                remA = (remA * 10 + (s[i] - '0')) % a;
            }
            
            if (remA != 0)
                continue;
            
            int remB = 0;
            
            // Calculate remainder of right part modulo b
            for (int i = split; i < n; i++) {
                remB = (remB * 10 + (s[i] - '0')) % b;
            }
            
            if (remB == 0)
                return s.Substring(0, split) + " " + s.Substring(split);
        }
        
        return "-1";
    }
    
    static void Main(string[] args) {
        string s = "1236";
        int a = 12, b = 3;
        
        Console.WriteLine(stringPartition(s, a, b));
    }
}

JavaScript

function stringPartition(s, a, b) {
    const n = s.length;
    
    for (let split = 1; split < n; split++) {
        let remA = 0;
        
        // Calculate remainder of left part modulo a
        for (let i = 0; i < split; i++) {
            remA = (remA * 10 + parseInt(s[i])) % a;
        }
        
        if (remA !== 0)
            continue;
        
        let remB = 0;
        
        // Calculate remainder of right part modulo b
        for (let i = split; i < n; i++) {
            remB = (remB * 10 + parseInt(s[i])) % b;
        }
        
        if (remB === 0)
            return s.substring(0, split) + " " + s.substring(split);
    }
    
    return "-1";
}

// Driver code
const s = "1236";
const a = 12, b = 3;

console.log(stringPartition(s, a, b));

Output

12 36

[Expected Approach] Prefix-Suffix Remainder - O(n) Time and O(n) Space

Precompute prefix remainders modulo a and suffix remainders modulo b. Find first split where prefix remainder is 0 and suffix remainder is 0.

Compute prefix[i] as remainder of first i+1 digits modulo a
Compute suffix[i] as remainder of digits from i to end modulo b
Traverse split from 1 to n-1
If prefix[split-1] == 0 and suffix[split] == 0, return two parts
Return -1 if no valid split found

C++

#include <iostream>
#include <string>
#include <vector>
using namespace std;

string stringPartition(string &s, int a, int b) {

    int n = s.size();

    // prefix[i] = remainder of s[0...i] when divided by a
    vector<int> prefix(n);
    prefix[0] = (s[0] - '0') % a;
    for (int i = 1; i < n; i++)
        prefix[i] = (prefix[i - 1] * 10 + (s[i] - '0')) % a;

    // suffix[i] = remainder of s[i...n-1] when divided by b
    vector<int> suffix(n);
    suffix[n - 1] = (s[n - 1] - '0') % b;

    int p10 = 1;
    for (int i = n - 2; i >= 0; i--) {
        p10 = (p10 * 10) % b;
        suffix[i] = ((s[i] - '0') * p10 + suffix[i + 1]) % b;
    }

    // Find the first valid split
    for (int i = 1; i < n; i++) {
        if (prefix[i - 1] == 0 && suffix[i] == 0)
            return s.substr(0, i) + " " + s.substr(i);
    }

    return "-1";
}

int main()
{

    string s = "1236";
    int a = 12, b = 3;

    cout << stringPartition(s, a, b);

    return 0;
}