Open In App

# Lexicographically largest string for given dictionary order

Given an array arr[] of N strings and a string order which represents the new alphabetical order of the string. The task is to find the lexicographically largest string based on the given order.

Examples:

Input: arr[] = {“abc”, “abd”, “abz”}, order = “abczdefghijklmnopqrstuvwxy”
Output: abd
Explanation:
Compare two words “abc”, “abd”, the first non-matching character is c, d in the order, c comes before d so abd is largest among them.
Similarly, compare abd and abz.

Input: arr[] = {“abc”, “abdz”, “abd”}, order = “abcdefghijklmnopqrstuvwxyz”
Output: abdz
Explanation:
Among all the given strings abdz is the largest.

Naive Approach:

The idea is to check for each string if it is lexicographically largest among the given strings or not. If yes then print that string else check for the next string.

Steps that were to follow the above approach:

•    Define a function named “checkLargest” which takes two string arguments “s1” and “s2”, and an unordered_map “order” as input.
•    In the “checkLargest” function, compare the length of “s1” and “s2” and store it in n1 and n2 respectively.
•    Traverse both strings and find the first mismatching character and check if it is lexicographically largest or not using the unordered_map      “order”.
•    If all characters match and length of s1 is greater than s2, then s1 is lexicographically largest, so return true.
•    If no mismatching character is found, then return the length comparison result.
•    Define another function named “largestString” which takes a vector “arr” and a string “order” as input.
•    Inside the “largestString” function, create an unordered_map “mp” to store the order of characters using “order”.
•   Traverse all strings in the “arr” vector and compare each string with the current lexicographically largest string using the “checkLargest”       function.
•   If the current string is lexicographically larger than the current largest string, update the largest string with the current string.
•   Finally, return the largest string.
•   In the main function, define the input vector “arr” and string “order”.
•   Call the “largestString” function with “arr” and “order” as input and print the returned result.

Below is the code to implement the above steps:

## C++

 `// C++ program to find the lexicographically largest``// string based on the given order` `#include ``using` `namespace` `std;` `// Function to check if a string is lexicographically``// largest among the given strings or not``bool` `checkLargest(string s1, string s2,``                  ``unordered_map<``char``, ``int``>& order)``{``    ``int` `n1 = s1.size();``    ``int` `n2 = s2.size();` `    ``// Traverse both strings and find the first mismatching``    ``// character and check if it is lexicographically``    ``// largest or not``    ``for` `(``int` `i = 0; i < min(n1, n2); i++) {``        ``if` `(order[s1[i]] != order[s2[i]])``            ``return` `order[s1[i]] > order[s2[i]];``    ``}` `    ``// If all characters match and length of s1 is greater``    ``// than s2, then s1 is lexicographically largest``    ``if` `(n1 > n2)``        ``return` `true``;` `    ``return` `false``;``}` `// Function to find the lexicographically largest string``// based on the given order``string largestString(vector& arr, string order)``{``    ``// Create a hash map to store the order of characters``    ``unordered_map<``char``, ``int``> mp;``    ``for` `(``int` `i = 0; i < order.length(); i++)``        ``mp[order[i]] = i;` `    ``// Traverse all strings to find the lexicographically``    ``// largest string``    ``string ans = ``""``;``    ``for` `(string s : arr) {``        ``if` `(checkLargest(s, ans, mp))``            ``ans = s;``    ``}` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``// Given array of strings``    ``vector arr = { ``"abc"``, ``"abd"``, ``"abz"` `};` `    ``// Given alphabetical order``    ``string order = ``"abczdefghijklmnopqrstuvwxy"``;` `    ``// Function call to find the lexicographically``    ``// largest string based on the given order``    ``cout << largestString(arr, order) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to find the lexicographically largest``// string based on the given order` `import` `java.util.*;` `public` `class` `GFG {``    ``// Function to check if a string is lexicographically``    ``// largest among the given strings or not``    ``static` `boolean``    ``checkLargest(String s1, String s2,``                 ``HashMap order)``    ``{``        ``int` `n1 = s1.length();``        ``int` `n2 = s2.length();``        ``// Traverse both strings and find the first``        ``// mismatching``        ``// character and check if it is lexicographically``        ``// largest or not``        ``for` `(``int` `i = ``0``; i < Math.min(n1, n2); i++) {``            ``if` `(order.get(s1.charAt(i))``                ``!= order.get(s2.charAt(i)))``                ``return` `order.get(s1.charAt(i))``                    ``> order.get(s2.charAt(i));``        ``}` `        ``// If all characters match and length of s1 is``        ``// greater than s2, then s1 is lexicographically``        ``// largest``        ``if` `(n1 > n2)``            ``return` `true``;` `        ``return` `false``;``    ``}` `    ``// Function to find the lexicographically largest string``    ``// based on the given order``    ``static` `String largestString(List arr,``                                ``String order)``    ``{``        ``// Create a hash map to store the order of``        ``// characters``        ``HashMap mp = ``new` `HashMap<>();``        ``for` `(``int` `i = ``0``; i < order.length(); i++)``            ``mp.put(order.charAt(i), i);` `        ``// Traverse all strings to find the``        ``// lexicographically largest string``        ``String ans = ``""``;``        ``for` `(String s : arr) {``            ``if` `(checkLargest(s, ans, mp))``                ``ans = s;``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array of strings``        ``List arr``            ``= Arrays.asList(``"abc"``, ``"abd"``, ``"abz"``);` `        ``// Given alphabetical order``        ``String order = ``"abczdefghijklmnopqrstuvwxy"``;` `        ``// Function call to find the lexicographically``        ``// largest string based on the given order``        ``System.out.println(largestString(arr, order));``    ``}``}`

## Python3

 `from` `typing ``import` `List``from` `collections ``import` `defaultdict`  `def` `checkLargest(s1: ``str``, s2: ``str``, order: ``dict``) ``-``> ``bool``:``    ``n1, n2 ``=` `len``(s1), ``len``(s2)``    ``for` `i ``in` `range``(``min``(n1, n2)):``        ``if` `order[s1[i]] !``=` `order[s2[i]]:``            ``return` `order[s1[i]] > order[s2[i]]``    ``return` `n1 > n2`  `def` `largestString(arr: ``List``[``str``], order: ``str``) ``-``> ``str``:``    ``# Create a dictionary to store the order of characters``    ``mp ``=` `defaultdict(``int``)``    ``for` `i, char ``in` `enumerate``(order):``        ``mp[char] ``=` `i` `    ``# Traverse all strings to find the lexicographically largest string``    ``ans ``=` `''``    ``for` `s ``in` `arr:``        ``if` `checkLargest(s, ans, mp):``            ``ans ``=` `s``    ``return` `ans`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``# Given array of strings``    ``arr ``=` `[``'abc'``, ``'abd'``, ``'abz'``]` `    ``# Given alphabetical order``    ``order ``=` `'abczdefghijklmnopqrstuvwxy'` `    ``# Function call to find the lexicographically largest string``    ``print``(largestString(arr, order))`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``  ``// Function to check if a string is lexicographically``  ``// largest among the given strings or not``  ``static` `bool` `CheckLargest(``string` `s1, ``string` `s2,``                           ``Dictionary<``char``, ``int``> order)``  ``{``    ``int` `n1 = s1.Length;``    ``int` `n2 = s2.Length;` `    ``// Traverse both strings and find the first``    ``// mismatching character and check if it is``    ``// lexicographically largest or not``    ``for` `(``int` `i = 0; i < Math.Min(n1, n2); i++) {``      ``if` `(order[s1[i]] != order[s2[i]])``        ``return` `order[s1[i]] > order[s2[i]];``    ``}` `    ``// If all characters match and length of s1 is``    ``// greater than s2, then s1 is lexicographically``    ``// largest``    ``if` `(n1 > n2)``      ``return` `true``;` `    ``return` `false``;``  ``}` `  ``// Function to find the lexicographically largest string``  ``// based on the given order``  ``static` `string` `LargestString(List<``string``> arr,``                              ``string` `order)``  ``{``    ``// Create a dictionary to store the order of``    ``// characters``    ``Dictionary<``char``, ``int``> mp``      ``= ``new` `Dictionary<``char``, ``int``>();``    ``for` `(``int` `i = 0; i < order.Length; i++)``      ``mp[order[i]] = i;` `    ``// Traverse all strings to find the``    ``// lexicographically largest string``    ``string` `ans = ``""``;``    ``foreach``(``string` `s ``in` `arr)``    ``{``      ``if` `(CheckLargest(s, ans, mp))``        ``ans = s;``    ``}` `    ``return` `ans;``  ``}` `  ``static` `void` `Main(``string``[] args)``  ``{``    ``// Given array of strings``    ``List<``string``> arr``      ``= ``new` `List<``string``>{ ``"abc"``, ``"abd"``, ``"abz"` `};` `    ``// Given alphabetical order``    ``string` `order = ``"abczdefghijklmnopqrstuvwxy"``;` `    ``// Function call to find the lexicographically``    ``// largest string based on the given order``    ``Console.WriteLine(LargestString(arr, order));``  ``}``}`

