数组包含一个完整的子数组

Question

在 Swift 中，我如何检查一个数组是否包含一个给定的子数组？例如，有没有像这样工作的contains 函数：

let mainArray = ["hello", "world", "it's", "a", "beautiful", "day"]
contains(mainArray, ["world", "it's"])   // would return true
contains(mainArray, ["world", "it"])   // would return false
contains(mainArray, ["world", "a"])   // would return false - not adjacent in mainArray

Answer 1

您可以使用更高级别的函数来做到这一点，如下所示：

func indexOf(data:[String], _ part:[String]) -> Int? {
    // This is to prevent construction of a range from zero to negative
    if part.count > data.count {
        return nil
    }

    // The index of the match could not exceed data.count-part.count
    return (0...data.count-part.count).indexOf {ind in
        // Construct a sub-array from current index,
        // and compare its content to what we are looking for.
        [String](data[ind..<ind+part.count]) == part
    }
}

此函数返回第一个匹配项的索引（如果有），否则返回nil。

您可以按如下方式使用它：

let mainArray = ["hello", "world", "it's", "a", "beautiful", "day"]
if let index = indexOf(mainArray, ["world", "it's"]) {
    print("Found match at \(index)")
} else {
    print("No match")
}

作为通用数组的扩展编辑...

这现在可以用于Equatable 类型的任何同构数组。

extension Array where Element : Equatable {
    func indexOfContiguous(subArray:[Element]) -> Int? {

        // This is to prevent construction of a range from zero to negative
        if subArray.count > self.count {
            return nil
        }

        // The index of the match could not exceed data.count-part.count
        return (0...self.count-subArray.count).indexOf { ind in
            // Construct a sub-array from current index,
            // and compare its content to what we are looking for.
            [Element](self[ind..<ind+subArray.count]) == subArray
        }
    }
}

Answer 2

据我所知，这样的功能是不存在的。但是您可以使用以下扩展名添加功能：

extension Array where Element: Equatable {
    func contains(subarray: [Element]) -> Bool {
        guard subarray.count <= count else { return false }
    
        for idx in 0 ... count - subarray.count {
            let start = index(startIndex, offsetBy: idx)
            let end = index(start, offsetBy: subarray.count)
            if Array(self[start ..< end]) == subarray { return true }
        }        
        return false
    }
}

将扩展添加到您的项目后，您只需调用：

mainArray.contains(["world", "it's"]) // true
mainArray.contains(["world", "it"])   // false
mainArray.contains(["it's", "world"]) // false

let array2 = ["hello", "hello", "world"]
array2.contains(["hello", "world"]) // true
[1, 1, 1, 2].contains(subarray: [1, 1, 2]) // true

Answer 3

simpleBob 的第一次尝试似乎只做了很少的修改：

extension Array where Element: Equatable {
    func contains(subarray: [Element]) -> Index? {
        var found = 0
        var startIndex:Index = 0
        for (index, element) in self.enumerate() where found < subarray.count {
            if element != subarray[found] {
                found = 0
            }
            if element == subarray[found]  {
                if found == 0 { startIndex = index }
                found += 1
            }
        }

        return found == subarray.count ? startIndex : nil
    }
}

Answer 4

这个想法可以扩展到所有等价序列。

public extension Sequence where Element: Equatable {
  /// The iterators of all subsequences, incrementally dropping early elements.
  /// - Note: Begins with the iterator for the full sequence (dropping zero).
  var dropIterators: AnySequence<AnyIterator<Element>> {
    .init(
      sequence(state: makeIterator()) {
        let iterator = $0
        return $0.next().map { _ in .init(iterator) }
      }
    )
  }

  /// - Note: `false` if `elements` is empty.
  func contains<Elements: Sequence>(inOrder elements: Elements) -> Bool
  where Elements.Element == Element {
    elements.isEmpty
      ? false
      : dropIterators.contains {
        AnySequence(zip: ($0, elements))
          .first(where: !=)?.1 == nil
      }
  }
}

public extension Sequence {
  /// The first element of the sequence.
  /// - Note: `nil` if the sequence is empty.
  var first: Element? {
    var iterator = makeIterator()
    return iterator.next()
  }

  /// Whether the sequence iterates exactly zero elements.
  var isEmpty: Bool { first == nil }
}

public extension AnySequence {
  /// Like `zip`, but with `nil` elements for the shorter sequence after it is exhausted.
  init<Sequence0: Sequence, Sequence1: Sequence>(
    zip zipped: (Sequence0, Sequence1)
  ) where Element == (Sequence0.Element?, Sequence1.Element?) {
    self.init(
      sequence(
        state: (zipped.0.makeIterator(), zipped.1.makeIterator())
      ) { iterators in
        Optional(
          (iterators.0.next(), iterators.1.next())
        )
        .filter { $0 != nil || $1 != nil }
      }
    )
  }
}

public extension Optional {
  /// Transform `.some` into `.none`, if a condition fails.
  /// - Parameters:
  ///   - isSome: The condition that will result in `nil`, when evaluated to `false`.
  func filter(_ isSome: (Wrapped) throws -> Bool) rethrows -> Self {
    try flatMap { try isSome($0) ? $0 : nil }
  }
}

Answer 5

我想我会添加一个我正在使用的变体，它返回子数组（或 nil）的起始索引。拥有索引会很方便，这更符合最近 Swift 版本中使用的约定（即firstIndex(of:) 而不是contains()）。 作为个人调整，在 subarray.count > array.count 的情况下，如果两者以相同的元素开头（否则为零），它将返回 0。如果你不想要这种（有点奇怪）的行为，你可以从 guard 块中返回 nil。

extension Array where Element: Equatable {
    func firstIndex(ofSubarray subarray: [Element]) -> Int? {
        guard subarray.count <= count else {
            return self == Array(subarray[0 ..< self.count]) ? 0 : nil
        }
        
        for idx in 0 ... count - subarray.count {
            let start = index(startIndex, offsetBy: idx)
            let end = index(start, offsetBy: subarray.count)
            if Array(self[start ..< end]) == subarray { return idx }
        }
        return nil
    }
}

Answer 6

数组没有您正在寻找的内置功能，但是您可以使用专为处理此类情况而设计的集合。

let mainSet:Set = ["hello", "world", "it's", "a", "beautiful", "day"]
let list2:Set = ["world", "it's"]
let list3:Set = ["world","a"]
list2.isSubsetOf(mainSet)