Question

在这种情况下，我有3个布尔变量（已经设置为true或false）

此处的目标是确定是否将一组布尔变量设置为true

现在我写了下面的代码，它可以正常工作：

    boolval := 0
    if *firstbool {
        boolval++
    }
    if *secondbool {
        boolval++
    }
    if *thirdbool {
        boolval++
    }
    if boolval > 1 {
        // More than 1 of the bool vars are true
    }

如果我要写连续的if{}语句，我总是标记我的逻辑，所以我想问问天才们，你将如何做到这一点。

Answer 1

确定是否一组布尔变量设置为true

例如，编写一个set函数：

package main

import "fmt"

func nTrue(b ...bool) int {
    n := 0
    for _, v := range b {
        if v {
            n++
        }
    }
    return n
}

func main() {
    v1, v2, v3 := true, false, true

    fmt.Println(nTrue(v1, v2, v3))

    if nTrue(v1, v2, v3) > 1 {
        // . .   .
    }
    // Or
    if n := nTrue(v1, v2, v3); n > 1 {
        // . .   .
    }
    // Or
    n := nTrue(v1, v2, v3)
    if n > 1 {
        // . .   .
    }
}

游乐场：https://play.golang.org/p/g3WCN6BgGly

输出：

例如，在集合范围内

package main

import "fmt"

func main() {
    v1, v2, v3 := true, false, true

    boolval := 0
    for _, v := range []bool{v1, v2, v3} {
        if v {
            boolval++
        }
    }
    if boolval > 1 {
        // . .   .
    }

    fmt.Println(boolval > 1, boolval)
}

游乐场：https://play.golang.org/p/R6UGb8YYEFw

输出：

true 2

Answer 2

也许我是在悲剧性地误解了一些东西，但是这个问题看起来像是布尔代数中的练习。

首先：让我们澄清一下“和”的含义

这里的目标是确定是否一组布尔变量都设置为true

因此，“求和”实际上是指：“不止一次” 或“两次以上”

第二：让我们直接写“不止一次”

func MoreThanOnce(a, b, c bool) bool {
    return ( 
        a&&(b||c)) || 
        (a||b)&&c ||        
        (a||c)&&b
}

第三：简化

func MoreThanOnce(a, b, c bool) bool { return a&&b || a&&c  || b&&c}

结果

一行，没有if，没有通道，没有指针。

这是想要的吗？

更新

来自@peterSO评论：

在该示例中，有三个连续的if语句。也许有四个，七个或四十二个连续的if语句。您如何总结这些例子？

概括

func MoreThanOnce(vs...bool) (result bool){
    for i:=0; i<len(vs); i++{
      for j:=i+1; j<len(vs); j++{ 
        if i!=j{  // this `if` could be omitted
        result = result || vs[i] && vs[j]
        }
      }
    }
    return
}

问的是这个吗？

Answer 3

取决于您如何获取package main import "fmt" func firstFunc(ch chan bool) { // assume this works, true! ch <- true } func secondFunc(ch chan bool) { // assume this fails, false! ch <- false } func thirdFunc(ch chan bool) { // assume this works, true! ch <- true } func listener(ch chan bool, numCallers int) <-chan bool { outch := make(chan bool) THRESHOLD := 2 go func(outch chan<- bool) { count := 0 trues := 0 for count < numCallers && trues < THRESHOLD { val := <-ch if val { trues++ } count++ } outch <- trues >= THRESHOLD }(outch) return outch } func main() { ch := make(chan bool) resultch := listener(ch, 3) go firstFunc(ch) go secondFunc(ch) go thirdFunc(ch) if <-resultch { fmt.Println("Two or more processes succeeded") } }等的值。此外，您可能应该在这里采取更惯用的方法。考虑到通道和goroutines可以在后台处理计费。如果您的布尔值是某些较重操作的结果，则可以执行以下操作：

{{1}}

但是，出于简单的需要，对它们进行了过度设计，因此，仅当此模式适合您的应用程序的较大设计时，才考虑这样做。

如何获得真实布尔值的“和”

3 个答案:

首先：让我们澄清一下“和”的含义

第二：让我们直接写“不止一次”

第三：简化

结果

概括