## Javascript

 `function` `checkLargest(s1, s2, order) {``  ``let n1 = s1.length;``  ``let n2 = s2.length;` `  ``// Traverse both strings and find the first mismatching``  ``// character and check if it is lexicographically``  ``// largest or not``  ``for` `(let i = 0; i < Math.min(n1, n2); i++) {``    ``if` `(order[s1[i]] !== order[s2[i]]) {``      ``return` `order[s1[i]] > order[s2[i]];``    ``}``  ``}` `  ``// If all characters match and length of s1 is greater``  ``// than s2, then s1 is lexicographically largest``  ``if` `(n1 > n2) {``    ``return` `true``;``  ``}` `  ``return` `false``;``}` `function` `largestString(arr, order) {``  ``// Create a hash map to store the order of characters``  ``let mp = {};``  ``for` `(let i = 0; i < order.length; i++) {``    ``mp[order[i]] = i;``  ``}` `  ``// Traverse all strings to find the lexicographically``  ``// largest string``  ``let ans = ``""``;``  ``for` `(let s of arr) {``    ``if` `(checkLargest(s, ans, mp)) {``      ``ans = s;``    ``}``  ``}` `  ``return` `ans;``}` `// Driver code``let arr = [``"abc"``, ``"abd"``, ``"abz"``];``let order = ``"abczdefghijklmnopqrstuvwxy"``;` `// Function call to find the lexicographically``// largest string based on the given order``console.log(largestString(arr, order));`

Output

`abd`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The idea is to implement a comparator function according to the given string order find the string which is lexicographically largest. Below are the steps:

