Array, eksiksiz bir alt dizgi içeriyor

Question

Swift'de, bir dizinin bütünüyle belirli bir alt dizgeyi içerip içermediğini nasıl kontrol edebilirim?

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

bunu, üst düzey işlevleri ile yapabilirsiniz:

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 
    } 
} 

Bu fonksiyon ilk maçında dizinini, varsa, ya nil otherwi döndürür se. aşağıdaki gibi

Bunu kullanabilirsiniz:

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") 
} 

Düzenleme bir jenerik diziye bir uzantısı olarak ...

Bu şimdi Equatable türlerinin herhangi homojen dizisi için kullanılabilir.

Answer 2

sen ancak böyle senaryolar işlemek için tasarlanmış setlerini kullanabilirsiniz aradığınız dahili yeterliliklere sahip olmayan diziler ..

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

: Ör bu gibi çalışır bir contains işlevi vardır

Answer 3

Bildiğim kadarıyla böyle bir işlev mevcut değil. Ama şu uzantılı işlevsellik ekleyebilirsiniz: uzatma projenize eklendikten sonra

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

     return found == subarray.count 
    } 
} 

, sadece çağırabilirsiniz:

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

let array2 = ["hello", "hello", "world"] 
array2.contains(["hello", "world"]) // would return true 

Answer 4

simpleBob ilk denemesi minimal değişiklik ile çalışmak gibi görünüyor

:

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 
    } 
}