Rearrange characters in a sorted string such that no pair of adjacent characters are the same

Given a sorted string S consisting of N lowercase characters, the task is to rearrange characters in the given string such that no two adjacent characters are the same. If it is not possible to rearrange as per the given criteria, then print “-1”.

Examples:

Input: S = “aaabc”
Output: abaca

Input: S = “aa”
Output: -1

Approach: The given problem can be solved by using the Two-Pointer Technique. Follow the steps below to solve this problem:

• Iterate over the characters of the string S and check if no two adjacent characters are the same in the string then print the string S.
• Otherwise, if the size of the string is 2 and has the same characters, then print “-1”.
• Initialize three variables, say, i as 0, j as 1, and k as 2 to traverse over the string S.
• Iterate while k is less than N and perform the following steps:
  • If S[i] is not equal to S[j], then increment i and j by 1, and increment k by 1, if the value of j is equal to k.
  • Else if S[j] equals S[k], increment k by 1.
  • Else, swap s[j] and s[k] and increment i and j by 1, and if j is equal to k, then increment k by 1.
• After completing the above steps reverse the string S.
• Finally, iterate over the characters of the string S and check if no two adjacent characters are the same. If found to be true then print string S. Otherwise, print “-1”.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to check if a string S
// contains pair of adjacent
// characters that are equal or not
bool isAdjChar(string& s)
{
    // Traverse the string S
    for (int i = 0; i < s.size() - 1; i++) {

        // If S[i] and S[i+1] are equal
        if (s[i] == s[i + 1])
            return true;
    }

    // Otherwise, return false
    return false;
}

// Function to rearrange characters
// of a string such that no pair of
// adjacent characters are the same
void rearrangeStringUtil(string& S, int N)
{
    // Initialize 3 variables
    int i = 0, j = 1, k = 2;

    // Iterate until k < N
    while (k < N) {

        // If S[i] is not equal
        // to S[j]
        if (S[i] != S[j]) {

            // Increment i and j by 1
            i++;
            j++;

            // If j equals k and increment
            // the value of K by 1
            if (j == k) {
                k++;
            }
        }

        // Else
        else {

            // If S[j] equals S[k]
            if (S[j] == S[k]) {

                // Increment k by 1
                k++;
            }

            // Else
            else {

                // Swap
                swap(S[k], S[j]);

                // Increment i and j
                // by 1
                i++;
                j++;

                // If j equals k
                if (j == k) {

                    // Increment k by 1
                    k++;
                }
            }
        }
    }
}

// Function to rearrange characters
// in a string so that no two
// adjacent characters are same
string rearrangeString(string& S, int N)
{

    // If string is already valid
    if (isAdjChar(S) == false) {
        return S;
    }

    // If size of the string is 2
    if (S.size() == 2)
        return "-1";

    // Function Call
    rearrangeStringUtil(S, N);

    // Reversing the string
    reverse(S.begin(), S.end());

    // Function Call
    rearrangeStringUtil(S, N);

    // If the string is valid
    if (isAdjChar(S) == false) {
        return S;
    }

    // Otherwise
    return "-1";
}