1. Create a map to store the index of the character in the given order of string.
2. Consider first string of the array as the lexicographically largest string as ans.
3. Now traverse the given string in the range [1, N] and compare each string with string ans using the indexes stored in the map.
4. Keep updating the largest lexicographically string in the above step and print the string.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include  ``using` `namespace` `std; ``  ` `int` `compare(string word1, string word2,``            ``int` `order[]);``            ` `// Find the lexicographically``// largest string``string largestString(string a[], ``int` `n,``                     ``string order)``{``    ` `    ``// Create a map of characters``    ``int` `map[26];` `    ``// Value of each character is``    ``// string is given priority``    ``// according to their occurrence``    ``// in the string``    ``for``(``int` `i = 0; i < order.length(); i++)``        ``map[order[i] - ``'a'``] = i;` `    ``// Take first String as maximum``    ``string ans = a[0];` `    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ` `        ``// Compare two strings each time``        ``if` `(compare(ans, a[i], map) < 0)``    ` `            ``// Update answer``            ``ans = a[i];``    ``}``    ``return` `ans;``}` `// Implement compare function``// to get the dictionary order``int` `compare(string word1, string word2,``            ``int` `order[])``{``    ``int` `i = 0, j = 0, charcompareval = 0;` `    ``while` `(i < word1.length() &&``           ``j < word2.length())``    ``{``        ` `        ``// Compare each char``        ``// according to the order``        ``charcompareval = order[word1[i] - ``'a'``] -``                         ``order[word2[i] - ``'a'``];``    ` `        ``// Find the first non matching``        ``// character in the string``        ``if` `(charcompareval != 0)``            ``return` `charcompareval;``            ` `        ``i++;``        ``j++;``    ``}` `    ``// If one word is prefix of``    ``// other return shortest word``    ``if` `(charcompareval == 0)``        ``return` `(word1.length() -``                ``word2.length());``    ``else``        ``return` `charcompareval;``}` `// Driver Code``int` `main()``{``    ``int` `n = 3;` `    ``// Given array of strings arr``    ``string arr[] = { ``"abc"``, ``"abd"``, ``"abz"` `};` `    ``// Given order of string``    ``string order = ``"abczdefghijklmnopqrstuvwxy"``;` `    ``// Function call``    ``string ans = largestString(arr, n, order);` `    ``cout << ans;``    ` `    ``return` `0;``}` `// This code is contributed by rutvik_56`

