Remove Duplicate/Repeated words from String

Remove duplicates from a string

Last Updated : 11 Sep, 2024

Try it on GfG Practice

Given a string s which may contain lowercase and uppercase characters. The task is to remove all duplicate characters from the string and find the resultant string.

Note: The order of remaining characters in the output should be the same as in the original string.

Example:

Input: s = geeksforgeeks
Output: geksfor
Explanation: After removing duplicate characters such as e, k, g, s, we have string as “geksfor”.

Input: s = HappyNewYear
Output: HapyNewYr
Explanation: After removing duplicate characters such as p, e, a, we have string as “HapyNewYr”.

Naive Approach – O(n^2) Time

Iterate through the string and for each character check if that particular character has occurred before it in the string. If not, add the character to the result, otherwise the character is not added to result.

Below is the implementation of above approach:

C++

#include <bits/stdc++.h>
using namespace std;

string removeDuplicate(string s)
{
   // Used as index in the modified string
   int index = 0;   

   // Traverse through all characters
   for (int i = 0; i < s.size(); i++) {
       
     // Check if s[i] is present before it  
     int j;  
     for (j = 0; j < i; j++) 
        if (s[i] == s[j])
           break;
     
     // If not present, then add it to result
     if (j == i)
        s[index++] = s[i];
   }
   
   // Resize the string to remove extra characters
   s.resize(index);
   
   return s;
}

// Driver code
int main()
{
   string s = "geeksforgeeks";
   cout << removeDuplicate(s);
   return 0;
}

C

#include <stdio.h>
#include <string.h>

// Used as index in the modified string
char* removeDuplicate(char* s) {
    int index = 0;
    int i, j;
    int len = strlen(s);

    // Traverse through all characters
    for (i = 0; i < len; i++) {
        
        // Check if s[i] is present before it  
        for (j = 0; j < i; j++) 
            if (s[i] == s[j])
                break;
        
        // If not present, then add it to result
        if (j == i)
            s[index++] = s[i];
    }
    
    // Resize the string to remove extra characters
    s[index] = '\0';
    
    return s;
}

// Driver code
int main() {
    char s[] = "geeksforgeeks";
    printf("%s\n", removeDuplicate(s));
    return 0;
}

Java

public class GfG {
    
    // Used as index in the modified string
    public static String removeDuplicate(String s) {
        StringBuilder sb = new StringBuilder(s.length());
        boolean[] seen = new boolean[256];

        // Traverse through all characters
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            // Check if s[i] is present before it  
            if (!seen[c]) {
                sb.append(c);
                seen[c] = true;
            }
        }
        
        return sb.toString();
    }

    // Driver code
    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(removeDuplicate(s));
    }
}

Python

def remove_duplicate(s):
    # Used as index in the modified string
    result = []
    seen = set()

    # Traverse through all characters
    for char in s:
        # Check if s[i] is present before it  
        if char not in seen:
            result.append(char)
            seen.add(char)
    
    # Join list to form the result string
    return ''.join(result)

# Driver code
s = "geeksforgeeks"
print(remove_duplicate(s))

C#

using System;

public class GfG
{
    // Used as index in the modified string
    public static string RemoveDuplicateChars(string s)
    {
        char[] arr = s.ToCharArray();
        int index = 0;

        // Traverse through all characters
        for (int i = 0; i < arr.Length; i++)
        {
            // Check if s[i] is present before it  
            int j;
            for (j = 0; j < i; j++)
            {
                if (arr[i] == arr[j])
                    break;
            }

            // If not present, then add it to result
            if (j == i)
                arr[index++] = arr[i];
        }

        // Resize the string to remove extra characters
        return new string(arr, 0, index);
    }

    // Driver code
    public static void Main()
    {
        string s = "geeksforgeeks";
        Console.WriteLine(RemoveDuplicateChars(s));
    }
}

JavaScript

function removeDuplicate(s) {
    // Used as index in the modified string
    let result = '';
    let seen = new Set();

    // Traverse through all characters
    for (let i = 0; i < s.length; i++) {
        let char = s[i];

        // Check if s[i] is present before it  
        if (!seen.has(char)) {
            result += char;
            seen.add(char);
        }
    }

    return result;
}

// Driver code
let s = "geeksforgeeks";
console.log(removeDuplicate(s));

Output

geksfor

Time Complexity: O(n * n)
Auxiliary Space: O(1), Keeps the order of elements the same as the input.

Using Hash Set – O(n) Time

Iterating through the given string and use a map to efficiently track of encountered characters. If a character is encountered for the first time, it’s added to the result string, Otherwise, it’s skipped. This ensures the output string contains only unique characters in the same order as the input string.

Below is the implementation of above approach:

C++

#include <bits/stdc++.h>
using namespace std;

// Function to remove duplicate characters
// using unordered_set
string removeDuplicates(string &s)
{
    unordered_set<char> exists; 
    string ans = "";

    // Traverse through the string
    for (char c : s) {
      
        // If character is not found in set, 
        // add it to result
        if (exists.find(c) == exists.end()) {
            ans.push_back(c);
            exists.insert(c); 
        }
    }
    
    return ans;
}

// Driver code
int main()
{
    string s = "geeksforgeeks";
    cout << removeDuplicates(s) << endl;
    return 0;
}

C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

// Function to remove duplicate characters
// using an array to track characters
char* removeDuplicates(char* s) {
    bool exists[256] = { false };
    int index = 0;
    int length = strlen(s);

    // Traverse through the string
    for (int i = 0; i < length; i++) {
        char c = s[i];
        
        // If character is not found in array,
        // add it to result
        if (!exists[(unsigned char)c]) {
            s[index++] = c;
            exists[(unsigned char)c] = true;
        }
    }
    
    // Null-terminate the result string
    s[index] = '\0';
    
    return s;
}

// Driver code
int main() {
    char s[] = "geeksforgeeks";
    printf("%s\n", removeDuplicates(s));
    return 0;
}

Java

import java.util.HashSet;

public class GfG {

    // Function to remove duplicate characters
    // using HashSet
    public static String removeDuplicates(String s) {
        HashSet<Character> exists = new HashSet<>();
        StringBuilder ans = new StringBuilder();

        // Traverse through the string
        for (char c : s.toCharArray()) {
            
            // If character is not found in set, 
            // add it to result
            if (!exists.contains(c)) {
                ans.append(c);
                exists.add(c);
            }
        }
        
        return ans.toString();
    }

    // Driver code
    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(removeDuplicates(s));
    }
}

Python

def remove_duplicates(s):
    # Function to remove duplicate characters
    # using set
    seen = set()
    result = []

    # Traverse through the string
    for char in s:
        # If character is not found in set, 
        # add it to result
        if char not in seen:
            result.append(char)
            seen.add(char)
    
    return ''.join(result)

# Driver code
s = "geeksforgeeks"
print(remove_duplicates(s))

C#

using System;
using System.Collections.Generic;

public class GfG {

    // Function to remove duplicate characters
    // using HashSet
    public static string RemoveDuplicatesChars(string s) {
        HashSet<char> exists = new HashSet<char>();
        System.Text.StringBuilder ans = new System.Text.StringBuilder();

        // Traverse through the string
        foreach (char c in s) {
            
            // If character is not found in set, 
            // add it to result
            if (!exists.Contains(c)) {
                ans.Append(c);
                exists.Add(c);
            }
        }
        
        return ans.ToString();
    }

    // Driver code
    public static void Main() {
        string s = "geeksforgeeks";
        Console.WriteLine(RemoveDuplicatesChars(s));
    }
}

JavaScript

function removeDuplicates(s) {

    // Function to remove duplicate characters
    // using a Set
    let seen = new Set();
    let result = '';

    // Traverse through the string
    for (let char of s) {
        
        // If character is not found in set, 
        // add it to result
        if (!seen.has(char)) {
            result += char;
            seen.add(char);
        }
    }

    return result;
}