// Driver Code
int main()
{
    string S = "aaabc";
    int N = S.length();
    cout << rearrangeString(S, N);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG
{
    static char []S = "aaabc".toCharArray();

// Function to check if a String S
// contains pair of adjacent
// characters that are equal or not
static boolean isAdjChar()
{

    // Traverse the String S
    for (int i = 0; i < S.length - 1; i++)
    {

        // If S[i] and S[i+1] are equal
        if (S[i] == S[i + 1])
            return true;
    }

    // Otherwise, return false
    return false;
}

// Function to rearrange characters
// of a String such that no pair of
// adjacent characters are the same
static void rearrangeStringUtil(int N)
{

    // Initialize 3 variables
    int i = 0, j = 1, k = 2;

    // Iterate until k < N
    while (k < N) {

        // If S[i] is not equal
        // to S[j]
        if (S[i] != S[j]) {

            // Increment i and j by 1
            i++;
            j++;

            // If j equals k and increment
            // the value of K by 1
            if (j == k) {
                k++;
            }
        }

        // Else
        else {

            // If S[j] equals S[k]
            if (S[j] == S[k]) {

                // Increment k by 1
                k++;
            }

            // Else
            else {

                // Swap
                swap(k,j);

                // Increment i and j
                // by 1
                i++;
                j++;

                // If j equals k
                if (j == k) {

                    // Increment k by 1
                    k++;
                }
            }
        }
    }
}
static void swap(int i, int j)
{
    char temp = S[i];
    S[i] = S[j];
    S[j] = temp;
}
// Function to rearrange characters
// in a String so that no two
// adjacent characters are same
static String rearrangeString(int N)
{

    // If String is already valid
    if (isAdjChar() == false) {
        return String.valueOf(S);
    }

    // If size of the String is 2
    if (S.length == 2)
        return "-1";

    // Function Call
    rearrangeStringUtil(N);

    // Reversing the String
    reverse();

    // Function Call
    rearrangeStringUtil(N);

    // If the String is valid
    if (isAdjChar() == false) {
        return String.valueOf(S);
    }

    // Otherwise
    return "-1";
}
static void reverse() {

    int l, r = S.length - 1;
    for (l = 0; l < r; l++, r--) {
        char temp = S[l];
        S[l] = S[r];
        S[r] = temp;
    }
}

// Driver Code
public static void main(String[] args)
{

    int N = S.length;
    System.out.print(rearrangeString(N));

}
}

// This code is contributed by Princi Singh

Python3

# Python 3 program for the above approach
S = "aaabc"

# Function to check if a string S
# contains pair of adjacent
# characters that are equal or not
def isAdjChar(s):

    # Traverse the string S
    for i in range(len(s)-1):

        # If S[i] and S[i+1] are equal
        if (s[i] == s[i + 1]):
            return True

    # Otherwise, return false
    return False

# Function to rearrange characters
# of a string such that no pair of
# adjacent characters are the same
def rearrangeStringUtil(N):
    global S
    S = list(S)
    # Initialize 3 variables
    i = 0
    j = 1
    k = 2

    # Iterate until k < N
    while (k < N):

        # If S[i] is not equal
        # to S[j]
        if (S[i] != S[j]):

            # Increment i and j by 1
            i += 1
            j += 1

            # If j equals k and increment
            # the value of K by 1
            if (j == k):
                k += 1

        # Else
        else:

            # If S[j] equals S[k]
            if (S[j] == S[k]):

                # Increment k by 1
                k += 1

            # Else
            else:

                # Swap
                temp = S[k]
                S[k] = S[j]
                S[j] = temp
                # Increment i and j
                # by 1
                i += 1
                j += 1

                # If j equals k
                if (j == k):

                    # Increment k by 1
                    k += 1
    S = ''.join(S)

# Function to rearrange characters
# in a string so that no two
# adjacent characters are same
def rearrangeString(N):
    global S

    # If string is already valid
    if (isAdjChar(S) == False):
        return S

    # If size of the string is 2
    if (len(S) == 2):
        return "-1"

    # Function Call
    rearrangeStringUtil(N)

    # Reversing the string
    S = S[::-1]

    # Function Call
    rearrangeStringUtil(N)

    # If the string is valid
    if (isAdjChar(S) == False):
        return S

    # Otherwise
    return "-1"

# Driver Code
if __name__ == '__main__':
    N = len(S)
    print(rearrangeString(N))

    # This code is contributed by ipg2016107.

C#

// C# program for the above approach
using System;

public class GFG
{
    static char []S = "aaabc".ToCharArray();

// Function to check if a String S
// contains pair of adjacent
// characters that are equal or not
static bool isAdjChar()
{

    // Traverse the String S
    for (int i = 0; i < S.Length - 1; i++)
    {

        // If S[i] and S[i+1] are equal
        if (S[i] == S[i + 1])
            return true;
    }

    // Otherwise, return false
    return false;
}

// Function to rearrange characters
// of a String such that no pair of
// adjacent characters are the same
static void rearrangeStringUtil(int N)
{

    // Initialize 3 variables
    int i = 0, j = 1, k = 2;

    // Iterate until k < N
    while (k < N) {

        // If S[i] is not equal
        // to S[j]
        if (S[i] != S[j]) {

            // Increment i and j by 1
            i++;
            j++;

            // If j equals k and increment
            // the value of K by 1
            if (j == k) {
                k++;
            }
        }

        // Else
        else {

            // If S[j] equals S[k]
            if (S[j] == S[k]) {

                // Increment k by 1
                k++;
            }

            // Else
            else {

                // Swap
                swap(k,j);

                // Increment i and j
                // by 1
                i++;
                j++;

                // If j equals k
                if (j == k) {

                    // Increment k by 1
                    k++;
                }
            }
        }
    }
}
static void swap(int i, int j)
{
    char temp = S[i];
    S[i] = S[j];
    S[j] = temp;
}

// Function to rearrange characters
// in a String so that no two
// adjacent characters are same
static String rearrangeString(int N)
{

    // If String is already valid
    if (isAdjChar() == false) {
        return String.Join("",S);
    }

    // If size of the String is 2
    if (S.Length == 2)
        return "-1";

    // Function Call
    rearrangeStringUtil(N);

    // Reversing the String
    reverse();

    // Function Call
    rearrangeStringUtil(N);

    // If the String is valid
    if (isAdjChar() == false) {
        return String.Join("",S);
    }

    // Otherwise
    return "-1";
}
static void reverse() {

    int l, r = S.Length - 1;
    for (l = 0; l < r; l++, r--) {
        char temp = S[l];
        S[l] = S[r];
        S[r] = temp;
    }
}

// Driver Code
public static void Main(String[] args)
{

    int N = S.Length;
    Console.Write(rearrangeString(N));

}
}

// This code is contributed by shikhasingrajput

Javascript

<script>

// JavaScript program for the above approach
let S = "aaabc"

// Function to check if a string S
// contains pair of adjacent
// characters that are equal or not
function isAdjChar(s){

    // Traverse the string S
    for(let i = 0; i < s.length - 1; i++){

        // If S[i] and S[i+1] are equal
        if (s[i] == s[i + 1])
            return true
    }

    // Otherwise, return false
    return false
}

// Function to rearrange characters
// of a string such that no pair of
// adjacent characters are the same
function rearrangeStringUtil(N){

    S = S.split("")
    // Initialize 3 variables
    let i = 0
    let j = 1
    let k = 2

    // Iterate until k < N
    while (k < N){

        // If S[i] is not equal
        // to S[j]
        if (S[i] != S[j]){

            // Increment i and j by 1
            i += 1
            j += 1

            // If j equals k and increment
            // the value of K by 1
            if (j == k)
                k += 1
        }

        // Else
        else{

            // If S[j] equals S[k]
            if (S[j] == S[k]){

                // Increment k by 1
                k += 1
            }

            // Else
            else{

                // Swap
                let temp = S[k]
                S[k] = S[j]
                S[j] = temp

                // Increment i and j
                // by 1
                i += 1
                j += 1

                // If j equals k
                if (j == k){

                    // Increment k by 1
                    k += 1
                }
            }
        }
    }
    S = S.join('')
}

// Function to rearrange characters
// in a string so that no two
// adjacent characters are same
function rearrangeString(N){

    // If string is already valid
    if (isAdjChar(S) == false)
        return S

    // If size of the string is 2
    if (S.length == 2)
        return "-1"

    // Function Call
    rearrangeStringUtil(N)

    // Reversing the string
    S = S.split("").reverse().join("")

    // Function Call
    rearrangeStringUtil(N)

    // If the string is valid
    if (isAdjChar(S) == false)
        return S

    // Otherwise
    return "-1"
}

// Driver Code
let N = S.length;
document.write(rearrangeString(N))

// This code is contributed by shinjanpatra

</script>

Output:

acaba

Time Complexity: O(N), as we are using reverse function which will cost O (N) time.
Auxiliary Space: O(1), as we are not using any extra space.