# Most frequent word in first String which is not present in second String

Given two string ‘S1’ and ‘S2’, the task is to return the most frequent (which is used the maximum number of times) word from ‘S1’ that is not present in ‘S2’. If more than one word is possible then print lexicographically smallest among them.

Examples:

Input: S1 = “geeks for geeks is best place to learn”, S2 = “bad place”
Output: geeks
“geeks” is the most frequent word in S1 and is also not present in S2.
The frequency of “geeks” is 2

Input: S1 = “the quick brown fox jumps over the lazy dog”, S2 = “the brown fox jumps”
Output: dog
All the words have frequency 1.
The lexicographically smallest word is “dog”

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The thought process must begin with the creation of a map to store key-value pair( string, int). Following this begins the extraction of the words from the first string while updating the map and the count. For every word from the second array that is present in the first array, reset the count. Finally, traverse the map and find the word with the highest frequency and get the lexicographically smallest one.

Algorithm:

1. Iterate through string S2 and create a map and insert all of the words in it to the map.
2. Iterate through string S1 and check whether the word is not present in the map created in the previous step or not.
3. If the word satisfies the condition then update the answer if the frequency of the same word is maximum till now.
4. If the frequency of the word is equal to the previously chosen word then update the answer according to lexicographically smallest of the two strings.

