Skip to content
Related Articles

Related Articles

Find two numbers with sum N such that neither of them contains digit K
  • Difficulty Level : Hard
  • Last Updated : 30 Sep, 2020

Given a number N and a digit K (1 < K <= 9), the task is to find two integers A and B such that A + B = N and digit K is not present in either A or B.

Examples: 

Input: N = 443, K = 4 
Output: 256, 187 
Explanation: 
Sum = 256 + 187 = 443 = N 
Also, K(4) is not present in 256 or 187 
Hence, 256 and 187 are valid output.

Input: N = 678, K = 9 
Output: 311, 367 
Explanation: 
Sum = 311 + 367 = 678 = N 
Also, K(9) is not present in 311 or 367 
Hence, 311 and 367 are valid output. 

Naive Approach: 
A simple approach is to run a loop and consider each element (say A) from 1 to N-1. Since the sum of A and B has to be N, corresponding B will be (N – A). Now check if both A and B contain K or not, if no, then print A and B. This approach will fail for larger inputs like N = 1018



Time complexity: O(N) 
Auxiliary Space: O(1)

Efficient Approach: 
The given problem can be solved much more efficiently. The idea is to break each digit D of N into two parts D1 and D2 such that D1 + D2 = D. Take two strings A and B, A will contain all D1’s, and string B will contain all D2’s. 
For example, N = 4467 and K = 4 

D    D1    D2
4    2    2
4    2    2
6    6    0
7    7    0    

Here, A will be 2267 and B will be 2200.
Detailed steps of this approach are as follows: 
1. Traverse N and consider each of its digit D
2. If digit D is same as K, break it into D1 = D / 2 and D2 = D / 2 + D % 2. 
D % 2 is added to D2 to ensure that D1 + D2 = D for both even and odd D. 
3. Else, break it into D1 = D and D2 = 0. 
4. Keep appending D1’s to string A and D2’s to string B. 
5. Finally, print string A and B, after removing leading zeros(if any).

Below is the implementation of the above approach: 

C++




// C++ implementation of
// the above approach
 
#include <iostream>
using namespace std;
 
string removeLeadingZeros(string str)
{
    // Count leading zeros
    int i = 0;
    int n = str.length();
    while (str[i] == '0' && i < n)
        i++;
 
    // It removes i characters
    // starting from index 0
    str.erase(0, i);
 
    return str;
}
 
void findPairs(int sum, int K)
{
 
    string A, B;
    A = "";
    B = "";
 
    string N = to_string(sum);
    int n = N.length();
 
    // Check each digit of the N
    for (int i = 0; i < n; i++) {
 
        int D = N[i] - '0';
 
        // If digit is K break it
        if (D == K) {
            int D1, D2;
            D1 = D / 2;
 
            // For odd numbers
            D2 = D / 2 + D % 2;
 
            // Add D1 to A and D2 to B
            A = A + char(D1 + '0');
            B = B + char(D2 + '0');
        }
 
        // If the digit is not K,
        // no need to break
        // string D in A and 0 in B
        else {
            A = A + char(D + '0');
            B = B + '0';
        }
    }
 
    // Remove leading zeros
    A = removeLeadingZeros(A);
    B = removeLeadingZeros(B);
 
    // Print the answer
    cout << A << ", " << B << endl;
}
 
// Driver code
int main()
 
{
    int N = 33673;
    int K = 3;
 
    findPairs(N, K);
 
    return 0;
}

Java




