Swift - 在数组中搜索数字模式

Question

我在 Swift 中组合了一个算法，其中一部分需要检查给定的数组并确定是否有 2 个（或 3、4 个 - 已注释掉）数字的任何序列重复。我的源代码是来自 Java 的代码块，据我所知，我尝试将其转换为 Swift - Playgrounds。它有点工作，但运行代码后会引发错误

“不能用upperBound

在它崩溃之前，输出是正确的并提供模式的序列。请问如何预防？

let array1 = [12, 4, 5, 7, 1, 2]
let array2 = [1, 2, 3, 1, 2, 3, 1, 2, 3]
let array3 = [1, 1, 1, 1, 1, 1 ]
let array4 = [1, 2, 4, 12, 13, 1, 8, 4, 12, 4 ]
let array5 = [17,39,78,324,43,33,234,99,34,555,39,78,324,43,45,92 ]

func hasPattern(c:Array<Int>) {
for i in 0..<c.count {
    var jj = i + 1

    let step2 = (c.count - i) 
    for j in jj..<step2 {

        if(c[j] == c[i]){

            // pattern of 4 numbers repeating
            /*if(c[j+1] == c[i+1] && c[j+2] == c[i+2] && c[j+3] == c[i+3]){
                print("\(c[i]), \(c[i+1]), \(c[i+2]), \(c[i+3])")                    
            }*/

            // pattern of 3 numbers repeating
            /*
            if(c[j+1] == c[i+1] && c[j+2] == c[i+2]){
             print("\(c[i]), \(c[i+1]), \(c[i+2])")
             }
             */

            // pattern of 2 numbers repeating
            if(c[j+1] == c[i+1]){
                print("\(c[i]), \(c[i+1])")
            }
         }
      }
   }
}
/*
print(hasPattern(c: array1))
print(hasPattern(c: array2))
print(hasPattern(c: array3))*/
//print(hasPattern(c: array4))

print(hasPattern(c: array5))

我在这里错过了什么？谢谢。

Answer 1

我仍然觉得你的问题并不完全清楚。数组 [2,3,2,3,2] 是否有 2 个重复的 [2,3,2] 子序列，即使它们共享一个元素？

如果您想避免“无法形成范围...”错误，请使用stride：

// A more convenient way to check if two arrays are equal
func ==(lhs: [Int], rhs: [Int]) -> Bool {
    guard lhs.count == rhs.count else { return false }

    for (l, r) in zip(lhs, rhs) {
        if l != r { return false }
    }
    return true
}

// If there's no matching pattern, this function will return nil
// instead of an aempty array. Change it if you want to
func hasPattern(array: [Int], length: Int) -> [[Int]]? {
    guard array.count >= length * 2 else { return nil }

    var result = [[Int]]()
    for i in 0..<(array.count - length) {
        let subarray1 = array[i..<(i+length)]

        for j in stride(from: i+1, to: array.count - length, by: 1) {
            let subarray2 = array[j..<(j+length)]
            if subarray1 == subarray2 {
                result.append(Array(subarray1))
            }
        }
    }
    return result.isEmpty ? nil : result
}

if let patterns = hasPattern(array: array5, length: 3) {
    print(patterns) // [[39, 78, 324], [78, 324, 43]]
} else {
    print("No repeating pattern found")
}

Answer 2

您的问题在于您的内部循环。对于一个大小为 5 的数组，循环如下：

for i in 0..<5
    for j in i+1..<5-i

会有一个点，+i 和 -i 发生冲突，你的下限变得大于你的上限。

如果您不明确需要推出自己的算法，最好使用以下方法执行搜索：

func hasPattern(elements :Array<Int>) -> Bool {
    var index = 0
    while index < (array.count - elements.count) {
        let subarray = array[index ..< (index + elements.count)]
        if subarray.elementsEqual(elements) {
            return true
        }
        index += 1
    }
    return false
}

array 是您要搜索的数组。