Question

这会在数组中找到重复项，但我正在寻找能够找到字符串中第一个非重复字符的内容。我一直试图找到一种方法来做到这一点，我无法弄明白。这是我得到的最接近的。

var strArray = ["P","Q","R","S","T","P","R","A","T","B","C","P","P","P","P","P","C","P","P","J"]

println(strArray)

var filter = Dictionary<String,Int>()
var len = strArray.count
for var index = 0; index < len  ;++index {
var value = strArray[index]
if (filter[value] != nil) {
    strArray.removeAtIndex(index--)
    len--
}else{
    filter[value] = 1
}
}
println(strArray)

Answer 1

为了判断一个字符是否重复，请遍历整个数组一次，增加字典中出现的次数：

let characters = ["P","Q","R","S","T","P","R","A","T","B","C","P","P","P","P","P","C","P","P","J"]

var counts: [String: Int] = [:]
for character in characters {
    counts[character] = (counts[character] ?? 0) + 1
}


let nonRepeatingCharacters = characters.filter({counts[$0] == 1})
// ["Q", "S", "A", "B", "J"]
let firstNonRepeatingCharacter = nonRepeatingCharacters.first!
// "Q"

Answer 2

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
}

没有额外的循环来从characterCount字典中找到字符

Answer 3

这是一个简单的解决方案

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

在上面的示例中，它将显示“ Q”

Answer 4

这是我发现检测第一个非重复字符的方法。它删除空格和标点符号以查找不重复的实际字母或数字。

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

Answer 5

我完全怀疑为什么接受的答案被认为是正确的。他们正在使用

.first

字典的

方法，根据文档的说明，它将在字典中返回一个随机元素，而不是第一个元素，因为swift中的字典没有像数组那样排序。

请在下面找到有效的实现

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".

Answer 6

我们可以迭代一次，并将字母计数保留在字典中。然后，再次进行迭代，并返回仅遇到一次的第一个字母（如果未找到非重复字母，则返回“ _”）：

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
}

Answer 7

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

使用Swift查找String中的第一个非重复字符

7 个答案: