在给定条件下查找字符串中不同字母的数量；小写字母不能在大写字母之前

Question

给你一串由N个英文字母组成的字母。计算以大写和小写形式出现的不同字母的数量，其中给定字母的所有小写出现都出现在任何大写出现之前。

例如，对于字母 =“aaAbcCABBc”，答案为 2。字母“a”和“b”满足条件，但“c”不满足条件。

编写一个函数：

函数解（字母）；

给定一个字符串字母，返回满足上述条件的不同字母的数量。

示例：

1. 给定字母“aaAbcCABBc”，函数应返回 2，如上所述。

2. 给定字母“xyzXYZabcABC”，该函数应返回 6。

3. 给定字母“ABCabcAefG”，函数应返回 0。

针对以下假设编写一个有效的算法：

N 是 [1..100,000) 范围内的整数；

字符串字母仅由字母（a-z 和/或 A-Z）组成。

我编写了以下代码，但第三个边缘情况一直失败。它返回 1 而不是零。

以下是三个测试用例：
aaAbcCABBc // 输出：2
xyzXYZabcABC // 输出：6
ABCabcAefG // 输出：0

func ssolution(_ letters: String) -> Int {
    var seenLowercase = Set<Character>() // Stores seen lowercase letters
    var count = 0

    for (index, char) in letters.enumerated() {
        let lowercaseChar = char.lowercased().first!

        if char.isLowercase {
            // If lowercase, check if already seen uppercase
            if seenLowercase.contains(lowercaseChar) {
                continue
            } else {
                // Track all seen lowercase letters, even for the first encounter
                seenLowercase.insert(lowercaseChar)
            }
        } else {
            // If uppercase, check if corresponding lowercase exists after its position
            let restOfArray = letters.suffix(from: letters.index(letters.startIndex, offsetBy: index + 1))

            if !restOfArray.contains(lowercaseChar) {
                count += 1 // Valid case, increment count
                seenLowercase.remove(lowercaseChar) // Remove lowercase as seen
                continue
            } else if restOfArray.contains(lowercaseChar) {
                continue
            }
        }
        print(seenLowercase)
    }

    return count
}

// Test cases
print(ssolution("aaAbcCABBc"))  // Output: 2
print(ssolution("xyzXYZabcABC")) // Output: 6
print(ssolution("ABCabcAefG"))   // Output: 0


func ssolution(_ letters: String) -> Int {
    var seenLowercase = Set<Character>() // Stores seen lowercase letters
    var count = 0

    for (index, char) in letters.enumerated() {
        let lowercaseChar = char.lowercased().first!

        if char.isLowercase {
            let restOfArray = letters.prefix(upTo: letters.index(letters.startIndex, offsetBy: index))


            if restOfArray.contains(char.uppercased()) {
                print(seenLowercase)
                continue
            } else {
                seenLowercase.insert(lowercaseChar)
                print(seenLowercase)
                continue
            }


        } else if char.isUppercase {
            // If uppercase, check if corresponding lowercase exists after its position
            let restOfArray = letters.suffix(from: letters.index(letters.startIndex, offsetBy: index + 1))

            if !restOfArray.contains(lowercaseChar) {

                if seenLowercase.contains(char) {
                    print(seenLowercase)
                    continue
                } else if !seenLowercase.contains(char){
                    seenLowercase.remove(lowercaseChar)

                    count += 1 // Valid case, increment count

                    print(count)
                    print(seenLowercase)
                    continue
                }

            } else if restOfArray.contains(lowercaseChar) {
                print(count)
                continue
            }
        }
        print(seenLowercase)
    }

    return count
}

Answer 1

所提供代码的问题在于检查大写字母的条件。具体来说，当遇到大写字母时，代码会检查字符串中其位置后面是否存在相应的小写字母。如果是，代码将继续执行，而不增加计数。

但是，这种逻辑忽略了这样一个事实：小写字母可能已经出现在字符串的前面。在“ABCabcAefG”的情况下，首先遇到小写“a”，然后遇到大写“A”。代码错误地继续而不增加计数，导致输出不正确。

要解决这个问题，需要跟踪所有看到的小写字母，并在处理大写字母时检查当前位置之前是否遇到过相应的小写字母。我在之前的回复中提供的更新代码通过使用一组（已看到）来跟踪小写字母来解决此问题。

解决方案： 你现在的做法有点复杂，逻辑可以简化一下。这是您的函数的更新版本：

func solution(_ letters: String) -> Int {
var seen = Set<Character>() // Stores seen letters
var count = 0

for char in letters {
    let lowercaseChar = char.lowercased().first!

    if char.isLowercase {
        if !seen.contains(lowercaseChar) {
            seen.insert(lowercaseChar)
        }
    } else if char.isUppercase {
        if !seen.contains(lowercaseChar) {
            seen.insert(lowercaseChar)
            count += 1
        }
    }
}

return count
}

// Test cases
print(solution("aaAbcCABBc"))  // Output: 2
print(solution("xyzXYZabcABC")) // Output: 6
print(solution("ABCabcAefG"))   // Output: 0

这个版本通过直接检查小写对应项是否已经看到来简化逻辑。如果不是，则将其视为有效情况，并且计数会增加。 see 的集合用于跟踪迄今为止遇到的小写字符。这应该可以更有效地处理边缘情况。