Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Find number formed by sorting digits of N after removing adjacent duplicates

  • Last Updated : 14 Dec, 2021

Given a number N, the task is to remove the adjacent duplicates of a number N and then sort the digits of the number N in decreasing order.

Example:

Input: N=11123134
Output: 433211

Input: N=22133455
Output: 54321

 

Approach: Follow the below steps to solve the below problem:

  1. Create a map to store the frequency of all characters, say mp.
  2. Create a function getDigits which will accept an integer as a parameter and will return it in a form of a string.
  3. Iterate on that string and only increment the frequency of the digits that don’t have a duplicate at their previous index.
  4. Iterate on the map mp and create a string of integers, which will automatically be in sorted order.
  5. Convert that string to integer and print the answer accordingly.

Below is the implementation of the above approach.

C++




// C++ code for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to change integer N to string
string getDigits(int N) { return to_string(N); }
 
// Function to remove the adjacent duplicates
// of a number N and then sort the digits
// of the number N in decreasing order
int getSolution(int N)
{
    string s = getDigits(N);
    if (s.size() == 1) {
        return stoi(s);
    }
 
    map<int, int> mp;
    for (int i = 1; i < s.size(); ++i) {
        if (s[i] != s[i - 1]) {
            mp[s[i - 1] - '0']++;
        }
    }
 
    mp[s[s.size() - 1] - '0']++;
 
    // Creating the number
    int mul = 1;
    int ans = 0;
    for (auto x : mp) {
        for (int i = 0; i < x.second; i++) {
            ans += x.first * mul;
            mul *= 10;
        }
    }
 
    // Returning the created number
    return ans;
}
 
// Driver Code
int main()
{
    int N = 11123134;
    cout << getSolution(N);
}

Java




// Java code for the above approach
import java.util.*;
 
class GFG{
 
// Function to change integer N to String
static String getDigits(int N) { return String.valueOf(N); }
 
// Function to remove the adjacent duplicates
// of a number N and then sort the digits
// of the number N in decreasing order
static int getSolution(int N)
{
    char []s = getDigits(N).toCharArray();
    if (s.length == 1) {
        return Integer.valueOf(String.valueOf(s));
    }
 
    HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();
    for (int i = 1; i < s.length; ++i) {
        if (s[i] != s[i - 1]) {
            if(mp.containsKey(s[i - 1] - '0')){
                mp.put(s[i - 1] - '0', mp.get(s[i - 1] - '0')+1);
            }
            else
                mp.put(s[i - 1] - '0', 1);
        }
    }
 
    if(mp.containsKey(s[s.length - 1] - '0')){
        mp.put(s[s.length - 1] - '0', mp.get(s[s.length - 1] - '0')+1);
    }
    else
        mp.put(s[s.length - 1] - '0', 1);
 
 
    // Creating the number
    int mul = 1;
    int ans = 0;
    for (Map.Entry<Integer,Integer> x : mp.entrySet()) {
        for (int i = 0; i < x.getValue(); i++) {
            ans += x.getKey() * mul;
            mul *= 10;
        }
    }
 
    // Returning the created number
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 11123134;
    System.out.print(getSolution(N));
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Python code for the above approach
 
# Function to change integer N to string
def getDigits(N) :
    return str(N);
 
# Function to remove the adjacent duplicates
# of a number N and then sort the digits
# of the number N in decreasing order
def getSolution(N):
    s = getDigits(N);
 
    if (len(s) == 1):
        return int(s);
 
    mp = {}
    for i in range(1, len(s)):
        if (s[i] != s[i - 1]):
            if ((ord(s[i - 1]) -  ord('0')) in mp):
                mp[ord(s[i - 1]) -  ord('0')] += 1;
            else:
                mp[ord(s[i - 1]) - ord('0')] =  1;
 
    if (s[-1] in mp):
        mp[ord(s[-1]) -  ord('0')]  += 1
    else:
        mp[ord(s[-1]) -  ord('0')]  = 1
 
    # Creating the number
    mul = 1;
    ans = 0;
     
    for x in mp:
        for i in range(mp[x]):
            ans = ans + x * mul;
            mul = mul * 10;
 
    # Returning the created number
    return ans;
 
# Driver Code
N = 11123134;
 
print(getSolution(N));
 
# This code is contributed by gfgking

C#




// C# code for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to change integer N to String
static string getDigits(int N)
{
    return (N).ToString();
}
 
// Function to remove the adjacent duplicates
// of a number N and then sort the digits
// of the number N in decreasing order
static int getSolution(int N)
{
    char[] s = getDigits(N).ToCharArray();
     
    if (s.Length == 1)
    {
        return Int32.Parse((s).ToString());
    }
 
    Dictionary<int,
               int> mp = new Dictionary<int,
                                        int>();
                                         
    for(int i = 1; i < s.Length; ++i)
    {
        if (s[i] != s[i - 1])
        {
            if (mp.ContainsKey(s[i - 1] - '0'))
            {
                mp[s[i - 1] - '0']++;
            }
            else
                mp[s[i - 1] - '0'] = 1;
        }
    }
 
    if (mp.ContainsKey(s[s.Length - 1] - '0'))
    {
        mp[s[s.Length - 1] - '0'] += 1;
    }
    else
        mp[s[s.Length - 1] - '0'] = 1;
 
    // Creating the number
    int mul = 1;
    int ans = 0;
    foreach(KeyValuePair<int, int> x in mp)
    {
        for(int i = 0; i < x.Value; i++)
        {
            ans += x.Key * mul;
            mul *= 10;
        }
    }
 
    // Returning the created number
    return ans;
}
 
// Driver Code
public static void Main(string[] args)
{
    int N = 11123134;
     
    Console.WriteLine(getSolution(N));
}
}
 
// This code is contributed by ukasp

Javascript




<script>
 
// JavaScript code for the above approach
 
// Function to change integer N to string
function getDigits(N)
{
    return N.toString();
}
 
// Function to remove the adjacent duplicates
// of a number N and then sort the digits
// of the number N in decreasing order
function getSolution(N)
{
    let s = getDigits(N);
 
    if (s.length == 1)
    {
        return parseInt(s);
    }
 
    let mp = new Map();
    for(let i = 1; i < s.length; ++i)
    {
        if (s[i] != s[i - 1])
        {
            if (mp.has(s[i - 1].charCodeAt(0) -
                            '0'.charCodeAt(0)))
            {
                mp.set(s[i - 1].charCodeAt(0) -
                            '0'.charCodeAt(0),
                mp.get(s[i - 1].charCodeAt(0) -
                            '0'.charCodeAt(0)) + 1);
            }
            else
            {
                mp.set(s[i - 1].charAt(0) -
                            '0'.charAt(0), 1);
            }
        }
    }
    if (mp.has(s[s.length - 1]))
        mp.set(s[s.length - 1].charCodeAt(0) -
                           '0'.charCodeAt(0),
        mp.get(s[s.length - 1].charCodeAt(0) -
                           '0'.charCodeAt(0)) + 1);
    else
        mp.set(s[s.length - 1].charCodeAt(0) -
                           '0'.charCodeAt(0), 1)
 
    // Creating the number
    let mul = 1;
    let ans = 0;
     
    for(let [key, value] of mp)
    {
        for(let i = 0; i < value; i++)
        {
            ans = ans + key * mul;
            mul = mul * 10;
        }
    }
 
    // Returning the created number
    return ans;
}
 
// Driver Code
let N = 11123134;
 
document.write(getSolution(N));
 
// This code is contributed by Potta Lokesh
 
</script>
Output
433211

Time Complexity: O(logN)
Auxiliary Space: O(1)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!