Open In App
Related Articles

Find the first repeated word in a string

Improve Article
Improve
Save Article
Save
Like Article
Like

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

Examples: 

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

question source : https://www.geeksforgeeks.org/goldman-sachs-interview-experience-set-29-internship/

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

Implementation:

C++




// Cpp program to find first repeated word in a string
#include<bits/stdc++.h>
using namespace std;
void solve(string s)
{
    unordered_map<string,int> mp;  // to store occurrences 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 occurred 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<<ans<<'\n';
    }
    else
    cout<<"No Repetition\n";
}
int main()
{
    string u="Ravi had been saying that he had been there";
    string v="Ravi had been saying that";
    string w="he had had he";
    solve(u);
    solve(v);
    solve(w);
     
     
    return 0;
     
}


Java




import java.util.*;
 
public class GFG {
  // Java  program to find first repeated word in a string
  public static void solve(String s)
  {
    HashMap<String, Integer> mp
      = new HashMap<String,
    Integer>(); // to store
    // occurrences of word
    String t = "";
    String 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.charAt(i) != ' ') {
        t += s.charAt(i);
      }
      // if space is there then this word t needs to
      // stored in map
      else {
        if (!mp.containsKey(t)) {
          mp.put(t, 1);
        }
        else {
          mp.put(t, mp.get(t) + 1);
        }
 
        // if that string t has occurred previously
        // then it is a possible ans
        if (mp.get(t) > 1) {
          ans = t;
        }
        // set t as empty for again new word
        t = "";
      }
    }
 
    // first word like "he" needs to be mapped
    if (!mp.containsKey(t)) {
      mp.put(t, 1);
    }
    else {
      mp.put(t, mp.get(t) + 1);
    }
    if (mp.get(t) > 1) {
      ans = t;
    }
 
    if (!ans.equals("")) {
      // reverse ans string as it has characters in
      // reverse order
      StringBuilder input1 = new StringBuilder();
 
      // append a string into StringBuilder input1
      input1.append(ans);
 
      // reverse StringBuilder input1
      input1.reverse();
 
      System.out.println(input1);
    }
    else {
      System.out.print("No Repetition\n");
    }
  }
  public static void main(String[] args)
  {
    String u
      = "Ravi had been saying that he had been there";
    String v = "Ravi had been saying that";
    String w = "he had had he";
    solve(u);
    solve(v);
    solve(w);
  }
}
 
// This code is contributed by Aarti_Rathi


Python3




# Python program to find first repeated word in a string
def solve(s):
 
    mp = {} # to store occurrences of word
    t = ""
    ans = ""
     
    # traversing from back makes sure that we get the word which repeats first as ans
    for i in range(len(s) - 1,-1,-1):
       
        # 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:
         
            # if that string t has occurred previously then it is a possible ans
            if(t in mp):
                ans = t
            else:
                mp[t] = 1
             
            # set t as empty for again new word
            t = ""
             
    # first word like "he" needs to be mapped
    if(t in mp):
        ans=t
                         
    if(ans!=""):
 
        # reverse ans string as it has characters in reverse order
        ans = ans[::-1]
        print(ans)
    else:
        print("No Repetition")
 
# driver code
u = "Ravi had been saying that he had been there"
v = "Ravi had been saying that"
w = "he had had he"
solve(u)
solve(v)
solve(w)
 
# This code is contributed by shinjanpatra


C#




// C# program to find first repeated word in a string
using System;
using System.Collections.Generic;
 
class GFG {
  static void solve(string s)
  {
    Dictionary<string, int> mp = new Dictionary<
      string, int>(); // to store occurrences of word
    string t = "";
    string 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 {
        if (mp.ContainsKey(t)) {
          mp[t] += 1;
        }
        else {
          mp.Add(t, 1);
        }
        // if that string t has occurred 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
    if (mp.ContainsKey(t)) {
      mp[t] += 1;
    }
    else {
      mp.Add(t, 1);
    }
 
    if (mp[t] > 1) {
      ans = t;
    }
 
    if (ans != "") {
      // reverse ans string as it has characters in
      // reverse order
      char[] charArray = ans.ToCharArray();
      Array.Reverse(charArray);
      Console.WriteLine(new string(charArray));
    }
    else {
      Console.Write("No Repetition\n");
    }
  }
  public static void Main()
  {
    string u
      = "Ravi had been saying that he had been there";
    string v = "Ravi had been saying that";
    string w = "he had had he";
    solve(u);
    solve(v);
    solve(w);
  }
}
 
// This code is contributed by Aarti_Rathi


Javascript




<script>
// JavaScript program to find first repeated word in a string
 
function solve(s)
{
    let mp = new Map();  // to store occurrences of word
    let t = "";
    let ans = "";
     
    // traversing from back makes sure that we get the word which repeats first as ans
    for(let 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
        {
         
            // if that string t has occurred previously then it is a possible ans
            if(mp.has(t))
               ans = t;
            else mp.set(t, 1)
             
            // set t as empty for again new word  
            t = "";
             
        }
    }
     
    // first word like "he" needs to be mapped
    if(mp.has(t)) ans=t;
                           
    if(ans!="")
    {
        // reverse ans string as it has characters in reverse order
        ans = [...ans].reverse().join("");
        document.write(ans);
    }
    else
    document.write("No Repetition");
}
 
// driver code
const u = "Ravi had been saying that he had been there";
const v = "Ravi had been saying that";
const w = "he had had he";
solve(u);
solve(v);
solve(w);
 
// This code is contributed by shinjanpatra
</script>


Output

had
No Repetition
he










Time complexity: O(N),because of for loop
Space Complexity: O(N),because of unordered_map/hashmap

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. 

Implementation:

CPP




// CPP program for finding first repeated
// word in a string
#include <bits/stdc++.h>
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<string, int> 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<String, Integer> setOfWords = new HashMap<String, Integer>();
     
        // store all the words of string
        // and the count of word in hashmap
     
        for (int i=0; i<token.length; i++) {
            if (setOfWords.containsKey(token[i]))           
                setOfWords.put(token[i], setOfWords.get(token[i]) + 1); // word exists
            else
                // insert new word to set
                setOfWords.put(token[i], 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
        for (int i=0; i<token.length; i++) {
            int count = setOfWords.get(token[i]);
            if (count > 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");
    }
}


Python3




class GFG:
    # returns first repeated word
    @staticmethod
    def findFirstRepeated(s):
        # break string into tokens
        # and then each string into set
        # if a word appeared before appears
        # again, return the word and break
        token = s.split(" ")
         
        # map for storing word and its count
        # in sentence
        setOfWords = {}
         
        # store all the words of string
        # and the count of word in map
        for i in range(len(token)):
            if token[i] in setOfWords:
                setOfWords[token[i]] += 1
            else:
                # insert new word to map
                setOfWords[token[i]] = 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 array of strings in previous loop
        for i in range(len(token)):
            count = setOfWords[token[i]]
            if count > 1:
                return token[i]
         
        return "NoRepetition"
     
    # driver program
    @staticmethod
    def main(args):
        s = "Ravi had been saying that he had been there"
        firstWord = GFG.findFirstRepeated(s)
        if firstWord != "NoRepetition":
            print("First repeated word :: " + firstWord)
        else:
            print("No Repetition")
     
GFG.main([])
 
 
# This code is contributed by adityashatmfh


C#




// C# program for finding first repeated
// word in a string
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
 
class HelloWorld {
     
    // returns first repeated word
    public 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
        Dictionary<string, int> setOfWords = new Dictionary<string,int>();
 
        // store all the words of string
        // and the count of word in map
        for (int i=0; i < token.Length; i++)
        {
            if (setOfWords.ContainsKey(token[i]) == true)
            {
                setOfWords[token[i]] = setOfWords[token[i]] + 1;
            }
            else
            {
                // insert new word to map
                setOfWords.Add(token[i], 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 array of strings in previous loop
        for (int i=0; i < token.Length; i++)
        {
            int count = setOfWords[token[i]];
            if (count > 1)
            {
                return token[i];
            }
        }
        return "NoRepetition";
    }   
 
    static void Main() {
        string s = "Ravi had been saying that he had been there";
        string firstWord = findFirstRepeated(s);
        if (firstWord != "NoRepetition")
            Console.WriteLine("First repeated word :: "  + firstWord);
        else
            Console.WriteLine("No Repitition");
    }
}
 
// The code is contributed by Nidhi goel.


Javascript




class GFG
{
    // returns first repeated word
    static findFirstRepeated(s)
    {
        // break string into tokens
        // and then each string into set
        // if a word appeared before appears
        // again, return the word and break
        var token = s.split(" ");
         
        // map for storing word and its count
        // in sentence
        var setOfWords = new Map();
        // store all the words of string
        // and the count of word in map
        for (let i=0; i < token.length; i++)
        {
            if (setOfWords.has(token[i]))
            {
                setOfWords.set(token[i],setOfWords.get(token[i]) + 1);
            }
            else
            {
                // insert new word to map
                setOfWords.set(token[i],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 array of strings in previous loop
        for (let i=0; i < token.length; i++)
        {
            var count = setOfWords.get(token[i]);
            if (count > 1)
            {
                return token[i];
            }
        }
        return "NoRepetition";
    }
    // driver program
    static main(args)
    {
        var s = "Ravi had been saying that he had been there";
        var firstWord = GFG.findFirstRepeated(s);
        if (firstWord !== "NoRepetition")
        {
            console.log("First repeated word :: " + firstWord);
        }
        else
        {
            console.log("No Repetitionn");
        }
    }
}
GFG.main([]);
 
// This code is contributed by mukulsomukesh


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

Implementation::

C++




#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
 
using namespace std;
 
string firstRepeatedWord(string sentence)
{
    // Splitting the string into words
    vector<string> words;
    size_t pos = 0;
    while ((pos = sentence.find(' ')) != string::npos)
    {
        string word = sentence.substr(0, pos);
        words.push_back(word);
        sentence.erase(0, pos + 1);
    }
    words.push_back(sentence); // Add the last word
 
    // Calculating the frequency of each word
    unordered_map<string, int> frequency;
    for (size_t i = 0; i < words.size(); i++)
    {
        string word = words[i];
        if (frequency.find(word) == frequency.end())
        {
            frequency[word] = 1;
        }
        else
        {
            frequency[word]++;
        }
    }
 
    // Traversing the list of words
    for (size_t i = 0; i < words.size(); i++)
    {
        string word = words[i];
        // Checking if the frequency is greater than 1
        if (frequency[word] > 1)
        {
            // Return the word
            return word;
        }
    }
 
    // If no repeated word is found
    return "No repeated word found";
}
 
int main()
{
    string sentence = "Vikram had been saying that he had been there";
    cout << firstRepeatedWord(sentence) << endl;
    return 0;
}
 
// This code is contributed by akshitaguprzj3


Java




import java.util.*; 
 
class GFG
{
  public static String firstRepeatedWord(String sentence)
  {
    // splitting the string
    String[] lis = sentence.split(" ");
 
    // Calculating frequency of every word
    Map<String, Integer> frequency = new HashMap<>();
    for (int i = 0; i < lis.length; i++)
    {
      String word = lis[i];
      if (!frequency.containsKey(word))
      {
        frequency.put(word, 1);
      }
      else
      {
        frequency.put(word, frequency.get(word) + 1);
      }
    }
 
    // Traversing the list of words
    for (int i = 0; i < lis.length; i++)
    {
      String word = lis[i];
      // checking if frequency is greater than 1
      if (frequency.get(word) > 1)
      {
        // return the word
        return word;
      }
    }
 
    // if no repeated word is found
    return "No repeated word found";
  }
 
  // Driver code
  public static void main(String[] args)
  {
    String sentence = "Vikram had been saying that he had been there";
    System.out.println(firstRepeatedWord(sentence));
  }
 
}


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):
 
    # splitting 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


C#




using System;
using System.Collections.Generic;
 
class Program
{
    static string FirstRepeatedWord(string sentence)
    {
        // Splitting the string into words
        List<string> words = new List<string>();
        int pos;
        while ((pos = sentence.IndexOf(' ')) != -1)
        {
            string word = sentence.Substring(0, pos);
            words.Add(word);
            sentence = sentence.Remove(0, pos + 1);
        }
        words.Add(sentence); // Add the last word
 
        // Calculating the frequency of each word
        Dictionary<string, int> frequency = new Dictionary<string, int>();
        foreach (string word in words)
        {
            if (!frequency.ContainsKey(word))
            {
                frequency[word] = 1;
            }
            else
            {
                frequency[word]++;
            }
        }
 
        // Traversing the list of words
        foreach (string word in words)
        {
            // Checking if the frequency is greater than 1
            if (frequency[word] > 1)
            {
                // Return the word
                return word;
            }
        }
 
        // If no repeated word is found
        return "No repeated word found";
    }
 
    static void Main()
    {
        string sentence = "Vikram had been saying that he had been there";
        Console.WriteLine(FirstRepeatedWord(sentence));
    }
}
 
// This code is contributed by shivamgupta0987654321


Javascript




// JavaScript program to find the first repeated word in a string
function firstRepeatedWord(sentence) {
  // splitting the string
  let lis = sentence.split(" ");
   
  // Calculating frequency of every word
  let frequency = {};
  for (let i = 0; i < lis.length; i++) {
    let word = lis[i];
    if (!frequency[word]) {
      frequency[word] = 1;
    } else {
      frequency[word]++;
    }
  }
   
  // Traversing the list of words
  for (let i = 0; i < lis.length; i++) {
    let word = lis[i];
     
    // checking if frequency is greater than 1
    if (frequency[word] > 1) {
      // return the word
      return word;
    }
  }
}
 
// Driver code
let sentence = "Vikram had been saying that he had been there";
console.log(firstRepeatedWord(sentence));
 
 
// This code is contributed by princekumaras


Output

had










Another Approach: 

Instead of tracking the counts for a specific token(word), we can keep track of the first occurrence of the token(word) using an unordered map. This would not require any extra loop to traverse in a hashmap or a string to find the repeated string. Thus, it eventually transforms the time complexity from O(2*n) to O(n) while the space complexity remains the same.

Implementation:

C++




// CPP program to find first repeated word in a string.
#include <bits/stdc++.h>
using namespace std;
 
void solve(string s)
{
    int n = s.size(); // size of the string.
    unordered_map<string, int>
        mp; // To store first occurrence of a word.
    string ans = "", t = "";
    int min_idx = INT_MAX; // To get minimum occurrence in
                           // the given string.
 
    int i = 0,
        j = 0; // iterators. i -> initial index of a word
               //            j -> final index of a word.
 
    // loop to traverse in a string and to find out each
    // repeated word whose occurrence is minimum.
    while (j <= n) {
 
        // If found an entire word then check if it is
        // repeated or not using unordered_map.
        if (s[j] == ' ' || j == n) {
            if (mp[t] == 0) { // Store the first occurrence
                              // of a word.
                mp[t] = i + 1;
            }
            else { // If there is a Repetition then check
                   // for minimum occurrence of the word.
                if (min_idx > mp[t]) {
                    min_idx = mp[t];
                    ans = t;
                }
            }
 
            // Shift the pointers.
            t = "";
            i = j + 1;
            j = i;
        }
        else {
            t += s[j];
            j++;
        }
    }
 
    // If ans is of empty string then this signifies that
    // there is no Repetition.
    if (ans == "")
        cout << "No Repetition" << endl;
    else
        cout << ans << endl;
}
 
int main()
{
    string s1
        = "Ravi had been saying that he had been there";
    string s2 = "Ravi had been saying that";
    string s3 = "he had had he";
 
    solve(s1);
    solve(s2);
    solve(s3);
 
    return 0;
}


Java




// Java program to find first repeated word in a string.
 
import java.io.*;
import java.util.*;
 
import java.util.*;
 
public class Main {
     
    public static void solve(String s) {
        int n = s.length(); // size of the string.
        Map<String, Integer> mp = new HashMap<>(); // To store first occurrence of a word.
        String ans = "", t = "";
        int min_idx = Integer.MAX_VALUE; // To get minimum occurrence in the given string.
 
        int i = 0, j = 0; // iterators. i -> initial index of a word, j -> final index of a word.
 
        // loop to traverse in a string and to find out each
        // repeated word whose occurrence is minimum.
        while (j <= n) {
 
            // If found an entire word then check if it is
            // repeated or not using unordered_map.
            if (j == n || s.charAt(j) == ' ') {
                if (mp.getOrDefault(t, 0) == 0) { // Store the first occurrence of a word.
                    mp.put(t, i + 1);
                }
                else { // If there is a repetition then check for minimum occurrence of the word.
                    if (min_idx > mp.get(t)) {
                        min_idx = mp.get(t);
                        ans = t;
                    }
                }
 
                // Shift the pointers.
                t = "";
                i = j + 1;
                j = i;
            }
            else {
                t += s.charAt(j);
                j++;
            }
        }
 
        // If ans is an empty string then this signifies that
        // there is no Repetition.
        if (ans.equals(""))
            System.out.println("No Repetition");
        else
            System.out.println(ans);
    }
 
    public static void main(String[] args) {
        String s1 = "Ravi had been saying that he had been there";
        String s2 = "Ravi had been saying that";
        String s3 = "he had had he";
 
        solve(s1);
        solve(s2);
        solve(s3);
    }
}
 
// The code is contributed by Arushi Goel.


Python3




def find_first_repeated_word(s):
    n = len(s)  # Size of the string.
    mp = {}  # To store the first occurrence of a word.
    ans = ""
    t = ""
    min_idx = float('inf'# To get the minimum occurrence in the given string.
 
    i = 0
    j = 0  # Iterators: i -> initial index of a word, j -> final index of a word.
 
    # Loop to traverse the string and find each repeated word whose occurrence is minimum.
    while j <= n:
        # If found an entire word, then check if it is repeated or not using a dictionary.
        if j == n or s[j] == ' ':
            if t not in mp:
                mp[t] = i + 1  # Store the first occurrence of a word.
            else:
                # If there is a repetition, then check for the minimum occurrence of the word.
                if min_idx > mp[t]:
                    min_idx = mp[t]
                    ans = t
 
            # Shift the pointers.
            t = ""
            i = j + 1
            j = i
        else:
            t += s[j]
            j += 1
 
    # If ans is an empty string, it signifies that there is no repetition.
    if ans == "":
        print("No Repetition")
    else:
        print(ans)
 
# Test cases
s1 = "Ravi had been saying that he had been there"
s2 = "Ravi had been saying that"
s3 = "he had had he"
 
find_first_repeated_word(s1)
find_first_repeated_word(s2)
find_first_repeated_word(s3)
 
# This code is contributed by shivamgupta310570


C#




using System;
using System.Collections.Generic;
 
public class MainClass
{
    public static void Solve(string s)
    {
        int n = s.Length; // size of the string.
        Dictionary<string, int> mp = new Dictionary<string, int>(); // To store first occurrence of a word.
        string ans = "", t = "";
        int min_idx = int.MaxValue; // To get minimum occurrence in the given string.
 
        int i = 0, j = 0; // iterators. i -> initial index of a word, j -> final index of a word.
 
        // loop to traverse in a string and to find out each
        // repeated word whose occurrence is minimum.
        while (j <= n)
        {
            // If found an entire word then check if it is
            // repeated or not using Dictionary.
            if (j == n || s[j] == ' ')
            {
                if (!mp.ContainsKey(t))
                {
                    mp[t] = i + 1; // Store the first occurrence of a word.
                }
                else
                {
                    // If there is a repetition then check for minimum occurrence of the word.
                    if (min_idx > mp[t])
                    {
                        min_idx = mp[t];
                        ans = t;
                    }
                }
 
                // Shift the pointers.
                t = "";
                i = j + 1;
                j = i;
            }
            else
            {
                t += s[j];
                j++;
            }
        }
 
        // If ans is an empty string then this signifies that
        // there is no Repetition.
        if (ans == "")
        {
            Console.WriteLine("No Repetition");
        }
        else
        {
            Console.WriteLine(ans);
        }
    }
 
    public static void Main(string[] args)
    {
        string s1 = "Ravi had been saying that he had been there";
        string s2 = "Ravi had been saying that";
        string s3 = "he had had he";
 
        Solve(s1);
        Solve(s2);
        Solve(s3);
    }
}


Javascript




// JS program to find first repeated word in a string.
function solve(s)
{
    const n = s.length; // size of the string.
    const mp = new Map(); // To store first occurrence of a word.
    let ans = "", t = "";
    let min_idx = Number.MAX_SAFE_INTEGER; // To get minimum occurrence in the given string.
     
    let i = 0, j = 0; // iterators. i -> initial index of a word, j -> final index of a word.
     
    // loop to traverse in a string and to
    // find out each repeated word whose occurrence is minimum.
    while (j <= n)
    {
     
    // If found an entire word then check if it is repeated or not using Map.
    if (s[j] === ' ' || j === n) {
        if (!mp.has(t)) { // Store the first occurrence of a word.
            mp.set(t, i + 1);
        }
        else
        {
        // If there is a Repetition then
        // check for minimum occurrence of the word.
            if (min_idx > mp.get(t))
            {
                min_idx = mp.get(t);
                ans = t;
            }
        }
 
        // Shift the pointers.
        t = "";
        i = j + 1;
        j = i;
        } else {
            t += s[j];
            j++;
        }
    }
     
    // If ans is of empty string then
    // this signifies that there is no Repetition.
    if (ans === "")
        console.log("No Repetition");
    else
        console.log(ans);
    }
 
const s1 = "Ravi had been saying that he had been there";
const s2 = "Ravi had been saying that";
const s3 = "he had had he";
 
solve(s1);
solve(s2);
solve(s3);


Output

had
No Repetition
he










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”.

Implementation:

C++




// C++ program for the above approach
#include <iostream>
#include <map>
#include <string>
#include <sstream>
using namespace std;
 
string first_repeating_word(string s) {
 
  // Creating a map with default values as 0.
  // Every word will have an initial count of 0
  map<string, int> word_count;
 
  // Creating a stringstream object to split the string into words
  stringstream ss(s);
 
  // Iterating through all words in string.
  string word;
  while (ss >> word) {
 
    // Increment the word count of
    // the word we encounter by 1
    if (word_count.find(word) != word_count.end()) {
      word_count[word]++;
    }
    else {
      word_count[word] = 1;
    }
 
    // If word_count of current word
    // is more than 1, we got our answer, return it.
    if (word_count[word] > 1) {
      return word;
    }
  }
 
  // If program has reached here that
  // means no word is being repeated
  return "No word is being repeated";
}
 
// Driver Code
int main() {
  string s = "Ravi had been saying that he had been there";
  cout << first_repeating_word(s);
  return 0;
}
 
// This code is contributed by princekumaras


Java




import java.util.HashMap;
import java.util.Map;
 
public class Main {
 
    public static String firstRepeatingWord(String s) {
        // Creating a map to store word counts with initial values as 0.
        Map<String, Integer> wordCount = new HashMap<>();
 
        // Split the input string into words.
        String[] words = s.split(" ");
 
        // Iterate through all words in the string.
        for (String word : words) {
            // Increment the word count of the word we encounter by 1.
            if (wordCount.containsKey(word)) {
                wordCount.put(word, wordCount.get(word) + 1);
            } else {
                wordCount.put(word, 1);
            }
 
            // If the word count of the current word is more than 1, we've found our answer; return it.
            if (wordCount.get(word) > 1) {
                return word;
            }
        }
 
        // If the program has reached here, it means no word is being repeated.
        return "No word is being repeated";
    }
 
    public static void main(String[] args) {
        String s = "Ravi had been saying that he had been there";
        System.out.println(firstRepeatingWord(s));
    }
}


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


C#




using System;
using System.Collections.Generic;
 
class GFG
{
    // Function to find the first repeating word in the string
    static string FirstRepeatingWord(string s)
    {
        Dictionary<string, int> wordCount = new Dictionary<string, int>();
        // Split the input string into words
        string[] words = s.Split(new char[] { ' ', '.', ',', '!', '?' },
                                 StringSplitOptions.RemoveEmptyEntries);
        // Iterate through all words in string
        foreach (string word in words)
        {
            // Convert the word to lowercase for
          // case-insensitive comparison
            string lowercaseWord = word.ToLower();
            // If the word is already in the dictionary
          // increment its count
            if (wordCount.ContainsKey(lowercaseWord))
            {
                wordCount[lowercaseWord]++;
            }
            else
            {
                // Otherwise, add the word to
              // dictionary with a count of 1
                wordCount[lowercaseWord] = 1;
            }
            // If the count of the current word is more than 1
          //we found the first repeating word
            if (wordCount[lowercaseWord] > 1)
            {
                return word;
            }
        }
        // If no word is repeated
      // return the appropriate message
        return "No word is being repeated";
    }
    // Main method
    static void Main(string[] args)
    {
        string s = "Ravi had been saying that he had been there";
        Console.WriteLine(FirstRepeatingWord(s));
    }
}


Javascript




<script>
 
function first_repeating_word(s){
 
    // Creating a defaultdict with
    // default values as 0.
    // Every word will have an
    // initial count of 0
    let word_count = new Map()
 
    // Iterating through all words in string.
    for(let i of s.split(' ')){
 
        // Increment the word count of
        // the word we encounter by 1
        if(word_count.has(i)){
            word_count.set(i,word_count.get(i) + 1);
        }
        else word_count.set(i,1);
 
        // If word_count of current word
        // is more than 1, we got our answer, return it.
        if(word_count.get(i) > 1)
            return i
    }
 
    // If program has reached here that
    // means no word is being repeated
    return 'No word is being repeated'
}
 
// Driver Code
let s = "Ravi had been saying that he had been there"
document.write(first_repeating_word(s))
 
// This code is contributed by shinjanpatra
 
</script>


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.

Implementation:

C++




// CPP program for finding first repeated
// word in a string
#include <bits/stdc++.h>
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<string> 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;
}


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<String> set = new HashSet<String>();
         
        // store the words of string in hashset
        for(int i=0; i<token.length; i++){
             
            // if word exists return
            if(set.contains(token[i])){
                return token[i];
            }
             
            // insert new word to set
            set.add(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");
    }
}


Python3




# Python program for finding the first repeated word in a string
 
# Function to return the first repeated word
def findFirstRepeated(s):
    # Split the string into tokens and store each word in a set
    # If a word appeared before, return the word and break
 
    tokens = s.split()
    setOfWords = set()
 
    # Store all the words from the string and their count in the set
    for token in tokens:
        # If the word already exists, return it
        if token in setOfWords:
            return token
        # Insert the new word into the set
        setOfWords.add(token)
 
    return "NoRepetition"
 
# Driver program
if __name__ == "__main__":
    s = "Ravi had been saying that he had been there"
    firstWord = findFirstRepeated(s)
    if firstWord != "NoRepetition":
        print("First repeated word ::", firstWord)
    else:
        print("No Repetition")
 
# This code is contributed by guptapratik


C#




// C# Code
 
using System;
using System.Collections.Generic;
using System.IO;
 
class Program
{
    // Function to return the first repeated word
    static string FindFirstRepeated(string s)
    {
        // Split the string into tokens and store each word in a HashSet
        // If a word appeared before, return the word and break
 
        var tokens = s.Split(' ');
        var setOfWords = new HashSet<string>();
 
        // Store all the words from the string and their count in the HashSet
        foreach (var token in tokens)
        {
            // If the word already exists, return it
            if (setOfWords.Contains(token))
            {
                return token;
            }
            // Insert the new word into the HashSet
            setOfWords.Add(token);
        }
 
        return "NoRepetition";
    }
 
    // Driver program
    static void Main()
    {
        string s = "Ravi had been saying that he had been there";
        string firstWord = FindFirstRepeated(s);
        if (firstWord != "NoRepetition")
        {
            Console.WriteLine("First repeated word :: " + firstWord);
        }
        else
        {
            Console.WriteLine("No Repetition");
        }
    }
}
 
 
// This code is contributed by guptapratik


Javascript




// javascript program for finding first repeated
// word in a string
 
class GFG
{
    // returns first repeated word
    static findFirstRepeated(s)
    {
        // break string into tokens
        var token = s.split(" ");
         
        // set for storing words
        var set = new Set();
         
        // store the words of string in set
        for (let i=0; i < token.length; i++)
        {
            // if word exists return
            if (set.has(token[i]))
            {
                return token[i];
            }
            // insert new word to set
            set.add(token[i]);
        }
        return "NoRepetition";
    }
     
    // driver program
    static main(args)
    {
        var s = "Ravi had been saying that he had been there";
        var firstWord = GFG.findFirstRepeated(s);
        if (firstWord !== "NoRepetition")
        {
            console.log("First repeated word :: " + firstWord);
        }
        else
        {
        console.log("No Repetitionn");
        }
    }
}
GFG.main([]);
 
// This code is contributed by mukulsomukesh


Output

First repeated word :: had










This article is contributed by Aarti_Rathi and 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.


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 24 Nov, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials