Skip to content
Related Articles

Related Articles

Convert a number of length N such that it contains any one digit at least ‘K’ times
  • Last Updated : 17 Dec, 2020

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 differences between the old digit and the new one. The task is to print the minimum cost took to convert the initial number to the final number 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 as “9” will be replaced to “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. At last, 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 <bits/stdc++.h>
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()
{
    // initilaize 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[])
{
    // initilaize 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__":
 
    # Initilaize 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()
  {
     
    // initilaize 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
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.
 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :