Find the first repeated word in a string

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::

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

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;
}

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);

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.

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

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

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");
    }
}

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.