First Non-Repeating Value

Find the first input value whose final frequency is one.

Algorithm

Canonical input [3, 5, 2, 5, 3, 8, 2] prints 8. The replay uses the same input in every language, so this Scala DSA implementation can be compared directly with the rest of the DSA track.

Basic Implementation

basic.scala

import scala.collection.mutable.HashMap
object Main {
  def main(args: Array[String]): Unit = {
    val arr = List(3, 5, 2, 5, 3, 8, 2)
    val count = HashMap.empty[Int, Int]
    for (value <- arr) {
      count(value) = count.getOrElse(value, 0) + 1
    }
    for (value <- arr) {
      if (count(value) == 1) {
        println(value)
        return
      }
    }
  }
}

Complexity

Time: O(n) average
Space: O(k) for k distinct values

Implementation notes

This checked source uses integer input, not string or character iteration: val arr = List(3, 5, 2, 5, 3, 8, 2).
val count = HashMap.empty[Int, Int] binds a mutable Scala HashMap; the binding is val, but the table contents are updated in place.
The first pass runs for (value <- arr) in list order and writes count(value) = count.getOrElse(value, 0) + 1.
getOrElse(value, 0) supplies the default count for a missing key before the increment.
The trace records logical table states only; it does not expose bucket order, resizing, or collision behavior.
After counting, the table is {3: 2, 5: 2, 2: 2, 8: 1}.
The second pass scans the original list again. Values 3, 5, 2, 5, and 3 have frequency 2; value 8 has frequency 1.
On the first unique value, the code calls println(value) and return, so the exact output is 8. If no value matched, this source would fall through without printing a sentinel.

two-pass lookup The first pass builds a frequency table. The second pass keeps the original order and stops at the first value with frequency one.