 GeeksforGeeks App
Open App Browser
Continue

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

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);``}`

## Java

 `// Java program to implement the approach` `import` `java.io.*;``import` `java.util.*;` `public` `class` `Main {` `    ``// Function for calculating minimum value``    ``public` `static` `void` `MinValue(``int` `N,``int` `X)``    ``{``      ``// number to string conversion``      ``String s = String.valueOf(N);``      ``char` `d = (``char``)(X + ``48``);` `      ``int` `n = s.length();` `      ``// checking whether last character of string``      ``// is greater than d or not``      ``if``(s.charAt(n-``1``) > d){``        ``s = s.substring(``0``, n-``1``) + d;``      ``}` `      ``// Implementing approach``      ``for``(``int` `i = ``0``; i < n-``1``; i++){` `        ``if``(i >=``0` `&& s.charAt(i) > s.charAt(i+``1``)){``          ``s += d;``          ``s = s.substring(``0``, i) + s.substring(i+``1``);``          ``i -= ``2``;``        ``}` `      ``}` `      ``// Printing the final minimum possible string``      ``System.out.println(s);` `    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``// Input value of N``        ``int` `N = ``4323``;` `        ``// Input value of X``        ``int` `X = ``3``;` `        ``// Function call``        ``MinValue(N, X);``    ``}``}``// This code is contributed by Arushi Jindal.`

## 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);`

## C#

 `using` `System;` `class` `MainClass {``  ``// Function for calculating minimum value``  ``public` `static` `void` `MinValue(``int` `N, ``int` `X) {``    ``// number to string conversion``    ``string` `s = N.ToString();``    ``char` `d = (``char``)(X + 48);` `    ``int` `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``(``int` `i = 0; i < n-1; i++) {``      ``if``(i >=0 && 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.WriteLine(s);``  ``}` `  ``public` `static` `void` `Main(``string``[] args) {``    ``// Input value of N``    ``int` `N = 4323;` `    ``// Input value of X``    ``int` `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