Rearrange string such that no pair of adjacent characters are of the same type
Given alphanumeric string str, the task is to rearrange the string such that no two adjacent characters are of the same type, i.e., no two adjacent characters can be alphabets or digits. If no such arrangement is possible, print -1.
Examples:
Input: str = “Beginner2020”
Output: g2e0e2k0sInput: str = “IPL20”
Output: I2P0L
Naive Approach: The simplest approach is to generate all possible permutation of the given string and for every permutation, check if it satisfies the given conditions or not. If found to be true for any permutation, print that permutation. If no such permutation exists, then print -1.
Time Complexity: O(2N)
Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach, the idea is to store all the alphabets and the digits separately and rearrange them by placing them alternatively in the resultant string. If the count of the alphabets and the digits differ by more than 1, print -1 as no desired arrangement is possible.
Below is the implementation of the above approach:
C++
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to rearrange given // alphanumeric string such that // no two adjacent characters // are of the same type string rearrange(string s) { // Stores alphabets and digits string s1 = "" , s2 = "" ; // Store the alphabets and digits // separately in the strings for ( char x : s) { isalpha (x) ? s1.push_back(x) : s2.push_back(x); } // Stores the count of // alphabets and digits int n = s1.size(); int m = s2.size(); // If respective counts // differ by 1 if ( abs (n - m) > 1) // Desired arrangement // not possible return "-1" ; // Stores the indexes int i = 0, j = 0, k = 0; // Check if first character // should be alphabet or digit int flag = (n >= m) ? 1 : 0; // Place alphabets and digits // alternatively while (i < n and j < m) { // If current character // needs to be alphabet if (flag) s[k++] = s1[i++]; // If current character // needs to be a digit else s[k++] = s2[j++]; // Flip flag for alternate // arrangement flag = !flag; } // Return resultant string return s; } // Driver Code int main() { // Given String string str = "Beginner2020" ; // Function Call cout << rearrange(str) << endl; return 0; } |
Java
// Java program to implement // the above approach class GFG{ // Function to rearrange given // alphanumeric String such that // no two adjacent characters // are of the same type static String rearrange(String s) { // Stores alphabets and digits String s1 = "" , s2 = "" , ans = "" ; char []s3 = s.toCharArray(); // Store the alphabets and digits // separately in the Strings for ( char x : s3) { if (x >= 'a' && x <= 'z' ) s1 += x ; else s2 += x; } // Stores the count of // alphabets and digits int n = s1.length(); int m = s2.length(); // If respective counts // differ by 1 if (Math.abs(n - m) > 1 ) // Desired arrangement // not possible return "-1" ; // Stores the indexes int i = 0 , j = 0 , k = 0 ; // Check if first character // should be alphabet or digit int flag = (n >= m) ? 1 : 0 ; // Place alphabets and digits // alternatively while (i < n && j < m) { // If current character // needs to be alphabet if (flag != 0 ) ans += s1.charAt(i++); // If current character // needs to be a digit else ans += s2.charAt(j++); // Flip flag for alternate // arrangement if (flag == 1 ) flag = 0 ; else flag = 1 ; } // Return resultant String return ans; } // Driver Code public static void main(String[] args) { // Given String String str = "Beginner2020" ; // Function Call System.out.print(rearrange(str) + "\n" ); } } // This code is contributed by gauravrajput1 |
Python3
# Python3 program to implement # the above approach # Function to rearrange given # alphanumeric such that no # two adjacent characters # are of the same type def rearrange(s): # Stores alphabets and digits s1 = [] s2 = [] # Store the alphabets and digits # separately in the strings for x in s: if x.isalpha(): s1.append(x) else : s2.append(x) # Stores the count of # alphabets and digits n = len (s1) m = len (s2) # If respective counts # differ by 1 if ( abs (n - m) > 1 ): # Desired arrangement # not possible return "-1" # Stores the indexes i = 0 j = 0 k = 0 # Check if first character # should be alphabet or digit flag = 0 if (n > = m): flag = 1 else : flag = 0 # Place alphabets and digits # alternatively while (i < n and j < m): # If current character # needs to be alphabet if (flag): s[k] = s1[i] k + = 1 i + = 1 # If current character # needs to be a digit else : s[k] = s2[j] k + = 1 j + = 1 # Flip flag for alternate # arrangement flag = not flag # Return resultant string return "".join(s) # Driver Code if __name__ = = '__main__' : # Given String str = "Beginner2020" str1 = [i for i in str ] # Function call print (rearrange(str1)) # This code is contributed by mohit kumar 29 |
C#
// C# program to implement // the above approach using System; class GFG{ // Function to rearrange given // alphanumeric String such that // no two adjacent characters // are of the same type static String rearrange(String s) { // Stores alphabets and digits String s1 = "" , s2 = "" , ans = "" ; char []s3 = s.ToCharArray(); // Store the alphabets and digits // separately in the Strings foreach ( char x in s3) { if (x >= 'a' && x <= 'z' ) s1 += x ; else s2 += x; } // Stores the count of // alphabets and digits int n = s1.Length; int m = s2.Length; // If respective counts // differ by 1 if (Math.Abs(n - m) > 1) // Desired arrangement // not possible return "-1" ; // Stores the indexes int i = 0, j = 0, k = 0; // Check if first character // should be alphabet or digit int flag = (n >= m) ? 1 : 0; // Place alphabets and digits // alternatively while (i < n && j < m) { // If current character // needs to be alphabet if (flag != 0) ans += s1[i++]; // If current character // needs to be a digit else ans += s2[j++]; // Flip flag for alternate // arrangement if (flag == 1) flag = 0; else flag = 1; } // Return resultant String return ans; } // Driver Code public static void Main(String[] args) { // Given String String str = "Beginner2020" ; // Function Call Console.Write(rearrange(str) + "\n" ); } } // This code is contributed by 29AjayKumar |
Javascript
<script> // Javascript program to implement // the above approach // Function to rearrange given // alphanumeric String such that // no two adjacent characters // are of the same type function rearrange(s) { // Stores alphabets and digits let s1 = "" , s2 = "" , ans = "" ; let s3 = s.split( "" ); // Store the alphabets and digits // separately in the Strings for (let x = 0; x < s3.length; x++) { if (s3[x] >= 'a' && s3[x] <= 'z' ) s1 += s3[x] ; else s2 += s3[x]; } // Stores the count of // alphabets and digits let n = s1.length; let m = s2.length; // If respective counts // differ by 1 if (Math.abs(n - m) > 1) // Desired arrangement // not possible return "-1" ; // Stores the indexes let i = 0, j = 0, k = 0; // Check if first character // should be alphabet or digit let flag = (n >= m) ? 1 : 0; // Place alphabets and digits // alternatively while (i < n && j < m) { // If current character // needs to be alphabet if (flag != 0) ans += s1[i++]; // If current character // needs to be a digit else ans += s2[j++]; // Flip flag for alternate // arrangement if (flag == 1) flag = 0; else flag = 1; } // Return resultant String return ans; } // Driver Code // Given String let str = "Beginner2020" ; // Function Call document.write(rearrange(str) + "<br>" ); // This code is contributed by patel2127 </script> |
g2e0e2k00
Time Complexity: O(N)
Auxiliary Space: O(N)