// Java implementation of the above approach
class GFG{
 
static String removeLeadingZeros(String str)
{
     
    // Count leading zeros
    int i = 0;
    int n = str.length();
     
    while (str.charAt(i) == '0' && i < n)
        i++;
 
    // It removes i characters
    // starting from index 0
    str = str.substring(i);
 
    return str;
}
 
static void findPairs(int sum, int K)
{
 
    String A, B;
    A = "";
    B = "";
 
    String N = String.valueOf(sum);
    int n = N.length();
 
    // Check each digit of the N
    for(int i = 0; i < n; i++)
    {
       int D = N.charAt(i) - '0';
        
       // If digit is K break it
       if (D == K)
       {
           int D1, D2;
           D1 = D / 2;
            
           // For odd numbers
           D2 = D / 2 + D % 2;
            
           // Add D1 to A and D2 to B
           A = A + (char)(D1 + '0');
           B = B + (char)(D2 + '0');
       }
        
       // If the digit is not K,
       // no need to break
       // String D in A and 0 in B
       else
       {
           A = A + (char)(D + '0');
           B = B + '0';
       }
    }
     
    // Remove leading zeros
    A = removeLeadingZeros(A);
    B = removeLeadingZeros(B);
 
    // Print the answer
    System.out.print(A + ", " + B + "\n");
}
 
// Driver code
public static void main(String[] args)
{
    int N = 33673;
    int K = 3;
 
    findPairs(N, K);
}
}
 
// This code is contributed by sapnasingh4991

Python3




# Python3 implementation of the
# above approach
def removeLeadingZeros(Str):
     
    # Count leading zeros
    i = 0
    n = len(Str)
       
    while (Str[i] == '0' and i < n):
        i += 1
   
    # It removes i characters
    # starting from index 0
    Str = Str[i:]
    return Str
   
def findPairs(Sum, K):
  
    A = ""
    B = ""
   
    N = str(Sum)
    n = len(N)
 
    # Check each digit of the N
    for i in range(n):
     
       D = int(N[i]) - int('0')
          
       # If digit is K break it
       if (D == K):
           D1 = D // 2;
              
           # For odd numbers
           D2 = (D // 2) + (D % 2)
 
           # Add D1 to A and D2 to B
           A = A + (str)(D1 + int('0'))
           B = B + (str)(D2 + int('0'))
            
       # If the digit is not K,
       # no need to break
       # String D in A and 0 in B
       else:
           A = A + (str)(D + int('0'))
           B = B + '0'
     
    # Remove leading zeros
    A = removeLeadingZeros(A)
    B = removeLeadingZeros(B)
   
    # Print the answer
    print(A + ", " + B)
   
# Driver code
N = 33673
K = 3
 
findPairs(N, K)
 
# This code is contributed divyeshrabadiya07

C#




// C# implementation of the above approach
using System;
 
class GFG{
  
static String removeLeadingZeros(String str)
{
      
    // Count leading zeros
    int i = 0;
    int n = str.Length;
      
    while (str[i] == '0' && i < n)
        i++;
  
    // It removes i characters
    // starting from index 0
    str = str.Substring(i);
  
    return str;
}
  
static void findPairs(int sum, int K)
{
  
    String A, B;
    A = "";
    B = "";
  
    String N = String.Join("", sum);
    int n = N.Length;
  
    // Check each digit of the N
    for(int i = 0; i < n; i++)
    {
       int D = N[i] - '0';
         
       // If digit is K break it
       if (D == K)
       {
           int D1, D2;
           D1 = D / 2;
             
           // For odd numbers
           D2 = D / 2 + D % 2;
             
           // Add D1 to A and D2 to B
           A = A + (char)(D1 + '0');
           B = B + (char)(D2 + '0');
       }
         
       // If the digit is not K,
       // no need to break
       // String D in A and 0 in B
       else
       {
           A = A + (char)(D + '0');
           B = B + '0';
       }
    }
      
    // Remove leading zeros
    A = removeLeadingZeros(A);
    B = removeLeadingZeros(B);
  
    // Print the answer
    Console.Write(A + ", " + B + "\n");
}
  
// Driver code
public static void Main(String[] args)
{
    int N = 33673;
    int K = 3;
  
    findPairs(N, K);
}
}
 
// This code is contributed by sapnasingh4991
Output: 
11671, 22002

 

Time complexity: O(M) 
Auxiliary Space: O(M) 
Here, M is the number of digits in N.
 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :