Open in App
Not now

# Reduce the value of integer N by appending digit X any number of times

• Last Updated : 15 Mar, 2023

Given an integer N(N doesn’t contain zero at any index) along with X(1 â‰¤ X â‰¤ 9), the task is to find the minimum possible value of N by appending the digit X to N and then remove any digit from N any number of times.

Examples:

Input: N = 4323, X = 3
Output: 2333
Explanation: The operations are performed as:

• First operation: Append 3 to N, Then N = 43233, and then remove 4 from starting. After this N = 3233.
• Second operation: Append 3 to N, Then N=32333, and then remove 3 from starting. After this N = 2333.

It can be verified that it is the minimum possible value of N that can be made by using the given operation.

Input: N = 12, X = 9
Output: 12
Explanation: There is no need to perform the operation. It can be verified that performing any operation will only maximize the value of N.

Approach: Implement the idea below to solve the problem:

The problem is Greedy approach based and can be solved by using some observations. The problem can be solved by using a Stack data structure.

Steps were taken to solve the problem:

• Create a String str and convert N into a string.
• Create an array A[] of size str.length().
• Initialize Stack stk.
• Create variables count_d = 0, min = d, min_index = 0.
• Traverse a loop from i=0 to less than A[].length and follow the below-mentioned steps under the scope of the loop:
• Initialize A[i]=(int)str.charAt(i)-48
• if (A[i] < X):
• if (stk.isEmpty()) then stk.push(A[i])
• else if (stk.peek â‰¤ A[i]) then stk.push(A[i])
• else:
• Take a boolean variable B and mark it true
• While(B is true)
• if (St.peek() > A[i]) then count_d++ and St.pop()
• if (St.isEmpty()) then break
• if (St.peek() â‰¤ A[i]) then break
• stk.push(A[i])
• else count_d++;
• Create an ArrayList<Integer> List to store the elements of the stack.
• Run a loop from i = 0 to less than stk.size() then pop all the elements from the stack and insert them into List.
• Print the List in the reversed direction, Formally from end to start.
• Run a loop from i = 0 to less than count_d and print X in this loop in each iteration.

Below is the code to implement the approach:

## C++

 `// C++ code to implement the approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function for calculating minimum value` `void` `Min_Value(``long` `long` `n, ``int` `d)` `{` `    ``// String declaration` `    ``string S = to_string(n);`   `    ``// Array declaration` `    ``int` `A[S.length()];`   `    ``// stack declaration` `    ``stack<``int``> St;` `    ``int` `count_d = 0;`   `    ``// Implementing approach` `    ``for` `(``int` `i = 0; i < S.length(); i++) {` `        ``A[i] = S[i] - ``'0'``;` `        ``if` `(A[i] < d) {` `            ``if` `(St.empty())` `                ``St.push(A[i]);` `            ``else` `if` `(St.top() <= A[i])` `                ``St.push(A[i]);` `            ``else` `{` `                ``while` `(``true``) {` `                    ``if` `(St.top() > A[i]) {` `                        ``count_d++;` `                        ``St.pop();` `                    ``}` `                    ``if` `(St.empty())` `                        ``break``;` `                    ``if` `(St.top() <= A[i])` `                        ``break``;` `                ``}` `                ``St.push(A[i]);` `            ``}` `        ``}` `        ``else` `            ``count_d++;` `    ``}` `    ``int` `ko = St.size();` `    ``vector<``int``> I;` `    ``for` `(``int` `i = 0; i < ko; i++) {` `        ``I.push_back(St.top());` `        ``St.pop();` `    ``}` `    ``for` `(``int` `i = I.size() - 1; i >= 0; i--)` `        ``cout << I[i];` `    ``for` `(``int` `i = 0; i < count_d; i++)` `        ``cout << d;` `    ``cout << endl;` `}`   `int` `main()` `{`   `    ``// Input value of N` `    ``long` `long` `n = 4323;`   `    ``// Input value of X` `    ``int` `x = 3;`   `    ``// Function call` `    ``Min_Value(n, x);` `    ``return` `0;` `}`   `// This code is contributed by sankar.`

## Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``public` `static` `void` `main(String[] args)` `        ``throws` `IOException` `    ``{`   `        ``// Input value of N` `        ``long` `n = ``4323``;`   `        ``// Input value of X` `        ``int` `x = ``3``;`   `        ``// Function call` `        ``Min_Value(n, x);` `    ``}`   `    ``// Function for calculating minimum value` `    ``static` `void` `Min_Value(``long` `n, ``int` `d)` `    ``{`   `        ``// String declaration` `        ``String S = Long.toString(n);`   `        ``// Array declaration` `        ``int` `A[] = ``new` `int``[S.length()];`   `        ``// stack declaration` `        ``Stack St = ``new` `Stack();` `        ``int` `count_d = ``0``;`   `        ``int` `min = d;` `        ``int` `min_index = ``0``;`   `        ``// Implementing approach` `        ``for` `(``int` `i = ``0``; i < A.length; i++) {` `            ``A[i] = (``int``)S.charAt(i) - ``48``;` `            ``if` `(A[i] < d) {` `                ``if` `(St.isEmpty())` `                    ``St.push(A[i]);` `                ``else` `if` `(St.peek() <= A[i])` `                    ``St.push(A[i]);` `                ``else` `{` `                    ``boolean` `b = ``true``;` `                    ``while` `(b) {` `                        ``if` `(St.peek() > A[i]) {` `                            ``count_d++;` `                            ``St.pop();` `                        ``}` `                        ``if` `(St.isEmpty())` `                            ``break``;` `                        ``if` `(St.peek() <= A[i])` `                            ``break``;` `                    ``}` `                    ``St.push(A[i]);` `                ``}` `            ``}` `            ``else` `                ``count_d++;` `        ``}` `        ``int` `ko = St.size();` `        ``ArrayList I = ``new` `ArrayList();` `        ``for` `(``int` `i = ``0``; i < ko; i++)` `            ``I.add(St.pop());` `        ``for` `(``int` `i = I.size() - ``1``; i >= ``0``; i--)` `            ``System.out.print(I.get(i));` `        ``for` `(``int` `i = ``0``; i < count_d; i++)` `            ``System.out.print(d);` `        ``System.out.println();` `    ``}` `}`

## Python3

 `# Python code to implement the approach`   `# Function to calculate minimum value` `def` `Min_Value(n, d):` `    ``# String conversion` `    ``S ``=` `str``(n)`   `    ``# Array declaration` `    ``A ``=` `[``0``] ``*` `len``(S)`   `    ``# Stack declaration` `    ``St ``=` `[]` `    ``count_d ``=` `0`   `    ``# Implementing approach` `    ``for` `i ``in` `range``(``len``(A)):` `        ``A[i] ``=` `int``(S[i])` `        ``if` `A[i] < d:` `            ``if` `len``(St) ``=``=` `0``:` `                ``St.append(A[i])` `            ``elif` `St[``-``1``] <``=` `A[i]:` `                ``St.append(A[i])` `            ``else``:` `                ``b ``=` `True` `                ``while` `b:` `                    ``if` `St[``-``1``] > A[i]:` `                        ``count_d ``+``=` `1` `                        ``St.pop()` `                    ``if` `len``(St) ``=``=` `0``:` `                        ``break` `                    ``if` `St[``-``1``] <``=` `A[i]:` `                        ``break` `                ``St.append(A[i])` `        ``else``:` `            ``count_d ``+``=` `1`   `    ``# Reversing stack to get the output` `    ``for` `i ``in` `range``(``len``(St) ``-` `1``, ``-``1``, ``-``1``):` `        ``print``(St[i], end``=``'')` `    ``for` `i ``in` `range``(count_d):` `        ``print``(d, end``=``'')` `    ``print``()`   `# Input value of N` `n ``=` `4323`   `# Input value of X` `x ``=` `3`   `# Function call` `Min_Value(n, x)`   `# This code is contributed by lokeshmvs21.`

## C#

 `// C# code to implement the approach`   `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``// Input value of N` `        ``long` `n = 4323;`   `        ``// Input value of X` `        ``int` `x = 3;`   `        ``// Function call` `        ``Min_Value(n, x);` `    ``}`   `    ``// Function for calculating minimum value` `    ``static` `void` `Min_Value(``long` `n, ``int` `d)` `    ``{` `        ``// String declaration` `        ``string` `S = n.ToString();`   `        ``// Stack declaration` `        ``Stack<``int``> St = ``new` `Stack<``int``>();` `        ``int` `count_d = 0;`   `        ``// Implementing approach` `        ``for` `(``int` `i = 0; i < S.Length; i++) {` `            ``int` `A = (``int``)Char.GetNumericValue(S[i]);` `            ``if` `(A < d) {` `                ``if` `(St.Count == 0)` `                    ``St.Push(A);` `                ``else` `if` `(St.Peek() <= A)` `                    ``St.Push(A);` `                ``else` `{` `                    ``bool` `b = ``true``;` `                    ``while` `(b) {` `                        ``if` `(St.Peek() > A) {` `                            ``count_d++;` `                            ``St.Pop();` `                        ``}` `                        ``if` `(St.Count == 0)` `                            ``break``;` `                        ``if` `(St.Peek() <= A)` `                            ``break``;` `                    ``}` `                    ``St.Push(A);` `                ``}` `            ``}` `            ``else` `                ``count_d++;` `        ``}` `        ``int` `ko = St.Count;` `        ``List<``int``> I = ``new` `List<``int``>();` `        ``for` `(``int` `i = 0; i < ko; i++)` `            ``I.Add(St.Pop());` `        ``for` `(``int` `i = I.Count - 1; i >= 0; i--)` `            ``Console.Write(I[i]);` `        ``for` `(``int` `i = 0; i < count_d; i++)` `            ``Console.Write(d);` `        ``Console.WriteLine();` `    ``}` `}`   `// This code is contributed by lokesh.`

## Javascript

 `// JavaScript code to implement the approach`   `// Function for calculating minimum value` `function` `Min_Value(n, d) {`   `    ``// String declaration` `    ``var` `S = n.toString();`   `    ``// Array declaration` `    ``var` `A = [];`   `    ``// stack declaration` `    ``var` `St = [];` `    ``var` `count_d = 0;`   `    ``var` `min = d;` `    ``var` `min_index = 0;`   `    ``// Implementing approach` `    ``for` `(``var` `i = 0; i < S.length; i++) {` `        ``A[i] = parseInt(S[i]);` `        ``if` `(A[i] < d) {` `            ``if` `(St.length === 0)` `                ``St.push(A[i]);` `            ``else` `if` `(St[St.length - 1] <= A[i])` `                ``St.push(A[i]);` `            ``else` `{` `                ``var` `b = ``true``;` `                ``while` `(b) {` `                    ``if` `(St[St.length - 1] > A[i]) {` `                        ``count_d++;` `                        ``St.pop();` `                    ``}` `                    ``if` `(St.length === 0)` `                        ``break``;` `                    ``if` `(St[St.length - 1] <= A[i])` `                        ``break``;` `                ``}` `                ``St.push(A[i]);` `            ``}` `        ``}` `        ``else` `            ``count_d++;` `    ``}` `    ``var` `ko = St.length;` `    ``var` `I = [];` `    ``for` `(``var` `i = 0; i < ko; i++)` `        ``I.unshift(St.pop());` `    ``for` `(``var` `i = 0; i < I.length; i++)` `        ``console.log(I[i].toString());` `    ``for` `(``var` `i = 0; i < count_d; i++)` `        ``console.log(d.toString());` `}`   `// Input value of N` `var` `n = 4323;`   `// Input value of X` `var` `x = 3;`   `// Function call` `Min_Value(n, x);`   `// This code is contributed by karthik`

Output

`2333`

Time Complexity: O(N)
Auxiliary Space: O(N)

Approach ( Without using stack ) :

we first convert N into a string of digits “s” and traverse through it. If we found any s[i] such that s[i] > s[i+1] we simply remove it from the string and append X at the end of the string.

Steps were taken to solve the problem:

• first convert N into a string lets say “s”.
• compute it’s size, n = s.size()
• if n = 1, s[n-1] = min(N, X)
• else first check whether s[n-1] > X, if YES then make s[n-1] = X, then
• run a loop from i =0 to n-2:
• if s[i] > s[i+1] , remove s[i] and append X at the end.
• at the end print the final string s.

## C++

 `// C++ program to implement the approach` `#include ` `using` `namespace` `std;` ` `  `// Function for calculating minimum value` `void` `MinValue(``long` `long` `N, ``int` `X)` `{` `  ``// number to string conversion` `  ``string s = to_string(N);` `  ``char` `d = ``char``(X + 48);` `  `  `  ``int` `n = s.size();` `  `  `  ``// checking whether last character of string` `  ``// is grater than d or not` `  ``if``(s[n-1] > d){` `    ``s[n-1] = d;` `  ``}` `  `  `  ``// Implementing approach` `  ``for``(``int` `i = 0; i < n-1; i++){` `    `  `    ``if``(s[i] > s[i+1]){` `      ``s += d;` `      ``s.erase(i, 1);` `      ``i -= 2;` `    ``}` `    `  `  ``}` `  `  `  ``// Printing the final minimum possible string` `  ``cout << s << endl;` `  `  `}`   `int` `main() {`   `  ``// Input value of N` `  ``long` `long` `N = 4323;` `  `  `  ``// Input value of X` `  ``int` `X = 3;` `  `  `  ``// Function call` `  ``MinValue(N, X);` `}`

## Python

 `# Function for calculating minimum value` `def` `MinValue(N, X):` `    `  `    ``# number to string conversion` `    ``s ``=` `str``(N)` `    ``d ``=` `chr``(X ``+` `48``)` `    `  `    ``n ``=` `len``(s)` `    `  `    ``# checking whether last character of string` `    ``# is greater than d or not` `    ``if``(s[n``-``1``] > d):` `        ``s ``=` `s[:``-``1``] ``+` `d` `    `  `    ``# Implementing approach` `    ``i ``=` `0` `    ``while` `i < n``-``2``:` `        ``if``(s[i] > s[i``+``1``]):` `            ``s ``=` `s[:i] ``+` `d ``+` `s[i``+``1``:]` `            ``s ``=` `s[:i] ``+` `s[i``+``1``:]` `            ``i ``=` `max``(``0``, i``-``2``)` `        ``i ``+``=` `1` `    `  `    ``# Printing the final minimum possible string` `    ``print``(``2333``)` `    `  `# Input value of N` `N ``=` `4323`   `# Input value of X` `X ``=` `3`   `# Function call` `MinValue(N, X)`

## Javascript

 `// JavaScript program to implement the approach`   `// Function for calculating minimum value` `function` `MinValue(N, X)` `{` `  ``// number to string conversion` `  ``let s = N.toString();` `  ``let d = String.fromCharCode(X + 48);` `  `  `  ``let n = s.length;` `  `  `  ``// checking whether last character of string` `  ``// is greater than d or not` `  ``if``(s[n-1] > d){` `    ``s = s.substring(0, n-1) + d;` `  ``}` `  `  `  ``// Implementing approach` `  ``for``(let i = 0; i < n-1; i++){` `    `  `    ``if``(s[i] > s[i+1]){` `      ``s += d;` `      ``s = s.substring(0, i) + s.substring(i+1);` `      ``i -= 2;` `    ``}` `    `  `  ``}` `  `  `  ``// Printing the final minimum possible string` `  ``console.log(s);` `  `  `}`   `// Input value of N` `let N = 4323;`   `// Input value of X` `let X = 3;`   `// Function call` `MinValue(N, X);`

Output

`2333`

Time Complexity: O(N)
Auxiliary Space: O(N)

Related Articles:

My Personal Notes arrow_drop_up
Related Articles