## Java

 `// Java program for the above approach` `import` `java.util.*;``public` `class` `Main {` `    ``// Find the lexicographically``    ``// largest string``    ``public` `static` `String``    ``largestString(String[] a, ``int` `n,``                ``String order)``    ``{``        ``// Create a map of characters``        ``int` `map[] = ``new` `int``[``26``];` `        ``// Value of each character is``        ``// string is given priority``        ``// according to their occurrence``        ``// in the string``        ``for` `(``int` `i = ``0``; i < order.length(); i++)``            ``map[order.charAt(i) - ``'a'``] = i;` `        ``// Take first String as maximum``        ``String ans = a[``0``];` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``// Compare two strings each time``            ``if` `(compare(ans, a[i], map) < ``0``)` `                ``// Update answer``                ``ans = a[i];``        ``}``        ``return` `ans;``    ``}` `    ``// Implement compare function``    ``// to get the dictionary order``    ``public` `static` `int``    ``compare(String word1, String word2,``            ``int``[] order)``    ``{``        ``int` `i = ``0``, j = ``0``, charcompareval = ``0``;` `        ``while` `(i < word1.length()``            ``&& j < word2.length()) {` `            ``// Compare each char``            ``// according to the order``            ``charcompareval``                ``= order[word1.charAt(i) - ``'a'``]``                ``- order[word2.charAt(i) - ``'a'``];` `            ``// Find the first non matching``            ``// character in the string``            ``if` `(charcompareval != ``0``)` `                ``return` `charcompareval;``            ``i++;``            ``j++;``        ``}` `        ``// If one word is prefix of``        ``// other return shortest word``        ``if` `(charcompareval == ``0``)``            ``return` `(word1.length()``                    ``- word2.length());``        ``else``            ``return` `charcompareval;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``3``;` `        ``// Given array of strings arr``        ``String arr[] = { ``"abc"``, ``"abd"``, ``"abz"` `};` `        ``// Given order of string``        ``String order``            ``= ``"abczdefghijklmnopqrstuvwxy"``;` `        ``// Function call``        ``String ans``            ``= largestString(arr, n, order);` `        ``System.out.println(ans);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Find the lexicographically``# largest string``def` `largestString(a, n, order):` `    ``# Create a map of characters``    ``map` `=` `[``0``] ``*` `26` `    ``# Value of each character is``    ``# string is given priority``    ``# according to their occurrence``    ``# in the string``    ``for` `i ``in` `range``(``len``(order)):``            ``map``[``ord``(order[i]) ``-` `ord``(``'a'``)] ``=` `i` `    ``# Take first String as maximum``    ``ans ``=` `a[``0``]` `    ``for` `i ``in` `range``(``1``, n):``        ` `        ``# Compare two strings each time``        ``if` `(compare(ans, a[i], ``map``) < ``0``):` `            ``# Update answer``            ``ans ``=` `a[i]``        ` `    ``return` `ans` `# Implement compare function``# to get the dictionary order``def` `compare(word1, word2, order):` `    ``i ``=` `0``    ``j ``=` `0``    ``charcompareval ``=` `0``;` `    ``while` `(i < ``len``(word1) ``and``        ``j < ``len``(word2)):` `        ``# Compare each char``        ``# according to the order``        ``charcompareval ``=` `(order[``ord``(word1[i]) ``-` `ord``(``'a'``)] ``-``                        ``order[``ord``(word2[i]) ``-` `ord``(``'a'``)])` `        ``# Find the first non matching``        ``# character in the string``        ``if` `(charcompareval !``=` `0``):``            ``return` `charcompareval``            ` `        ``i ``+``=` `1``        ``j ``+``=` `1` `    ``# If one word is prefix of``    ``# other return shortest word``    ``if` `(charcompareval ``=``=` `0``):``        ``return` `(``len``(word1) ``-` `len``(word2))``    ``else``:``        ``return` `charcompareval``    ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``n ``=` `3` `    ``# Given array of strings arr``    ``arr ``=` `[ ``"abc"``, ``"abd"``, ``"abz"` `]` `    ``# Given order of string``    ``order ``=` `"abczdefghijklmnopqrstuvwxy"` `    ``# Function call``    ``ans ``=` `largestString(arr, n, order)``    ` `    ``print``(ans)` `# This code is contributed by chitranayal`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `// Find the lexicographically``// largest string``public` `static` `String largestString(String[] a, ``int` `n,``                                    ``String order)``{``    ``// Create a map of characters``    ``int` `[]map = ``new` `int``[26];` `    ``// Value of each character is``    ``// string is given priority``    ``// according to their occurrence``    ``// in the string``    ``for` `(``int` `i = 0; i < order.Length; i++)``    ``map[order[i] - ``'a'``] = i;` `    ``// Take first String as maximum``    ``String ans = a[0];` `    ``for` `(``int` `i = 1; i < n; i++)``    ``{` `    ``// Compare two strings each time``    ``if` `(compare(ans, a[i], map) < 0)` `        ``// Update answer``        ``ans = a[i];``    ``}``    ``return` `ans;``}` `// Implement compare function``// to get the dictionary order``public` `static` `int` `compare(String word1,``                            ``String word2,``                            ``int``[] order)``{``    ``int` `i = 0, j = 0, charcompareval = 0;` `    ``while` `(i < word1.Length &&``        ``j < word2.Length)``    ``{` `    ``// Compare each char``    ``// according to the order``    ``charcompareval = order[word1[i] - ``'a'``] -``                    ``order[word2[i] - ``'a'``];` `    ``// Find the first non matching``    ``// character in the string``    ``if` `(charcompareval != 0)` `        ``return` `charcompareval;``    ``i++;``    ``j++;``    ``}` `    ``// If one word is prefix of``    ``// other return shortest word``    ``if` `(charcompareval == 0)``    ``return` `(word1.Length -``            ``word2.Length);``    ``else``    ``return` `charcompareval;``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``int` `n = 3;` `    ``// Given array of strings arr``    ``String []arr = { ``"abc"``, ``"abd"``, ``"abz"` `};` `    ``// Given order of string``    ``String order = ``"abczdefghijklmnopqrstuvwxy"``;` `    ``// Function call``    ``String ans = largestString(arr, n, order);` `    ``Console.WriteLine(ans);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`abd`

Time Complexity: O(N *max_word_length)
Auxiliary Space: O(1)