How to remove duplicate characters from a String in Scala?

In this article, we will learn how to remove duplicate characters from a string in Scala using different approaches. First, we will look through the Brute-Force Approach and then use different standard libraries.

Examples:

Input: String = "hello"
Output: helo

Input: String = "Geeks"
Output: Geks

Naive Approach to remove duplicate characters from a String in Scala

In the brute force approach, we compare each character in the string with every other character to determine if it's a duplicate.

Below is the code in Scala.

// Program to remove duplicate from string using scala
// Creating Object
object Gfg {
  //Method to removeDuplicates
  def removeDuplicates(str: String): String = {
    var result = ""
    for (char <- str) {
      if (!result.contains(char)) {
        result += char
      }
    }
    result
  }
   // Main Method
  def main(args: Array[String]): Unit = {
    val inputString = "hello"
    val outputString = removeDuplicates(inputString)
    println(stringWithoutDuplicates) 
  }
}

Output

Explanation:

• First we will create a function removeDuplicates
  • Inside this function we will took a empty var string.
  • We iterate over each character in the input string str.
  • For each character, we check if it exists in the result string. If it doesn't, we append it to the result.
  • Finally, we return the result string, which contains unique characters.
• In main method we will call the removeDuplicate Method and Print the Output.

Time Complexity : O(n²)

Remove duplicate characters from a String in Scala Using Set

This is the another approach using a mutable Set to keep track of duplicate characters.

Below is the code in Scala using set.

// Program to remove duplicate from string using set

//creating object
object Gfg {
  
  //remove duplicate function
  def removeDuplicates(str: String): String = {
    val set = scala.collection.mutable.Set[Char]()
    val result = new StringBuilder
    for (char <- str) {
      if (!set(char)) {
        result += char
        contain += char
      }
    }
    result.toString
  }

  //Main Method
  def main(args: Array[String]): Unit = {
    val inputString = "hello"
    val outputString = removeDuplicates(inputString)
    println(outputString) 
  }
}

Output:

Explanation:

• First we will define a removeDuplicate Method
  • Inside that method we will define a mutable set named set.
  • We iterate over each character in the input string str.
  • For each character, if it's not already present in the set, we append it to the result string and add it to the set.
  • At the end, we convert the result string builder to a regular string and return it.
• In main method we will call removeDuplicate Function and Print the Output.

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

Remove duplicate characters from a String in Scala Using foldLeft Method

This is the another method for removing duplicate characters from a String in Scala.

Below is the code in Scala.

//Creating Object
object Gfg {
  
  // defining removeDuplicates Method
  def removeDuplicates(str: String): String = {
    
  // Use foldLeft to iterate through each character of the string
    str.foldLeft("") { (acc, char) =>
     // If the accumulator already contains the character, return the accumulator
      if (acc.contains(char)) acc
      // Otherwise, append the character to the accumulator
      else acc + char
    }
  }
  
 // Defining Main Method
  def main(args: Array[String]): Unit = {
    val inputString = "Geeksforgeeks"
    val outputString = removeDuplicates(inputString)
    println(outputString)
  }
}

Output:

Explanation:

• We define a function removeDuplicates that takes a string str as input and returns a string with duplicate characters removed.
  • We use foldLeft to iterate over each character in the input string.
  • For each character, we check if it already exists in the accumulator string (acc). If it does, we don't add it to the accumulator. If it doesn't, we append it to the accumulator.
  • Finally, we return the accumulator string, which contains unique characters.
• We will create Main Method , call the function removeDuplicates and Print that return output.

Remove duplicate characters from a String in Scala Using Distinct Method

The distinct method provides a convenient way to remove duplicate characters from a string in Scala.

Below is the code of remove duplicate characters from a string using string.distinct Method.

// Creating Object
object Gfg {
  // defining a removeDuplicate Method
  def removeDuplicates(str: String): String = {
    // Using string.distinct method
    str.distinct
  }

  //defining main Method
  def main(args: Array[String]): Unit = {
    val inputString = "Geeksforgeeks"
    val outputString = removeDuplicates(inputString)
    println(outputString) 
  }
}

Output:

Explanation

• The removeDuplicates function simply calls the distinct method on the input string str, which returns a new string with duplicate characters removed.
• The main method is the entry point for the program.

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