Open in App
Not now

# Minimum number to be added to all digits of X to make X > Y

• Last Updated : 08 Mar, 2022

Given two numbers X and Y of the same length, the task is to find the minimum number d that needs to be added to all the digits of X such that it becomes larger than Y.
Examples:

Input: X = 123, Y = 222
Output:
Explanation:
Add 1 to all digits of X
Then X becomes {2, 3, 4} which is
lexicographically larger than {2, 2, 2}.
Input: X = 4512, Y = 2998
Output:
Explanation:
X is already lexicographically larger than Y
so the answer will be 0.

Approach: This problem can be solved easily by breaking it into three cases

• Case 1: Find if X is already lexicographically larger than Y. If yes, then we don’t need to do anything.
• Case 2: Otherwise add (Y[0] – X[0]) to all elements of X and then check if X is lexicographically larger than Y or not.
• Case 3: If it is still not larger, then answer will be (Y[0] – X[0]) + 1 because the first elements of X become larger than first element of Y means X[0] > Y[0].

Below is the implementation of the above approach:

## C++

 `// C++ program to find Minimum number to be added` `// to all digits of X to make X > Y`   `#include ` `using` `namespace` `std;`   `// Function to check if X` `// is lexicographically larger Y` `bool` `IsLarger(``int` `X[], ``int` `Y[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// It is lexicographically larger` `        ``if` `(X[i] < Y[i]) {` `            ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Utility function to check` `// minimum value of d` `int` `solve(``int` `X[], ``int` `Y[], ``int` `n)` `{`   `    ``int` `ans = 0;` `    ``// If X is already larger` `    ``// do not need to add anything` `    ``if` `(IsLarger(X, Y, n)) {` `        ``ans = 0;` `    ``}` `    ``else` `{`   `        ``// Adding d to all elements of X` `        ``int` `d = Y[0] - X[0];`   `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``X[i] += d;` `        ``}`   `        ``// If X is larger now` `        ``// print d` `        ``if` `(IsLarger(X, Y, n)) {` `            ``ans = d;` `        ``}` `        ``// else print d + 1` `        ``else` `{` `            ``ans = d + 1;` `        ``}` `    ``}`   `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Taking the numbers as sequences` `    ``int` `X[] = { 2, 3, 6, 9 };` `    ``int` `Y[] = { 3, 4, 8, 1 };`   `    ``int` `n = ``sizeof``(X) / ``sizeof``(X[0]);` `    ``cout << solve(X, Y, n);`   `    ``return` `0;` `}`

## Java

 `// Java program to find Minimum number to be added ` `// to all digits of X to make X > Y` `import` `java.util.*;`   `class` `GFG ` `{`   `    ``// Function to check if X` `    ``// is lexicographically larger Y` `    ``static` `boolean` `IsLarger(``int``[] X,` `                            ``int``[] Y, ``int` `n) ` `    ``{` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{`   `            ``// It is lexicographically larger` `            ``if` `(X[i] < Y[i]) ` `            ``{` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Utility function to check` `    ``// minimum value of d` `    ``static` `int` `solve(``int` `X[], ``int` `Y[], ``int` `n) ` `    ``{` `        ``int` `ans = ``0``;` `        `  `        ``// If X is already larger` `        ``// do not need to add anything` `        ``if` `(IsLarger(X, Y, n))` `            ``ans = ``0``;` `        ``else` `        ``{`   `            ``// Adding d to all elements of X` `            ``int` `d = Y[``0``] - X[``0``];`   `            ``for` `(``int` `i = ``0``; i < n; i++)` `                ``X[i] += d;`   `            ``// If X is larger now` `            ``// print d` `            ``if` `(IsLarger(X, Y, n))` `                ``ans = d;`   `            ``// else print d + 1` `            ``else` `            ``{` `                ``ans = d + ``1``;` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        `  `        ``// Taking the numbers as sequences` `        ``int` `X[] = { ``2``, ``3``, ``6``, ``9` `};` `        ``int` `Y[] = { ``3``, ``4``, ``8``, ``1` `};`   `        ``int` `n = X.length;` `        ``System.out.println(solve(X, Y, n));` `    ``}` `}`   `// This code is contributed by` `// sanjeev2552`

## Python3

 `# Python3 program to find Minimum number to be added ` `# to all digits of X to make X > Y `   `# Function to check if X ` `# is lexicographically larger Y ` `def` `IsLarger(X, Y, n) :`   `    ``for` `i ``in` `range``(n) :`   `        ``# It is lexicographically larger ` `        ``if` `(X[i] < Y[i]) :` `            ``return` `False``; `   `    ``return` `True``; `   `# Utility function to check ` `# minimum value of d ` `def` `solve(X, Y, n) : `   `    ``ans ``=` `0``; ` `    `  `    ``# If X is already larger ` `    ``# do not need to add anything ` `    ``if` `(IsLarger(X, Y, n)) :` `        ``ans ``=` `0``; `   `    ``else` `:`   `        ``# Adding d to all elements of X ` `        ``d ``=` `Y[``0``] ``-` `X[``0``]; `   `        ``for` `i ``in` `range``(n) :` `            ``X[i] ``+``=` `d; `   `        ``# If X is larger now ` `        ``# print d ` `        ``if` `(IsLarger(X, Y, n)) :` `            ``ans ``=` `d; ` `        ``# else print d + 1 ` `        ``else` `:` `            ``ans ``=` `d ``+` `1``; `   `    ``return` `ans; `   `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``# Taking the numbers as sequences ` `    ``X ``=` `[ ``2``, ``3``, ``6``, ``9` `]; ` `    ``Y ``=` `[ ``3``, ``4``, ``8``, ``1` `]; `   `    ``n ``=` `len``(X); ` `    ``print``(solve(X, Y, n)); `   `# This code is contributed by AnkitRai01`

## C#

 `// C# program to find Minimum number to be.Added ` `// to all digits of X to make X > Y` `using` `System;`   `class` `GFG ` `{`   `    ``// Function to check if X` `    ``// is lexicographically larger Y` `    ``static` `bool` `IsLarger(``int``[] X,` `                            ``int``[] Y, ``int` `n) ` `    ``{` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{`   `            ``// It is lexicographically larger` `            ``if` `(X[i] < Y[i]) ` `            ``{` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Utility function to check` `    ``// minimum value of d` `    ``static` `int` `solve(``int` `[]X, ``int` `[]Y, ``int` `n) ` `    ``{` `        ``int` `ans = 0;` `        `  `        ``// If X is already larger` `        ``// do not need to.Add anything` `        ``if` `(IsLarger(X, Y, n))` `            ``ans = 0;` `        ``else` `        ``{`   `            ``// Adding d to all elements of X` `            ``int` `d = Y[0] - X[0];`   `            ``for` `(``int` `i = 0; i < n; i++)` `                ``X[i] += d;`   `            ``// If X is larger now` `            ``// print d` `            ``if` `(IsLarger(X, Y, n))` `                ``ans = d;`   `            ``// else print d + 1` `            ``else` `            ``{` `                ``ans = d + 1;` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        `  `        ``// Taking the numbers as sequences` `        ``int` `[]X = { 2, 3, 6, 9 };` `        ``int` `[]Y = { 3, 4, 8, 1 };`   `        ``int` `n = X.Length;` `        ``Console.WriteLine(solve(X, Y, n));` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`2`

Time Complexity: , where N is the length of X or Y
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles