Go 如何从一个数组中的所有项与另一个数组中的某些项匹配的数组中筛选数组？ TL/DR

如何根据字符串数组过滤中的数组

go中是否有与JS/Py相当的

some

或

any

，如果一个数组中的某些或所有项存在于另一个数组中，我可以在其中过滤一个数组

因此，将此视为源数组：

数组：=[]字符串{
{“一些”，“价值”}，
{“一些”，“价值”，“另一个”}，
{“值”、“另一个”、“测试”}，
{“值”，“测试”}，
{“一些”，“测试”}，
}

我想通过

[]字符串{“some”，“value”}

过滤

数组

，如果这里的所有项都在数组中找到

预期产量为

[[some value] [some value another]]

或者，如果我将过滤器更改为

[]字符串{“some”，“test”}

，则预期值为

[[some test]]]

我可以在我的测试代码中很好地理解逻辑

主程序包
输入“fmt”
func inArray（s字符串，arr[]字符串）bool{
对于u，a:=范围arr{
如果s==a{
返回真值
}
}
返回错误
}
func main（）{
数组：=[]字符串{
{“一些”，“价值”}，
{“一些”，“价值”，“另一个”}，
{“值”、“另一个”、“测试”}，
{“值”，“测试”}，
{“一些”，“测试”}，
}
filterBy:=[]字符串{“某些”，“值”}
保留：=生成（[]字符串，0）
//忽略此项，因为它无法按预期工作
对于u，arr:=范围数组{
对于uf:=范围过滤器by{
如果正常：=inArray（f，arr）；正常{
保持=附加（保持，arr）
}
}
}
fmt.Println（等待）
}

inArray函数中的逻辑对于检查单针

s串

是否处于草堆

arr[]string

中是正确的。如果您想扩展它以检查是否所有的针

ss[]string

都存在于草堆

arr[]string

，那么您至少也需要在针上循环。以下是一个例子：

func allInArray(ss []string, arr []string) bool {
    for _, s := range ss {
        if !inArray(s, arr) {
            return false
        }
    }
    return true
}

当然，这是非常低效的，因为它在干草堆

arr

上循环的次数相当于

ss

中的针数。为了提高效率，您可以预处理干草堆，将其转换为

map[string]struct{}

，然后对照map的键检查针，如下所示：

func allInArray(ss []string, arr []string) bool {
    present := make(map[string]struct{})
    for _, a := range arr {
        present[a] = struct{}{}
    }
    for _, s := range ss {
        if _, ok := present[s]; !ok {
            return false
        }
    }
    return true
}

---

这将在

arr

上迭代一次以创建查找映射，然后在

ss

上迭代一次，利用映射的恒定查找时间检查

ss

的元素是否存在于

arr
中，检查在每个数组中找到的数组的所有筛选器字符串，然后决定在切片中追加。我还添加了一些评论

 hold := make([][]string, 0)
 for _, arr := range arrays {
    isValid := true // Initialy set true
    for _, f := range filterBy {
        if ok := inArray(f, arr); !ok {
            isValid = false // if any filter string does match then make false and break
            break
        }
    }
    // If all filter string found the isValid is true, then append in slice
    if(isValid){ 
       hold = append(hold, arr)
    }
}

围棋场的完整代码

但有效的解决办法是

filterByMap := make(map[string]bool)
// Create a map for filter slice
for _, a := range filterBy {
    filterByMap[a] = true
}
for _, arr := range arrays {
    cnt := 0 // Initial the counter
    for _, a := range arr {
      if filterByMap[a] {
          cnt++  // Increment the counter if filter string found
      }
    }
    // Check if all filter string found ? Append if yes
    if(cnt >= len(filterBy)){ 
         hold = append(hold, arr)
    }
}

完整代码
以下哪项有助于您回答问题，隐马尔可夫模型。。。不完全是。我可以看到这些帖子中的大多数都引用了for循环中的指针，或者范围是如何工作的，但这并不能真正帮助我达到我想要达到的目的。你在每次迭代中重复使用
arr
，做的事情与所有这些问题完全相同。总的逻辑问题是另一回事我道歉。很新，我不完全理解你隐晦的评论。我想我可以试着重写它，在这里它将返回每个过滤器项的布尔数组，然后尝试从布尔数组中获取一个布尔值，以复制一个
some
函数。为每个数组创建映射是一个低效的解决方案，而创建过滤器数组映射更高效。你完全正确——你的解决方案更高效，但假设每个指针在大海捞针时只出现一次。请参阅一些反例。@粘贴我不知道OP是否也需要这方面，但你是对的