# Find two numbers with sum N such that neither of them contains digit K

• Difficulty Level : Hard
• Last Updated : 26 May, 2021

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 strings 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 ``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`

## Javascript

 ``
Output:
`11671, 22002`

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

My Personal Notes arrow_drop_up