GFG App
Open App
Browser
Continue

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

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 ` `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 mp = ``new` `HashMap();` `    ``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 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

 ``

Output

`433211`

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

My Personal Notes arrow_drop_up