Below is the implementation of above approach:

 `// CPP implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return frequent ` `// word from S1 that isn't ` `// present in S2 ` `string smallestFreq(string S1, string S2) ` `{ ` ` `  `    ``map banned; ` ` `  `    ``// create map of banned words ` `    ``for` `(``int` `i = 0; i < S2.length(); ++i) { ` ` `  `        ``string s = ``""``; ` `        ``while` `(i < S2.length() && S2[i] != ``' '``) ` `            ``s += S2[i++]; ` ` `  `        ``banned[s]++; ` `    ``} ` ` `  `    ``map result; ` `    ``string ans; ` `    ``int` `freq = 0; ` ` `  `    ``// find smallest and most frequent word ` `    ``for` `(``int` `i = 0; i < S1.length(); ++i) { ` ` `  `        ``string s = ``""``; ` `        ``while` `(i < S1.length() && S1[i] != ``' '``) ` `            ``s += S1[i++]; ` ` `  `        ``// check if word is not banned ` `        ``if` `(banned[s] == 0) { ` `            ``result[s]++; ` `            ``if` `(result[s] > freq ` `                ``|| (result[s] == freq && s < ans)) { ` `                ``ans = s; ` `                ``freq = result[s]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``string S1 = ``"geeks for geeks is best place to learn"``; ` `    ``string S2 = ``"bad place"``; ` ` `  `    ``cout << smallestFreq(S1, S2); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of above approach  ` `import` `java.util.HashMap; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to return frequent ` `    ``// word from S1 that isn't ` `    ``// present in S2 ` `    ``static` `String smallestFreq(String S1, ` `                               ``String S2)  ` `    ``{ ` `        ``HashMap banned = ``new` `HashMap<>(); ` ` `  `        ``// create map of banned words ` `        ``for` `(``int` `i = ``0``; i < S2.length(); i++) ` `        ``{ ` `            ``String s = ``""``; ` `            ``while` `(i < S2.length() &&  ` `                       ``S2.charAt(i) != ``' '``) ` `                ``s += S2.charAt(i++); ` ` `  `            ``banned.put(s, banned.get(s) == ``null` `?  ` `                      ``1` `: banned.get(s) + ``1``); ` `        ``} ` ` `  `        ``HashMap result = ``new` `HashMap<>(); ` `        ``String ans = ``""``; ` `        ``int` `freq = ``0``; ` ` `  `        ``// find smallest and most frequent word ` `        ``for` `(``int` `i = ``0``; i < S1.length(); i++)  ` `        ``{ ` `            ``String s = ``""``; ` `            ``while` `(i < S1.length() &&  ` `                       ``S1.charAt(i) != ``' '``) ` `                ``s += S1.charAt(i++); ` ` `  `            ``// check if word is not banned ` `            ``if` `(banned.get(s) == ``null``) ` `            ``{ ` `                ``result.put(s, result.get(s) == ``null` `? ``1` `:  ` `                              ``result.get(s) + ``1``); ` `                ``if` `(result.get(s) > freq ||  ` `                   ``(result.get(s) == freq &&  ` `                    ``s.compareTo(ans) < ``0``)) ` `                ``{ ` `                    ``ans = s; ` `                    ``freq = result.get(s); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// return answer ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String S1 = ``"geeks for geeks is best place to learn"``; ` `        ``String S2 = ``"bad place"``; ` `        ``System.out.println(smallestFreq(S1, S2)); ` `    ``} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

 `# Python3 implementation of above approach  ` `from` `collections ``import` `defaultdict ` ` `  `# Function to return frequent  ` `# word from S1 that isn't  ` `# present in S2  ` `def` `smallestFreq(S1, S2):  ` ` `  `    ``banned ``=` `defaultdict(``lambda``:``0``) ` `     `  `    ``i ``=` `0` `     `  `    ``# create map of banned words  ` `    ``while` `i < ``len``(S2):  ` ` `  `        ``s ``=` `""  ` `        ``while` `i < ``len``(S2) ``and` `S2[i] !``=` `' '``:  ` `            ``s ``+``=` `S2[i] ` `            ``i ``+``=` `1` `             `  `        ``i ``+``=` `1` `        ``banned[s] ``+``=` `1` ` `  `    ``result ``=` `defaultdict(``lambda``:``0``)  ` `    ``ans ``=` `"" ` `    ``freq ``=` `0` `    ``i ``=` `0` `     `  `    ``# find smallest and most frequent word  ` `    ``while` `i < ``len``(S1):  ` ` `  `        ``s ``=` `""  ` `        ``while` `i < ``len``(S1) ``and` `S1[i] !``=` `' '``:  ` `            ``s ``+``=` `S1[i] ` `            ``i ``+``=` `1` `         `  `        ``i ``+``=` `1` `         `  `        ``# check if word is not banned  ` `        ``if` `banned[s] ``=``=` `0``: ` `            ``result[s] ``+``=` `1` `             `  `            ``if` `(result[s] > freq ``or`  `               ``(result[s] ``=``=` `freq ``and` `s < ans)): ` `                ``ans ``=` `s  ` `                ``freq ``=` `result[s]  ` `             `  `    ``# return answer  ` `    ``return` `ans  ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``S1 ``=` `"geeks for geeks is best place to learn"` `    ``S2 ``=` `"bad place"` ` `  `    ``print``(smallestFreq(S1, S2))  ` ` `  `# This code is contributed  ` `# by Rituraj Jain `

 `// C# implementation of above approach ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `class` `GFG  ` `{ ` ` `  `    ``// Function to return frequent ` `    ``// word from S1 that isn't ` `    ``// present in S2 ` `    ``static` `String smallestFreq(String S1, ` `                               ``String S2)  ` `    ``{ ` `        ``Dictionary banned = ``new` `Dictionary(); ` ` `  `        ``// create map of banned words ` `        ``for` `(``int` `i = 0; i < S2.Length; i++) ` `        ``{ ` `            ``String s = ``""``; ` `            ``while` `(i < S2.Length &&  ` `                    ``S2[i] != ``' '``) ` `                ``s += S2[i++]; ` ` `  `            ``if``(banned.ContainsKey(s)) ` `            ``{ ` `                ``var` `val = banned[s]; ` `                ``banned.Remove(s); ` `                ``banned.Add(s, val + 1);  ` `            ``} ` `            ``else` `            ``{ ` `                ``banned.Add(s, 1); ` `            ``} ` `        ``} ` ` `  `        ``Dictionary result = ``new` `Dictionary(); ` `        ``String ans = ``""``; ` `        ``int` `freq = 0; ` ` `  `        ``// find smallest and most frequent word ` `        ``for` `(``int` `i = 0; i < S1.Length; i++)  ` `        ``{ ` `            ``String s = ``""``; ` `            ``while` `(i < S1.Length &&  ` `                    ``S1[i] != ``' '``) ` `                ``s += S1[i++]; ` ` `  `            ``// check if word is not banned ` `            ``if` `(!banned.ContainsKey(s)) ` `            ``{ ` `                ``if``(result.ContainsKey(s)) ` `                ``{ ` `                    ``var` `val = result[s]; ` `                    ``result.Remove(s); ` `                    ``result.Add(s, val + 1);  ` `                ``} ` `                ``else` `                ``{ ` `                    ``result.Add(s, 1); ` `                ``} ` `                ``if` `(result[s] > freq ||  ` `                   ``(result[s] == freq &&  ` `                    ``s.CompareTo(ans) < 0)) ` `                ``{ ` `                    ``ans = s; ` `                    ``freq = result[s]; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// return answer ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``String S1 = ``"geeks for geeks is best place to learn"``; ` `        ``String S2 = ``"bad place"``; ` `        ``Console.WriteLine(smallestFreq(S1, S2)); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:
```geeks
```

Complexity Analysis:

• Time Complexity: O(n), where n is the length of the string.
A single traversal of the string is needed.
• Space Complexity: O(n).
There can be at most n words in a string. The map requires O(n) space to store the strings.

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :