在 Swift 中计算不同的字符

Question

我是 swift 新手，我正在尝试在 string 中使用 count 不同的 characters，但我的代码返回整个 String 的值

对于示例：

var string aString = "aabb"
aString.characters.count()             //returns 5

counter = 0
let a = "a"

for a in aString.characters {
  counter++
}                                      //equally returns 5

有人可以解释为什么会发生这种情况以及我如何计算不同的字符吗？

Answer 1

看起来你对真正需要的东西有些困惑。

我试图回答 5 种最可能的解释。

var word = "aabb"

let numberOfChars = word.characters.count // 4
let numberOfDistinctChars = Set(word.characters).count // 2
let occurrenciesOfA = word.characters.filter { $0 == "A" }.count // 0
let occurrenciesOfa = word.characters.filter { $0 == "a" }.count // 2
let occurrenciesOfACaseInsensitive = word.characters.filter { $0 == "A" || $0 == "a" }.count // 2

print(occurrenciesOfA)
print(occurrenciesOfa)
print(occurrenciesOfACaseInsensitive)

Answer 2

检查一下

var aString = "aabb"
aString.characters.count // 4

var counter = 0
let a = "a" // you newer use this in your code 

for thisIsSingleCharacterInStringCharactersView in aString.characters {
    counter++
}
print(counter) // 4

它只是增加每个字符的计数器

要计算字符串中不同字符的数量，您可能可以使用“更高级”的方法，例如下一个示例

let str = "aabbcsdfaewdsrsfdeewraewd"

let dict = str.characters.reduce([:]) { (d, c) -> Dictionary<Character,Int> in
    var d = d
    let i = d[c] ?? 0
    d[c] = i+1
    return d
}
print(dict) // ["b": 2, "a": 4, "w": 3, "r": 2, "c": 1, "s": 3, "f": 2, "e": 4, "d": 4]

Answer 3

你的代码很错误：它可能应该以

开头

let aString = "aabb"

解决方案是获取字符，将它们放入一个集合（唯一），然后计算集合的成员：

let differentChars = Set(aString.characters).count

正确返回

2

Answer 4

characters 属性已弃用，您可以使用components(separatedBy:) 查找字符串中有多少个字符。例如，

extension String {

    public func numberOfOccurrences(_ string: String) -> Int {
        return components(separatedBy: string).count - 1
    }

}
let aString = "aabbaa"
let aCount = aString.numberOfOccurrences("a") // aCount = 4

Answer 5

更新了@Luca Angeletti 对 Swift5.3 的回答，因为 characters 属性在较新的 swift 版本中不可用。

var word = "aabb"

let numberOfChars = word.count // 4
let numberOfDistinctChars = Set(word).count // 2
let occurrenciesOfA = word.filter { $0 == "A" }.count // 0
let occurrenciesOfa = word.filter { $0 == "a" }.count // 2
let occurrenciesOfACaseInsensitive = word.filter { $0 == "A" || $0 == "a" }.count // 2

print(numberOfChars)
print(numberOfDistinctChars)
print(occurrenciesOfA)
print(occurrenciesOfa)
print(occurrenciesOfACaseInsensitive)

Answer 6

从（键，值）对的序列中构造一个字典。如果我们可以保证键是唯一的，我们可以使用 Dictionary(uniqueKeysWithValues:)。

func characterFrequencies(of string: String) -> Dictionary<String.Element, Int> {
    let frequencyPair = string.map { ($0, 1) }
    return Dictionary(frequencyPair, uniquingKeysWith: +)
}

用法：print(characterFrequencies(of: "Happy")) 结果：[“a”：1，“H”：1，“y”：1，“p”：2]

Answer 7

func repeatedCharaterPrint(inputArray: [String]) -> [String:Int] {
var dict = [String:Int]()
if inputArray.count > 0 {
    for char in inputArray {
        if let keyExists = dict[char], keyExists != nil {
            dict[char] = Int(dict[char] ?? 0) + 1
        }else {
            dict[char] = 1
        }
    }
}
return dict

}

let aa = ["a","s","f","s","l","s"]
print(repeatedCharaterPrint(inputArray: aa))
//Answer : "["s": 3, "l": 1, "a": 1, "f": 1]"

Answer 8

此解决方案是使用哈希函数编写的，因此计算时间为 O(1)。适合长字符串。

//对字符串和字符进行扩展以从Ascii中获取Ascii值和Char

extension Character {
    //Get Ascii Value of Char
    var asciiValue:UInt32? {
        return String(self).unicodeScalars.filter{$0.isASCII}.first?.value
    }
}

extension String {
    //Char Char from Ascii Value
    init(unicodeScalar: UnicodeScalar) {
        self.init(Character(unicodeScalar))
    }


init?(unicodeCodepoint: Int) {
    if let unicodeScalar = UnicodeScalar(unicodeCodepoint) {
        self.init(unicodeScalar: unicodeScalar)
    } else {
        return nil
    }
}


static func +(lhs: String, rhs: Int) -> String {
    return lhs + String(unicodeCodepoint: rhs)!
}


static func +=(lhs: inout String, rhs: Int) {
    lhs = lhs + rhs
}
}

extension String {
    ///Get Char at Index from String
    var length: Int {
        return self.characters.count
    }

subscript (i: Int) -> String {
    return self[Range(i ..< i + 1)]
}

func substring(from: Int) -> String {
    return self[Range(min(from, length) ..< length)]
}

func substring(to: Int) -> String {
    return self[Range(0 ..< max(0, to))]
}

subscript (r: Range<Int>) -> String {
    let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                        upper: min(length, max(0, r.upperBound))))
    let start = index(startIndex, offsetBy: range.lowerBound)
    let end = index(start, offsetBy: range.upperBound - range.lowerBound)
    return self[Range(start ..< end)]
}

}

//程序：

let  strk = "aacncjkvkevkklvkdsjkbvjsdbvjkbsdjkvbjdsbvjkbsvbkjwlnkneilhfleknkeiohlgblehgilkbskdbvjdsbvjkdsbvbbvsbdvjlbsdvjbvjkdbvbsjdbjsbvjbdjbjbjkbjkvbjkbdvjbdjkvbjdbvjdbvjbvjdsbjkvbdsjvbkjsbvadvbjkenevknkenvnekvjksbdjvbjkbjbvbkjvbjdsbvjkbdskjvbdsbvjkdsbkvbsdkjbvkjsbvjsbdjkvbdsbvjkbdsvjbdefghaj"

print(strk)

//Declare array of fixes size 26 (characters) or you can say it as a hash table 
var freq = [Int](repeatElement(0, count: 26))

func hashFunc(char : Character) -> UInt32 {
    guard let ascii = char.asciiValue else {
        return 0
    }
    return ascii - 97 //97 used for ascii value of a
}


func countFre(string:String) {

    for i in 0 ... string.characters.count-1 {
        let charAtIndex = string[i].characters.first!
        let index = hashFunc(char: charAtIndex)
        let currentVal = freq[Int(index)]
        freq[Int(index)] = currentVal + 1
        //print("CurrentVal of \(charAtIndex) with index \(index) is \(currentVal)")

    }

    for charIndex in 0 ..< 26 {
        print(String(unicodeCodepoint: charIndex+97)!,freq[charIndex])
    }
}

countFre(string: strk)