Finding the first non-repeating character in a String using Swift

Here is a simple solution

let inputString = "PQRSTPRATBCPPPPPCPPJ"

func nonRepeat (_ input: String) -> String {
    for char in input {
        if input.firstIndex(of: char) == input.lastIndex(of: char) {
            return String(char)
        }
    }
    return ""
}
print (nonRepeat(inputString))

In the above example it would print "Q"

func firstNonRepeatedCharacter(input: String) -> Character?{
    var characterCount : [Character : Int] = [:]
    var uniqueCharacter: Character?

    for character in input{
        if let count = characterCount[character]{
            characterCount[character] = count + 1
            if(uniqueCharacter == character)
            {
                uniqueCharacter = nil
            }
        }
        else{
            characterCount[character] = 1
            if(uniqueCharacter == nil){
                uniqueCharacter = character
            }
        }
    }
    return uniqueCharacter
}

Without extra loop to find character from characterCount dictionary

Here is the way I have found to detect the first non-repeated character. It removes spaces and punctuation to find the actual letter or number that does not repeat.

extension String {

func removeNonAlphaNumChars() -> String {
    let charSet = NSCharacterSet.alphanumericCharacterSet().invertedSet

    return self
        .componentsSeparatedByCharactersInSet(charSet)
        .joinWithSeparator("")
}

var firstNonRepeatedCharacter: Character? {
    let alphaNumString = self.removeNonAlphaNumChars()

    let characters = alphaNumString.characters
    let count = characters.count
    guard count > 0 else { return nil }

    // Find unique chars
    var dict: [Character: Int?] = [:]
    for (index, char) in characters.enumerate() {
        if dict[char] != nil {
            dict[char] = (nil as Int?)
        }
        else {
            dict[char] = index
        }
    }

    return dict.filter { $0.1 != nil }.sort { $0.1 < $1.1 }.first?.0
}
}

I totally wonder why the accepted answer was considered correct. They are using

.first

method of a dictionary and that according to documentation would return a random element in the dictionary and not the first element as a dictionary in swift is not ordered like an array.

please do find below an implementation that works

func firstNonRepeatingLetter(_ str: String)  -> String{
   var characterDict = [String : Int]()

   for character in str{
       let lower = character.lowercased()
       if let count = characterDict[lower]{
         characterDict[lower] = count + 1
       }else{
        characterDict[lower] = 1
       }
   }

   let filtered = characterDict.filter { $0.value == 1}
   for character in str{
       let lower = character.lowercased()
       if let _ = filtered[lower]{
        return lower
       }
   }

   return ""
}


firstNonRepeatingLetter("moonmen") would return "e". 

We can iterate once and keep the letter counts inside a dictionary. Then, iterate again and return first letter where we see it was encountered once only (or "_" if not found a non-repeating letter):

func firstNotRepeatingCharacter(s: String) -> Character {
    var letterCounts: [String: Int] = [:]
    var result: Character = "_"

    for letter in s {
        if let currentLetterCount = letterCounts[String(letter)] {
            letterCounts[String(letter)] = currentLetterCount + 1
        } else {
            letterCounts[String(letter)] = 1
        }
    }

    for letter in s {
        if letterCounts[String(letter)] == 1 {
            result = letter
            break
        }
    }

    return result
}

OrderedDictionary makes this easy for all Sequences of Hashables, not just Strings:

import struct OrderedCollections.OrderedDictionary

extension Sequence where Element: Hashable {
  var firstUniqueElement: Element? {
    OrderedDictionary(zip(self, true)) { _, _  in false }
      .first(where: \.value)?
      .key
  }
}

/// `zip` a sequence with a single value, instead of another sequence.
public func zip<Sequence: Swift.Sequence, Constant>(
  _ sequence: Sequence, _ constant: Constant
) -> LazyMapSequence<
  LazySequence<Sequence>.Elements,
  (LazySequence<Sequence>.Element, Constant)
> {
 sequence.lazy.map { ($0, constant) }
}

func getFirstUniqueChar(string:String)->Character?{
var counts: [String: Int] = [:]
for character in string {
    let charString = "\(character)"
    counts[charString] = (counts[charString] ?? 0) + 1
}
let firstNonRepeatingCharacter = string.first {counts["\($0)"] == 1}
return firstNonRepeatingCharacter
}

print(getFirstUniqueChar(string: string))

import Foundation
import Glibc
var str:String = "aacbbcee"//your input string
var temp:String = ""
var dict:[Character:Int] = [:]

for char in str{
    if let count = dict[char]{
        dict[char] = count+1//storing values in dict and incrmenting counts o key
    }
    else{
        dict[char] = 0
    }
}
var arr:[Character] = []
for (key, value) in dict{
    if value == 0{
        arr.append(key)//filtering out, take characters which has value>0
    }  //int(arr)
}//print(arr.count)
if arr.count != 0{
outer:for char in str{//outer is labeling the loop
    for i in arr{
        if i == char{
        print(i,"is first")//matching char with array elements if found break
        break outer
        }
        else{
            continue
        }
    }
}
}
else{
print("not found")
}

func firstNonRepeatedChar(string: String) -> Character {
var arr: [Character] = []
var dict: [Character : Int] = [:]

for character in string.description {
    arr.append(character)
}

for character in arr {
    dict[character] = (dict[character] ?? 0) + 1
}
let nonRepeatedArray = arr.filter { char in
    if dict[char] == 1 {return true}
    return false
}
let firstNonRepeatedChar = nonRepeatedArray.first
return firstNonRepeatedChar! 
}
print(firstNonRepeatedChar(string: "strinstrig"))