Alternate Lower Upper String Sort - GeeksforGeeks

28 May, 2021
Given a string containing lowercase and uppercase letters. Sort it in such a manner that the uppercase and lowercase letters come in an alternate manner but in a sorted way.
Examples:
Input : bAwutndekWEdkd
Output :AbEdWddekkntuw
Explanation:
Here we can see that letter ‘A’, ’E’, ’W’ are sorted 
as well as letters “b, d, d, d, e, k, k, n, t, u, w” are sorted 
but both appears alternately in the string as far as possible.

Input :abbfDDhGFBvdFDGBNDasZVDFjkb
Output :BaBaDbDbDbDdDfFhFjFkGsGvNVZ
1) Count lower case characters in an array lCount[] 2) Count upper case characters in another array uCount[] 3) Modify strings using lCount[] and uCount[] 
C++
Java
C#
Python3
Javascript
// C++ program for unusul string sorting#include <bits/stdc++.h>using namespace std;#define MAX 26 // Function for alternate sorting of stringvoid alternateSort(string& s){    int n = s.length();     // Count occurrences of individual lower case and    // upper case characters    int lCount[MAX] = { 0 }, uCount[MAX] = { 0 };    for (int i = 0; i < n; i++) {        if (isupper(s[i]))            uCount[s[i] - 'A']++;        else            lCount[s[i] - 'a']++;    }     // Traverse through count arrays and one by one    // pick characters.  Below loop takes O(n) time    // considering the MAX is constant.    int i = 0, j = 0, k = 0;    while (k < n) {        while (i < MAX && uCount[i] == 0)            i++;        if (i < MAX) {            s[k++] = 'A' + i;            uCount[i]--;        }         while (j < MAX && lCount[j] == 0)            j++;        if (j < MAX) {            s[k++] = 'a' + j;            lCount[j]--;        }    }} // Driver codeint main(){    string str = "bAwutndekWEdkd";    alternateSort(str);    cout << str << "\n";}
// Java program for// unusual string sortingimport java.util.*;import java.lang.*; public class GfG{ private final static int MAX = 100; // Function for alternate// sorting of stringpublic static String alternateSort(String s1){    int n = s1.length();     char[] s = s1.toCharArray();     // Count occurrences of    // individual lower case and    // upper case characters    int[] lCount = new int[MAX];    int[] uCount = new int[MAX];     for (int i = 0; i < n; i++) {         if (Character.isUpperCase(s[i]))            uCount[s[i] - 'A']++;        else            lCount[s[i] - 'a']++;    }     // Traverse through count    // arrays and one by one    // pick characters.    // Below loop takes O(n) time    // considering the MAX is constant.    int i = 0, j = 0, k = 0;    while (k < n)    {         while (i < MAX && uCount[i] == 0)                i++;         if (i < MAX) {                s[k++] = (char)('A' + i);                uCount[i]--;            }         while (j < MAX && lCount[j] == 0)                j++;         if (j < MAX) {                s[k++] = (char)('a' + j);                lCount[j]--;            }        }                 return (new String(s));    }     // Driver functionpublic static void main(String argc[]){     String str = "bAwutndekWEdkd";    System.out.println(alternateSort(str));}     }  // This code is contributed by Sagar Shukla
// C# program for unusual string sortingusing System; public class GFG {     private static int MAX = 100;         // Function for alternate    // sorting of string    static String alternateSort(String s1)    {        int n = s1.Length;        int l = 0, j = 0, k = 0;             char[] s = s1.ToCharArray();             // Count occurrences of        // individual lower case and        // upper case characters        int[] lCount = new int[MAX];        int[] uCount = new int[MAX];             for (int i = 0; i < n; i++) {                 if (char.IsUpper(s[i]))                uCount[s[i] - 'A']++;            else                lCount[s[i] - 'a']++;        }             // Traverse through count        // arrays and one by one        // pick characters.        // Below loop takes O(n) time        // considering the MAX is constant.                 while (k < n)        {                 while (l < MAX && uCount[l] == 0)                l++;                 if (l < MAX) {                s[k++] = (char)('A' + l);                uCount[l]--;            }                 while (j < MAX && lCount[j] == 0)                j++;                 if (j < MAX) {                s[k++] = (char)('a' + j);                lCount[j]--;            }        }                     return (new String(s));    }             // Driver function    public static void Main()    {        String str = "bAwutndekWEdkd";                 Console.Write(alternateSort(str));    }} // This code is contributed by parashar.
# Python3 program for# unusul string sortingMAX = 26 # Function for alternate# sorting of stringdef alternateSort(s):       n = len(s)     # Count occurrences of    # individual lower case and       # upper case characters    lCount = [0 for i in range(MAX)]    uCount = [0 for i in range(MAX)]    s = list(s)         for i in range(n):        if(s[i].isupper()):            uCount[ord(s[i]) -                   ord('A')] += 1        else:            lCount[ord(s[i]) -                   ord('a')] += 1     # Traverse through count    # arrays and one by one    # pick characters. Below    # loop takes O(n) time    # considering the MAX    # is constant.    i = 0    j = 0    k = 0     while(k < n):        while(i < MAX and              uCount[i] == 0):            i += 1        if(i < MAX):            s[k] = chr(ord('A') + i)            k += 1            uCount[i] -= 1        while(j < MAX and              lCount[j] == 0):            j += 1        if(j < MAX):            s[k] = chr(ord('a') + j)            k += 1            lCount[j] -= 1     print("".join(s)) # Driver codestr = "bAwutndekWEdkd"alternateSort(str) # This code is contributed by avanitrachhadiya2155
<script>      // JavaScript program for unusual string sorting      const MAX = 26;       // Function for alternate      // sorting of string      function alternateSort(s1) {        var n = s1.length;        var l = 0, j = 0, k = 0;         var s = s1.split("");         // Count occurrences of        // individual lower case and        // upper case characters        var lCount = new Array(MAX).fill(0);        var uCount = new Array(MAX).fill(0);         for (var i = 0; i < n; i++) {          if (s[i] === s[i].toUpperCase())            uCount[s[i].charCodeAt(0) - "A".charCodeAt(0)]++;          else              lCount[s[i].charCodeAt(0) - "a".charCodeAt(0)]++;        }         // Traverse through count        // arrays and one by one        // pick characters.        // Below loop takes O(n) time        // considering the MAX is constant.         while (k < n) {          while (l < MAX && uCount[l] === 0)              l++;           if (l < MAX) {            s[k++] = String.fromCharCode("A".charCodeAt(0) + l);            uCount[l]--;          }           while (j < MAX && lCount[j] === 0)              j++;           if (j < MAX) {            s[k++] = String.fromCharCode("a".charCodeAt(0) + j);            lCount[j]--;          }        }         return s.join("");      }       // Driver function      var str = "bAwutndekWEdkd";       document.write(alternateSort(str));</script>
Output: 
AbEdWddekkntuw
Time Complexity: O(n)
parashar
avanitrachhadiya2155
rdtank
frequency-counting
Sorting
Strings
Strings
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
HeapSort
Time Complexities of all Sorting Algorithms
Radix Sort
Merge two sorted arrays
Sort an array of 0s, 1s and 2s
Reverse a string in Java
Write a program to reverse an array or string
Longest Common Subsequence | DP-4
Write a program to print all permutations of a given string
C++ Data Types