Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Alternate Lower Upper String Sort

  • Difficulty Level : Medium
  • Last Updated : 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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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++




// C++ program for unusul string sorting
#include <bits/stdc++.h>
using namespace std;
#define MAX 26
 
// Function for alternate sorting of string
void 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 code
int main()
{
    string str = "bAwutndekWEdkd";
    alternateSort(str);
    cout << str << "\n";
}

Java




// Java program for
// unusual string sorting
import java.util.*;
import java.lang.*;
 
public class GfG{
 
private final static int MAX = 100;
 
// Function for alternate
// sorting of string
public 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 function
public static void main(String argc[]){
 
    String str = "bAwutndekWEdkd";
    System.out.println(alternateSort(str));
}
     
}
 
 
// This code is contributed by Sagar Shukla

C#




// C# program for unusual string sorting
using 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




# Python3 program for
# unusul string sorting
MAX = 26
 
# Function for alternate
# sorting of string
def 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 code
str = "bAwutndekWEdkd"
alternateSort(str)
 
# This code is contributed by avanitrachhadiya2155

Javascript




<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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :