# Convert a number of length N such that it contains any one digit at least ‘K’ times

• Last Updated : 26 Aug, 2022

Given the value ‘N’ which is the length of a number ‘A’. Your task is to convert the digits such that at least ‘K’ times in the number ‘A’ any digit exists. In order to replace one of ‘N’ digits, you also need to calculate the cost, which is the absolute difference between the old digit and the new one. The task is to print the minimum cost it took to convert the initial number to the final number and also print the final number.
Note: If there are several such numbers, then print the lexicographically minimum one.

Examples:

Input: N = 6, K = 5, A = 898196
Output: 4, 888188
Number = “898196”, the second digit “9” will be replaced by “8” costs |9 – 8| = 1 . Replacing the fifth digit with an “8” will cost the same. Replacing the fifth digit cost |6 – 8| = 2. As a result, 4 will be the total cost and the final number will be “888188”.

Input: N = 16, K = 14, A = 6124258626539246
Output: 22, 4444448444449444

Approach:

1. Initialize a number ‘A’ of length ‘N’.
2. Initialize a PAIR STL to store the minimum cost and Number.
3. Store the number as a string in the temp variable.
4. Using two for loop checks all the digits with a difference of ‘j’ and replace them with ‘i’, break if the cost is achieved.
5. Replace the minimum cost with the previous one.
6. Finally, print the minimum cost and the final number.

Below is the implementation of the above approach:

## C++

 `// C++ program to illustrate``// the above problem``#include ``using` `namespace` `std;` `// function to calculate the minimum``// value and the final number``int` `finalNumber(``int` `n, ``int` `k, string a)``{``    ``// modtemp = modified temp string``    ``int` `modtemp;` `    ``// store the count of numbers changed to k``    ``int` `co;` `    ``// temporary temp string``    ``string temp;` `    ``// To store the minimum cost and no``    ``pair<``int``, string> ans = make_pair(INT_MAX, ``""``);` `    ``for` `(``int` `i = 0; i < 10; i++) {``        ``// 'i' will replace the digits of N's to``        ``// generate a number with k same digits` `        ``// store the main str in temp str for modification``        ``temp = a;` `        ``// To store the temporary value of the modified number``        ``modtemp = 0;` `        ``// Initial count for the given number to replace 'i'``        ``co = count(a.begin(), a.end(), i + ``'0'``);` `        ``// 'j' manages the difference 'i' and 'j'``        ``for` `(``int` `j = 1; j < 10; j++) {` `            ``// For the elements ahead of 'i' index``            ``if` `(i + j < 10) {` `                ``// Checks all elements with difference 'j'``                ``// and replaces them with 'i'``                ``for` `(``int` `p = 0; p < n; p++) {` `                    ``// Break if count is achieved``                    ``if` `(co >= k)``                        ``break``;` `                    ``if` `(i + ``'0'` `== temp[p] - j) {` `                        ``// Replaces all elements with difference``                        ``// 'j' and with 'i'``                        ``temp[p] = i + ``'0'``;``                        ``modtemp += j;``                        ``co++;``                    ``}``                ``}``            ``}``            ``// For the elements before 'i' index``            ``if` `(i - j >= 0) {``                ``for` `(``int` `p = n - 1; p >= 0; p--) {``                    ``if` `(co >= k)``                        ``break``;` `                    ``if` `(i + ``'0'` `== temp[p] + j) {``                        ``temp[p] = i + ``'0'``;``                        ``modtemp += j;``                        ``co++;``                    ``}``                ``}``            ``}``        ``}` `        ``// replace the minimum cost with the previous one``        ``ans = min(ans, make_pair(modtemp, temp));``    ``}``    ``// print the minimum cost and the final number``    ``cout << ans.first << endl``         ``<< ans.second << endl;``}` `// Driver code``int` `main()``{``    ``// initialize number length and k``    ``int` `n = 5, k = 4;` `    ``// initialize the number``    ``string a = ``"21122"``;` `    ``finalNumber(n, k, a);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``class` `GFG``{``    ``static` `class` `pair``    ``{``        ``int` `first;``        ``String second;``        ``static` `pair make_pair(``int` `first, String second)``        ``{``            ``pair p = ``new` `pair();``            ``p.first = first;``            ``p.second = second;``            ``return` `p;``        ``}``    ``}``    ` `// count for the given character``static` `int` `count(String a,``char` `c)``{``    ``int` `co = ``0``;``    ``for``(``int` `i = ``0``; i < a.length(); i++)``    ``if``(a.charAt(i) == c)``        ``co++;``    ``return` `co;``}` `// function to calculate the minimum``// value and the final number``static` `int` `finalNumber(``int` `n, ``int` `k, String a)``{``    ``// modtemp = modified temp String``    ``int` `modtemp;` `    ``// store the count of numbers changed to k``    ``int` `co;` `    ``// temporary temp String``    ``char` `temp[] = ``new` `char``[a.length()];` `    ``// To store the minimum cost and no``    ``pair ans = pair.make_pair(Integer.MAX_VALUE, ``""``);` `    ``for` `(``int` `i = ``0``; i < ``10``; i++)``    ``{``        ``// 'i' will replace the digits of N's to``        ``// generate a number with k same digits` `        ``// store the main str in temp str for modification``        ``temp = a.toCharArray();` `        ``// To store the temporary value of the modified number``        ``modtemp = ``0``;` `        ``// Initial count for the given number to replace 'i'``        ``co = count(a, (``char``)(i + ``'0'``));` `        ``// 'j' manages the difference 'i' and 'j'``        ``for` `(``int` `j = ``1``; j < ``10``; j++)``        ``{` `            ``// For the elements ahead of 'i' index``            ``if` `(i + j < ``10``)``            ``{` `                ``// Checks all elements with difference 'j'``                ``// and replaces them with 'i'``                ``for` `(``int` `p = ``0``; p < n; p++)``                ``{` `                    ``// Break if count is achieved``                    ``if` `(co >= k)``                        ``break``;` `                    ``if` `(i + ``'0'` `== temp[p] - j)``                    ``{` `                        ``// Replaces all elements with difference``                        ``// 'j' and with 'i'``                        ``temp[p] = (``char``)(i + ``'0'``);``                        ``modtemp += j;``                        ``co++;``                    ``}``                ``}``            ``}``            ` `            ``// For the elements before 'i' index``            ``if` `(i - j >= ``0``)``            ``{``                ``for` `(``int` `p = n - ``1``; p >= ``0``; p--)``                ``{``                    ``if` `(co >= k)``                        ``break``;` `                    ``if` `(i + ``'0'` `== temp[p] + j)``                    ``{``                        ``temp[p] = (``char``)(i + ``'0'``);``                        ``modtemp += j;``                        ``co++;``                    ``}``                ``}``            ``}``        ``}` `        ``// replace the minimum cost with the previous one``        ``if``(ans.first > modtemp)``        ``ans = pair.make_pair(modtemp, ``new` `String(temp));``    ``}``    ` `    ``// print the minimum cost and the final number``    ``System.out.print( ans.first + ``"\n"``                    ``+ ans.second + ``"\n"``);``    ` `    ``return` `-``1``;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``// initialize number length and k``    ``int` `n = ``5``, k = ``4``;` `    ``// initialize the number``    ``String a = ``"21122"``;` `    ``finalNumber(n, k, a);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to illustrate``# the above problem``import` `sys` `# function to calculate the``# minimum value and the final``# number``def` `finalNumber(n, k, a):` `    ``# To store the minimum``    ``# cost and no``    ``ans ``=` `[sys.maxsize, ""]` `    ``for` `i ``in` `range``(``10``):``      ` `        ``# 'i' will replace the``        ``# digits of N's to generate``        ``# a number with k same digits` `        ``# store the main str in temp``        ``# str for modification``        ``temp ``=` `a` `        ``# To store the temporary``        ``# value of the modified number``        ``modtemp ``=` `0` `        ``# Initial count for the``        ``# given number to replace 'i'``        ``co ``=` `a.count(``chr``(i ``+` `ord``(``'0'``)))` `        ``# 'j' manages the difference``        ``# 'i' and 'j'``        ``for` `j ``in` `range``(``1``, ``10``):` `            ``# For the elements ahead``            ``# of 'i' index``            ``if` `(i ``+` `j < ``10``):` `                ``# Checks all elements with``                ``# difference 'j' and replaces``                ``# them with 'i'``                ``for` `p ``in` `range``(n):` `                    ``# Break if count is``                    ``# achieved``                    ``if` `(co >``=` `k):``                        ``break` `                    ``if` `(i ``+` `ord``(``'0'``) ``=``=``                        ``ord``(temp[p]) ``-` `j):` `                        ``# Replaces all elements``                        ``# with difference 'j'``                        ``# and with 'i'``                        ``temp.replace(temp[p],``                                     ``chr``(i ``+``                                         ``ord``(``'0'``)), ``1``)``                        ``modtemp ``+``=` `j``                        ``co``+``=` `1` `            ``# For the elements``            ``# before 'i' index``            ``if` `(i ``-` `j >``=` `0``):``                ``for` `p ``in` `range``(n ``-` `1``,``                               ``-``1``, ``-``1``):``                    ``if` `(co >``=` `k):``                        ``break``                    ``if` `(i ``+` `ord``(``'0'``) ``=``=``                        ``ord``(temp[p]) ``+` `j):``                        ``temp.replace(temp[p],``                                     ``chr``(i ``+``                                         ``ord``(``'0'``)), ``1``)``                        ``modtemp ``+``=` `j``                        ``co ``+``=` `1` `        ``# replace the minimum cost``        ``# with the previous one``        ``ans ``=` `min``(ans, [modtemp,``                        ``temp])` `    ``# print the minimum cost``    ``# and the final number``    ``print``(ans[``0``])``    ``print``(ans[``1``])` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Initialize number``    ``# length and k``    ``n ``=` `5``    ``k ``=` `4` `    ``# initialize the number``    ``a ``=` `"21122"` `    ``finalNumber(n, k, a)` `# This code is contributed by Chitranayal`

## C#

 `// C# program to illustrate``// the above problem``using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// count for the given character``    ``static` `int` `count(``string` `a,``char` `c)``    ``{``        ``int` `co = 0;``        ``for``(``int` `i = 0; i < a.Length; i++)``        ``if``(a[i] == c)``            ``co++;``        ``return` `co;``    ``}``     ` `    ``// function to calculate the minimum``    ``// value and the final number``    ``static` `int` `finalNumber(``int` `n, ``int` `k, ``string` `a)``    ``{``        ``// modtemp = modified temp String``        ``int` `modtemp;``     ` `        ``// store the count of numbers changed to k``        ``int` `co;``     ` `        ``// temporary temp String``        ``char``[] temp = ``new` `char``[a.Length];``     ` `        ``// To store the minimum cost and no``        ``Tuple<``int``, ``string``> ans = ``new` `Tuple<``int``, ``string``>(Int32.MaxValue, ``""``);``     ` `        ``for` `(``int` `i = 0; i < 10; i++)``        ``{``            ``// 'i' will replace the digits of N's to``            ``// generate a number with k same digits``     ` `            ``// store the main str in temp str for modification``            ``temp = a.ToCharArray();``     ` `            ``// To store the temporary value of the modified number``            ``modtemp = 0;``     ` `            ``// Initial count for the given number to replace 'i'``            ``co = count(a, (``char``)(i + ``'0'``));``     ` `            ``// 'j' manages the difference 'i' and 'j'``            ``for` `(``int` `j = 1; j < 10; j++)``            ``{``     ` `                ``// For the elements ahead of 'i' index``                ``if` `(i + j < 10)``                ``{``     ` `                    ``// Checks all elements with difference 'j'``                    ``// and replaces them with 'i'``                    ``for` `(``int` `p = 0; p < n; p++)``                    ``{``     ` `                        ``// Break if count is achieved``                        ``if` `(co >= k)``                            ``break``;``     ` `                        ``if` `(i + ``'0'` `== temp[p] - j)``                        ``{``     ` `                            ``// Replaces all elements with difference``                            ``// 'j' and with 'i'``                            ``temp[p] = (``char``)(i + ``'0'``);``                            ``modtemp += j;``                            ``co++;``                        ``}``                    ``}``                ``}``                 ` `                ``// For the elements before 'i' index``                ``if` `(i - j >= 0)``                ``{``                    ``for` `(``int` `p = n - 1; p >= 0; p--)``                    ``{``                        ``if` `(co >= k)``                            ``break``;``     ` `                        ``if` `(i + ``'0'` `== temp[p] + j)``                        ``{``                            ``temp[p] = (``char``)(i + ``'0'``);``                            ``modtemp += j;``                            ``co++;``                        ``}``                    ``}``                ``}``            ``}``     ` `            ``// replace the minimum cost with the previous one``            ``if``(ans.Item1 > modtemp)``            ``ans = ``new` `Tuple<``int``, ``string``>(modtemp, ``new` `string``(temp));``        ``}``         ` `        ``// print the minimum cost and the final number``        ``Console.Write( ans.Item1 + ``"\n"` `+ ans.Item2 + ``"\n"``);``         ` `        ``return` `-1;``    ``}` `  ``static` `void` `Main()``  ``{``    ` `    ``// initialize number length and k``    ``int` `n = 5, k = 4;``    ` `    ``// initialize the number``    ``string` `a = ``"21122"``;`` ` `    ``finalNumber(n, k, a);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

```1
21222```

Explanation: As on converting 1 to 2 just one time. 2 becomes k times in the number. So the cost is 2-1 = 1.

Time Complexity: O(10 * 10 * N), where N is the given length of the number.
Auxiliary Space: O(1) because constant space is used.

My Personal Notes arrow_drop_up