Rearrange characters in a string such that no two adjacent are same using hashing

Given a string str with repeated characters, the task is to rearrange the characters in a string such that no two adjacent characters are same. If it is possible then print Yes else print No.

Examples:

Input: str = “geeksforgeeks”
Output: Yes
“egeksforegeks” is one such arrangement.



Input: str = “bbbbb”
Output: No

Approach: The idea is to store the frequency of each character in an unordered_map and compare maximum frequency of character with the difference of string length and maximum frequency number. If the maximum frequency is less than the difference then it can be arranged otherwise not.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
  
// Function that returns true if it is possible
// to rearrange the characters of the string
// such that no two consecutive characters are same
int isPossible(string str)
{
  
    // To store the frequency of
    // each of the character
    unordered_map<char, int> freq;
  
    // To store the maximum frequency so far
    int max_freq = 0;
    for (int j = 0; j < (str.length()); j++) {
        freq[str[j]]++;
        if (freq[str[j]] > max_freq)
            max_freq = freq[str[j]];
    }
  
    // If possible
    if (max_freq <= (str.length() - max_freq + 1))
        return true;
    return false;
}
  
// Driver code
int main()
{
    string str = "geeksforgeeks";
  
    if (isPossible(str))
        cout << "Yes";
    else
        cout << "No";
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
  
class GFG {
  
    // Function that returns true if it is possible
    // to rearrange the characters of the string
    // such that no two consecutive characters are same
    static boolean isPossible(char[] str)
    {
  
        // To store the frequency of
        // each of the character
        Map<Character, Integer> freq = new HashMap<>();
  
        // To store the maximum frequency so far
        int max_freq = 0;
        for (int j = 0; j < (str.length); j++) {
            if (freq.containsKey(str[j])) {
                freq.put(str[j], freq.get(str[j]) + 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
            else {
                freq.put(str[j], 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
        }
  
        // If possible
        if (max_freq <= (str.length - max_freq + 1))
            return true;
        return false;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String str = "geeksforgeeks";
  
        if (isPossible(str.toCharArray()))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Function that returns true if it is possible
# to rearrange the characters of the String
# such that no two consecutive characters are same
def isPossible(Str):
  
    # To store the frequency of
    # each of the character
    freq = dict()
  
    # To store the maximum frequency so far
    max_freq = 0
    for j in range(len(Str)):
        freq[Str[j]] = freq.get(Str[j], 0) + 1
        if (freq[Str[j]] > max_freq):
            max_freq = freq[Str[j]]
  
    # If possible
    if (max_freq <= (len(Str) - max_freq + 1)):
        return True
    return False
  
# Driver code
Str = "geeksforgeeks"
  
if (isPossible(Str)):
    print("Yes")
else:
    print("No")
  
# This code is contributed by Mohit Kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
using System.Collections.Generic;
  
class GFG {
  
    // Function that returns true if it is possible
    // to rearrange the characters of the string
    // such that no two consecutive characters are same
    static Boolean isPossible(char[] str)
    {
  
        // To store the frequency of
        // each of the character
        Dictionary<char, int> freq = new Dictionary<char, int>();
  
        // To store the maximum frequency so far
        int max_freq = 0;
        for (int j = 0; j < (str.Length); j++) {
            if (freq.ContainsKey(str[j])) {
                var v = freq[str[j]] + 1;
                freq.Remove(str[j]);
                freq.Add(str[j], v);
                if (freq[str[j]] > max_freq)
                    max_freq = freq[str[j]];
            }
            else {
                freq.Add(str[j], 1);
                if (freq[str[j]] > max_freq)
                    max_freq = freq[str[j]];
            }
        }
  
        // If possible
        if (max_freq <= (str.Length - max_freq + 1))
            return true;
        return false;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        String str = "geeksforgeeks";
  
        if (isPossible(str.ToCharArray()))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
  
// This code is contributed by Princi Singh

chevron_right


Output:

Yes


My Personal Notes arrow_drop_up

I like to write Technical Articles on Data Structures and Algorithm in my leisure time

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.