# 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

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

 ``

Output:

`AbEdWddekkntuw`

Time Complexity: O(n)

My Personal Notes arrow_drop_up