Question

我有一个要解决的问题

我正在尝试查找单词的中间字符。如果单词的长度是奇数，则返回中间字符。如果单词的长度是偶数，请返回中间的2个字符

func middle(_ str: String) -> String {
    let arr = Array(str).map{$0}

    print(arr)
//    if arr.count
    for myInt: String in arr {
        if myInt % 2 == 0 {
            println("\(myInt) is even number")
        } else {
            println("\(myInt) is odd number")
        }
    }
    return ""
}

Answer 1

假设您的字符串是整个单词（否则，在使用此属性之前，您需要先通过word枚举字符串）：

extension StringProtocol {
    var middle: SubSequence {
        if isEmpty { return "" }
        if count == 1 { return  self[startIndex...startIndex] }
        let middleIndex = index(startIndex, offsetBy: count/2)
        let previous = index(before: middleIndex)
        return count % 2 == 0 ? self[previous...middleIndex] : self[middleIndex...middleIndex]
    }
}

"abc".middle
"abcd".middle

Answer 2

您可以使用此功能：

func middle(_ str: String) -> String {

    let count = str.count

    if count < 2 {
        return str
    }

    let start = str.index(str.startIndex, offsetBy: (count - 1)/2)
    let end = str.index(str.startIndex, offsetBy: (count + 2)/2)

    return String(str[start..<end])
}

以下是一些用例：

middle("")          //""
middle("1")         //"1"
middle("12")        //"12"
middle("123")       //"2"
middle("1234")      //"23"
middle("12345")     //"3"

Answer 3

让我们尝试系统地解决这个问题。第一项任务是确定“中间部分”的第一个和最后一个字符的偏移量。如果我们用一些代表性案例制作一张桌子

string  result  length  first   last
------------------------------------
a       a       1       0       0
ab      ab      2       0       1
abc     b       3       1       1
abcd    bc      4       1       2
abcde   c       5       2       2
abcdef  cd      6       2       3

然后我们可以得出

firstIndex = (length - 1) / 2
lastIndex = length / 2

其中/是截断整数除法。空字符串必须单独处理。

最后，我们需要知道如何使用Swift字符串中的索引和偏移量，这在A New Model for Collections and Indices中进行了解释。

这导致实施

func middle(_ str: String) -> String {
    if str.isEmpty { return "" }
    let len = str.count
    let fromIdx = str.index(str.startIndex, offsetBy: (len - 1)/2)
    let toIdx = str.index(str.startIndex, offsetBy: len/2)
    return String(str[fromIdx...toIdx])
}

Answer 4

这是另一个示例：

添加此扩展名

extension StringProtocol {

    subscript(offset: Int) -> Element {
        return self[index(startIndex, offsetBy: offset)]
    }
    subscript(range: CountableClosedRange<Int>) -> SubSequence {
        return prefix(range.lowerBound + range.count)
            .suffix(range.count)
    }
}

像

一样使用

let stringLength: Int = str.count
if stringLength % 2 == 0{
    //even
    print(str[((stringLength/2) - 1)...(stringLength/2)])
}else{
    //odd
    print(str[(stringLength/2) - 1])
}

中人物迅捷

4 个答案: