# Lexicographically largest sub-sequence of the given string

• Difficulty Level : Basic
• Last Updated : 18 Aug, 2021

Given a string str containing lowercase characters, the task is to find the lexicographically largest sub-sequence of str.
Examples:

Input: str = “abc”
Output:
All possible sub-sequences are “a”, “ab”, “ac”, “b”, “bc” and “c”
and “c” is the largest among them (lexicographically)
Input: str = “geeksforgeeks”
Output: ss

Approach: Let mx be the lexicographically largest character in the string. Since we want the lexicographically largest sub-sequence we should include all occurrences of mx. Now after all the occurrences have been used, the same process can be repeated for the remaining string (i.e. sub-string after the last occurrence of mx) and so on until the there are no more characters left.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the lexicographically``// largest sub-sequence of s``string getSubSeq(string s, ``int` `n)``{``    ``string res = ``""``;``    ``int` `cr = 0;``    ``while` `(cr < n) {` `        ``// Get the max character from the string``        ``char` `mx = s[cr];``        ``for` `(``int` `i = cr + 1; i < n; i++)``            ``mx = max(mx, s[i]);``        ``int` `lst = cr;` `        ``// Use all the occurrences of the``        ``// current maximum character``        ``for` `(``int` `i = cr; i < n; i++)``            ``if` `(s[i] == mx) {``                ``res += s[i];``                ``lst = i;``            ``}` `        ``// Repeat the steps for the remaining string``        ``cr = lst + 1;``    ``}``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``string s = ``"geeksforgeeks"``;``    ``int` `n = s.length();``    ``cout << getSubSeq(s, n);``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `    ``// Function to return the lexicographically``    ``// largest sub-sequence of s``    ``static` `String getSubSeq(String s, ``int` `n)``    ``{``        ``String res = ``""``;``        ``int` `cr = ``0``;``        ``while` `(cr < n)``        ``{` `            ``// Get the max character from the String``            ``char` `mx = s.charAt(cr);``            ``for` `(``int` `i = cr + ``1``; i < n; i++)``            ``{``                ``mx = (``char``) Math.max(mx, s.charAt(i));``            ``}``            ``int` `lst = cr;` `            ``// Use all the occurrences of the``            ``// current maximum character``            ``for` `(``int` `i = cr; i < n; i++)``            ``{``                ``if` `(s.charAt(i) == mx)``                ``{``                    ``res += s.charAt(i);``                    ``lst = i;``                ``}``            ``}` `            ``// Repeat the steps for``            ``// the remaining String``            ``cr = lst + ``1``;``        ``}``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String s = ``"geeksforgeeks"``;``        ``int` `n = s.length();``        ``System.out.println(getSubSeq(s, n));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python 3 implementation of the approach` `# Function to return the lexicographically``# largest sub-sequence of s``def` `getSubSeq(s, n):``    ``res ``=` `""``    ``cr ``=` `0``    ``while` `(cr < n):``        ` `        ``# Get the max character from``        ``# the string``        ``mx ``=` `s[cr]``        ``for` `i ``in` `range``(cr ``+` `1``, n):``            ``mx ``=` `max``(mx, s[i])``        ``lst ``=` `cr` `        ``# Use all the occurrences of the``        ``# current maximum character``        ``for` `i ``in` `range``(cr,n):``            ``if` `(s[i] ``=``=` `mx):``                ``res ``+``=` `s[i]``                ``lst ``=` `i` `        ``# Repeat the steps for the``        ``# remaining string``        ``cr ``=` `lst ``+` `1``    ` `    ``return` `res` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``s ``=` `"geeksforgeeks"``    ``n ``=` `len``(s)``    ``print``(getSubSeq(s, n))` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to return the lexicographically``    ``// largest sub-sequence of s``    ``static` `String getSubSeq(String s, ``int` `n)``    ``{``        ``String res = ``""``;``        ``int` `cr = 0;``        ``while` `(cr < n)``        ``{` `            ``// Get the max character from``            ``// the String``            ``char` `mx = s[cr];``            ``for` `(``int` `i = cr + 1; i < n; i++)``            ``{``                ``mx = (``char``) Math.Max(mx, s[i]);``            ``}``            ``int` `lst = cr;` `            ``// Use all the occurrences of the``            ``// current maximum character``            ``for` `(``int` `i = cr; i < n; i++)``            ``{``                ``if` `(s[i] == mx)``                ``{``                    ``res += s[i];``                    ``lst = i;``                ``}``            ``}` `            ``// Repeat the steps for``            ``// the remaining String``            ``cr = lst + 1;``        ``}``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String s = ``"geeksforgeeks"``;``        ``int` `n = s.Length;``        ``Console.WriteLine(getSubSeq(s, n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## PHP

 ``

## Javascript

 ``
Output:
`ss`

Time Complexity: O(N) where N is the length of the string.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up