Related Articles

# Find the first repeated word in a string

• Difficulty Level : Medium
• Last Updated : 04 Aug, 2021

Given a string, Find the 1st repeated word in a string
Examples:

```Input : "Ravi had been saying that he had been there"

Input : "Ravi had been saying that"
Output : No Repetition

Output : he```

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.

Simple Approach : Start iterating from back and for every new word , store it in unordered map . For every word which has occured more than one  , update ans to be that word , at last reverse ans and print it.

## C++

 `// Cpp program to find first repeated word in a string``#include``using` `namespace` `std;``void` `solve(string s)``{``    ``unordered_map mp;  ``// to store occurences of word``    ``string t=``""``,ans=``""``;``    ``// traversing from back makes sure that we get the word which repeats first as ans``    ``for``(``int` `i=s.length()-1;i>=0;i--)``    ``{``        ``// if char present , then add that in temp word string t``        ``if``(s[i]!=``' '``)``        ``{``            ``t+=s[i];``            ` `        ``}``        ``// if space is there then this word t needs to stored in map``        ``else``        ``{``            ``mp[t]++;``            ``// if that string t has occured previously then it is a possible ans``            ``if``(mp[t]>1)``               ``ans=t;``            ``// set t as empty for again new word  ``            ``t=``""``;``            ` `        ``}``    ``}``    ` `    ``// first word like "he" needs to be mapped``            ``mp[t]++;``            ``if``(mp[t]>1)``               ``ans=t;``                          ` `    ``if``(ans!=``""``)``    ``{``        ``// reverse ans string as it has characters in reverse order``        ``reverse(ans.begin(),ans.end());``        ``cout<
Output
```had
No Repetition
he
```

Another Approach: The idea is to tokenize the string and store each word and its count in hashmap. Then traverse the string again and for each word of string, check its count in created hashmap.

## CPP

 `// CPP program for finding first repeated``// word in a string``#include ``using` `namespace` `std;` `// returns first repeated word``string findFirstRepeated(string s)``{``    ``// break string into tokens``    ``// and then each string into set``    ``// if a word appeared before appears``    ``// again, return the word and break` `    ``istringstream iss(s);``    ``string token;` `    ``// hashmap for storing word and its count``    ``// in sentence``    ``unordered_map setOfWords;` `    ``// store all the words of string``    ``// and the count of word in hashmap` `    ``while` `(getline(iss, token, ``' '``)) {``        ``if` `(setOfWords.find(token) != setOfWords.end())            ``            ``setOfWords[token] += 1;  ``// word exists``        ``else``            ``// insert new word to set``            ``setOfWords.insert(make_pair(token, 1));       ``    ``}` `    ``// traverse again from first word of string s``    ``// to check if count of word is greater than 1` `    ``// either take a new stream or store the words``    ``// in vector of strings in previous loop``    ``istringstream iss2(s);``    ``while` `(getline(iss2, token, ``' '``)) {``        ``int` `count = setOfWords[token];``        ``if` `(count > 1) {``            ``return` `token;``        ``}``    ``}` `    ``return` `"NoRepetition"``;``}` `// driver program``int` `main()``{``    ``string s(``"Ravi had been saying that he had been there"``);``    ``string firstWord = findFirstRepeated(s);``    ``if` `(firstWord != ``"NoRepetition"``)``        ``cout << ``"First repeated word :: "``             ``<< firstWord << endl;``    ``else``        ``cout << ``"No Repetitionn"``;``    ``return` `0;``}`

## Java

 `// Java program for finding first repeated``// word in a string``import` `java.util.*;` `class` `GFG{``    ` `    ``// returns first repeated word``    ``static` `String findFirstRepeated(String s)``    ``{``        ``// break string into tokens``        ``// and then each string into set``        ``// if a word appeared before appears``        ``// again, return the word and break``    ` `        ``String token[] = s.split(``" "``);``    ` `        ``// hashmap for storing word and its count``        ``// in sentence``        ``HashMap setOfWords = ``new` `HashMap();``    ` `        ``// store all the words of string``        ``// and the count of word in hashmap``    ` `        ``for` `(``int` `i=``0``; i ``1``) {``                ``return` `token[i];``            ``}``        ``}``    ` `        ``return` `"NoRepetition"``;``    ``}``    ` `    ``// driver program``    ``public` `static` `void` `main(String args[])``    ``{``        ``String s = ``"Ravi had been saying that he had been there"``;``        ``String firstWord = findFirstRepeated(s);``        ``if` `(!firstWord.equals(``"NoRepetition"``))``            ``System.out.println(``"First repeated word :: "` `+ firstWord);``        ``else``            ``System.out.println(``"No Repetitionn"``);``    ``}``}`
Output
```First repeated word :: had
```

#### Method #2: Using built in python functions:

• As all the words in a sentence are separated by spaces.
• We have to split the sentence by spaces using split().
• We split all the words by spaces and store them in a list.
• Use Counter function to count frequency of words
• Traverse the list and check if any word has frequency greater than 1
• If it is present then print the word and break the loop

Below is the implementation:

## Python3

 `# Python program for the above approach``from` `collections ``import` `Counter` `# Python program to find the first``# repeated character in a string``def` `firstRepeatedWord(sentence):` `    ``# spliting the string``    ``lis ``=` `list``(sentence.split(``" "``))``    ` `    ``# Calculating frequency of every word``    ``frequency ``=` `Counter(lis)``    ` `    ``# Traversing the list of words``    ``for` `i ``in` `lis:``      ` `        ``# checking if frequency is greater than 1``        ` `        ``if``(frequency[i] > ``1``):``            ``# return the word``            ``return` `i`  `# Driver code``sentence ``=` `"Vikram had been saying that he had been there"``print``(firstRepeatedWord(sentence))``# this code is contributed by vikkycirus`
Output
```had
```

### Optimized Approach:

Instead of counting a number of occurrences of each word which will have O(N) time and space complexity, where N is number of words, we can stop when the count of any word becomes 2. That is no need to iterate through all the words in string.

Let’s say our first repeated word is present at Mth index, then

By using this approach, space and time complexity reduced from O(N) to O(M).

Where,

N: number of words in a string.

M: Index at which first repeating word is present

However, Worst case( When no word is being repeated or the word being repeated is present at last) time and space complexity will still be O(N).

Steps:

• Create a default dictionary with an initial value of 0, to keep track count of words.
• Iterate through each word in a sentence and increment the count of that word by 1.
• If (count of the word) > 1, return the word.
• If the count of none of the words is greater than 1 then that is we are outside our loop then return “No word is being repeated”.

## Python3

 `# Import defaultdict from Collections module``from` `collections ``import` `defaultdict` `def` `first_repeating_word(s):` `    ``# Creating a defaultdict with``    ``# default values as 0.``    ``# Every word will have an``    ``# initial count of 0``    ``word_count ``=` `defaultdict(``lambda``: ``0``)` `    ``# Iterating through all words in string.``    ``for` `i ``in` `s.split():` `        ``# Increment the word count of``        ``# the word we encounter by 1``        ``word_count[i] ``+``=` `1` `        ``# If word_count of current word``        ``# is more than 1, we got our answer, return it.``        ``if` `word_count[i] > ``1``:``            ``return` `i` `    ``# If program has reached here that``    ``# means no word is being repeated``    ``return` `'No word is being repeated'`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``s ``=` `"Ravi had been saying that he had been there"``    ``print``(first_repeating_word(s))` `    ``# This code is contributed by Anurag Mishra`
Output
```had
```

Time complexity: O(M)

Space Complexity: O(M)

### Optimized Approach 2:

Instead of counting a number of occurrences of each word which will have O(N) time and space complexity, where N is a number of words, we can just store words in a HashSet, and as soon as we reach a word that is already present in the HashSet we can return.

## Java

 `// Java program for finding first repeated``// word in a string``import` `java.util.*;` `public` `class` `GFG{``    ` `    ``// returns first repeated word``    ``static` `String findFirstRepeated(String s)``    ``{``        ``// break string into tokens``        ``String token[] = s.split(``" "``);``        ` `        ``// hashset for storing words``        ``HashSet set = ``new` `HashSet();``        ` `        ``// store the words of string in hashset``        ``for``(``int` `i=``0``; i

## C++

 `// CPP program for finding first repeated``// word in a string``#include ``using` `namespace` `std;` `// returns first repeated word``string findFirstRepeated(string s)``{``    ``// break string into tokens``    ``// and then each string into set``    ``// if a word appeared before appears``    ``// again, return the word and break` `    ``istringstream iss(s);``    ``string token;` `    ``// hashset for storing word and its count``    ``// in sentence``    ``set setOfWords;` `    ``// store all the words of string``    ``// and the count of word in hashset` `    ``while` `(getline(iss, token, ``' '``)) {``        ``// if word exists return``        ``if` `(setOfWords.find(token) != setOfWords.end()) {``            ``return` `token;``        ``}` `        ``// insert new word to set``        ``setOfWords.insert(token);``    ``}` `    ``return` `"NoRepetition"``;``}` `// driver program``int` `main()``{``    ``string s(``"Ravi had been saying that he had been there"``);``    ``string firstWord = findFirstRepeated(s);``    ``if` `(firstWord != ``"NoRepetition"``)``        ``cout << ``"First repeated word :: "` `<< firstWord``             ``<< endl;``    ``else``        ``cout << ``"No Repetitionn"``;``    ``return` `0;``}`
Output
```First repeated word :: had
```

This article is contributed by Mandeep Singh. 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.