// Driver code
let s = "geeksforgeeks";
console.log(removeDuplicates(s));

Output

geksfor

Time Complexity: O(n)
Auxiliary Space: O(n)

Using Frequency Array – O(n)

Iterating through the given string and use a character array initilize with 0 frequency to efficiently track of encountered characters. If current character’s frequency is 0, then it’s added to the result string and increment frequency by 1, Otherwise, it’s skipped. This ensures the output string contains only unique characters in the same order as the input string.

Below is the implementation of above approach:

C++

#include <bits/stdc++.h>
using namespace std;

// Function to remove duplicate characters
string removeDuplicates(string &s)
{
    // Create an integer array to store 
    // frequency for ASCII characters
    vector<int> ch(256, 0);

    // Create result string
    string ans = "";

    // Traverse the input string
    for (char c : s) {
      
        // Check if current character's frequency is 0
        if (ch[c] == 0) {
          
            // Add char if frequency is 0
            ans.push_back(c);

            // Increment frequency
            ch[c]++;
        }
    }
    return ans;
}

// Driver code
int main()
{
    string s = "geeksforgeeks";
    cout << removeDuplicates(s) << endl;
    return 0;
}

C

#include <stdio.h>
#include <string.h>

// Function to remove duplicate characters
char* removeDuplicates(char* s) {
  
    // Create an integer array to store 
    // frequency for ASCII characters
    int ch[256] = { 0 };
    int index = 0;
    int length = strlen(s);

    // Traverse the input string
    for (int i = 0; i < length; i++) {
        char c = s[i];

        // Check if current character's frequency is 0
        if (ch[(unsigned char)c] == 0) {
            
            // Add char if frequency is 0
            s[index++] = c;

            // Increment frequency
            ch[(unsigned char)c]++;
        }
    }
    s[index] = '\0';  // Null-terminate the result string
    return s;
}

// Driver code
int main() {
    char s[] = "geeksforgeeks";
    printf("%s\n", removeDuplicates(s));
    return 0;
}

Java

import java.util.Arrays;

public class GfG {

    // Function to remove duplicate characters
    public static String removeDuplicates(String s) {
      
        // Create an integer array to store 
        // frequency for ASCII characters
        int[] ch = new int[256];
        StringBuilder ans = new StringBuilder();

        // Traverse the input string
        for (char c : s.toCharArray()) {

            // Check if current character's frequency is 0
            if (ch[c] == 0) {
                
                // Add char if frequency is 0
                ans.append(c);

                // Increment frequency
                ch[c]++;
            }
        }
        return ans.toString();
    }

    // Driver code
    public static void main(String[] args) {
        String s = "geeksforgeeks";
        System.out.println(removeDuplicates(s));
    }
}

Python

def remove_duplicates(s):
  
    # Function to remove duplicate characters
    # Create a list to store frequency for ASCII characters
    ch = [0] * 256
    result = []

    # Traverse the input string
    for char in s:
        
        # Check if current character's frequency is 0
        if ch[ord(char)] == 0:
            
            # Add char if frequency is 0
            result.append(char)

            # Increment frequency
            ch[ord(char)] += 1
    
    return ''.join(result)

# Driver code
s = "geeksforgeeks"
print(remove_duplicates(s))

C#

using System;

public class GfG {

    // Function to remove duplicate characters
    public static string RemoveDuplicatesChars(string s) {
      
        // Create an integer array to store 
        // frequency for ASCII characters
        int[] ch = new int[256];
        System.Text.StringBuilder ans = new System.Text.StringBuilder();

        // Traverse the input string
        foreach (char c in s) {

            // Check if current character's frequency is 0
            if (ch[c] == 0) {
                
                // Add char if frequency is 0
                ans.Append(c);

                // Increment frequency
                ch[c]++;
            }
        }
        return ans.ToString();
    }

    // Driver code
    public static void Main() {
        string s = "geeksforgeeks";
        Console.WriteLine(RemoveDuplicatesChars(s));
    }
}

JavaScript

function removeDuplicates(s) {

    // Function to remove duplicate characters
    // Create an integer array to store 
    // frequency for ASCII characters
    let ch = new Array(256).fill(0);
    let result = '';

    // Traverse the input string
    for (let char of s) {
        
        // Check if current character's frequency is 0
        if (ch[char.charCodeAt(0)] === 0) {
            
            // Add char if frequency is 0
            result += char;

            // Increment frequency
            ch[char.charCodeAt(0)]++;
        }
    }
    
    return result;
}

// Driver code
let s = "geeksforgeeks";
console.log(removeDuplicates(s));

Output

geksfor

Time Complexity: O(n)
Auxiliary Space: O(1) considering that the alphabet size is constant.

Remove Duplicate/Repeated words from String

kartik

News

Improve

Article Tags :

Practice Tags :

Strings

Similar Reads

Remove duplicates from a string

Given a string s which may contain lowercase and uppercase characters. The task is to remove all duplicate characters from the string and find the resultant string. Note: The order of remaining characters in the output should be the same as in the original string. Example: Input: s = geeksforgeeksOu

Remove Duplicate/Repeated words from String

Given a string S, the task is to remove all duplicate/repeated words from the given string. Examples: Input: S = "Geeks for Geeks A Computer Science portal for Geeks" Output: Geeks for A Computer Science portal Explanation: here 'Geeks' and 'for' are duplicate so these words are removed from the str

Remove "b" and "ac" from a given string

Given a string, eliminate all "b" and "ac" in the string, you have to replace them in-place, and you are only allowed to iterate over the string once. (Source Google Interview Question) Examples: acbac ==> "" aaac ==> aa ababac ==> aa bbbbd ==> dWe strongly recommend that you click here

Remove extra spaces from a string

Given a string containing many consecutive spaces, trim all spaces so that all words should contain only a single space between them. The conversion should be done in-place and solution should handle trailing and leading spaces and also remove preceding spaces before common punctuation like full sto

Remove odd indexed characters from a given string

Given string str of size N, the task is to remove the characters present at odd indices (0-based indexing) of a given string. Examples : Input: str = â€œabcdefâ€Output: aceExplanation:The characters 'b', 'd' and 'f' are present at odd indices, i.e. 1, 3 and 5 respectively. Therefore, they are removed f

Remove consecutive vowels from string

Given a string s of lowercase letters, we need to remove consecutive vowels from the string Note : Sentence should not contain two consecutive vowels ( a, e, i, o, u). Examples : Input: geeks for geeksOutput: geks for geksInput : your article is in queue Output : yor article is in quApproach: Iterat

Remove all characters other than alphabets from string

Given a string consisting of alphabets and others characters, remove all the characters other than alphabets and print the string so formed. Examples: Input : $Gee*k;s..fo, r'Ge^eks?Output : GeeksforGeeks Input : P&ra+$BHa;;t*ku, ma$r@@s#in}ghOutput : PraBHatkumarsingh Recommended PracticeRemove

Remove spaces from a given string

Given a string, remove all spaces from the string and return it. Input: "g eeks for ge eeks "Output: "geeksforgeeks" Input: "abc d "Output: "abcd" Expected time complexity is O(n) and only one traversal of string. Below is a Simple Solution 1) Iterate through all characters of given string, do follo

C++ Program to remove spaces from a string

Given a string, remove all spaces from it. For example "g e e k" should be converted to "geek" and " g e " should be converted to "ge". The idea is to traverse the string from left to right and ignore spaces while traversing. We need to keep track of two indexes, one for the current character being

Python String - removesuffix()

removesuffix() method allows us to remove a specified suffix from a string. This method is particularly helpful when we need to work with strings and remove unwanted endings without manually checking or slicing. For example, we might have a file name that ends with ".txt" and want to remove it to ge