Dictionary 使用go lang中的地图实现更高阶的嘶嘶嗡嗡声？

我正在尝试使用go lang中的maps实现fizz buzz问题。但是，这段代码的工作需要改进。由于在映射上迭代的

for

循环，它会继续打印不需要的和冗余的结果。我尝试了很多解决方案，但都失败了。不使用任何键片的帮助是否可行

package main

import "fmt"

func fizzbuzz(i int)  {
    myMap:= make(map[int]string)
    myMap[3] = "fizz"
    myMap[5] = "buzz"
    myMap[15] = "fizzbuzz"

    for k,v:= range myMap{
        if i%k==0 {fmt.Printf("%v \n",v)
        } else {fmt.Printf("%v \n",i)}
    }
}

func main() {

    for i:=1;i<10000;i++ {
        fizzbuzz(i)
    }

}

主程序包
输入“fmt”
func fizzbuzz（i int）{
myMap:=make（映射[int]字符串）
myMap[3]=“嘶嘶”
myMap[5]=“嗡嗡声”
myMap[15]=“嘶嘶作响”
对于k，v:=范围myMap{
如果i%k==0{fmt.Printf（“%v\n”，v）
}else{fmt.Printf（“%v\n”，i）}
}
}
func main（）{
对于i:=1；i带有地图
在您的规则集中，整个
for
循环应该是决定是否将
i
数字替换为一个单词。但是您在每次迭代中都会发出一个结果。for

的

最多应发出一个结果。如果
i
不能被任何键分割，则应发出
i

键可以是其他键的倍数（例如
15=3*5
），如果
i
数字可以被这样一个键分割，我们希望发出与最大键相关的单词。因此
for
循环不应该发出任何东西，因为如果你找到一个好键，可能会有一个更大的键。因此循环应该只找到最好的键

循环后，您可以检查是否找到任何正确的键，如果找到，则发出与其关联的单词，否则发出数字：

var rules = map[int]string{
    3:  "fizz",
    5:  "buzz",
    15: "fizzbuzz",
}

func fizzbuzz(i int) {
    max := -1
    for k := range rules {
        if i%k == 0 && k > max {
            max = k
        }
    }

    if max < 0 {
        fmt.Println(i)
    } else {
        fmt.Println(rules[max])
    }
}

func main() {
    for i := 1; i < 100; i++ {
        fizzbuzz(i)
    }

}

有秩序的切片
如果规则按键降序排序，您可以获得更好的性能，在这种情况下，您可以按该顺序检查键（首先检查最大键），然后第一个符合条件的键将是最大键。因此，您可以立即发出结果并返回

如果循环后继续执行，我们知道没有键是好的，我们可以发出
i
编号：

var rules = []struct {
    n    int
    word string
}{
    {15, "fizzbuzz"},
    {5, "buzz"},
    {3, "fizz"},
}

func fizzbuzz(i int) {
    for _, rule := range rules {
        if i%rule.n == 0 {
            fmt.Println(rule.word)
            return
        }
    }

    fmt.Println(i)
}

试穿这个

一般（不包括规则中的倍数）
虽然您从规则中包含
15=3*5
的规则集开始，但情况不应该是这样；您应该只列出
3
和
5
，
15
应该是隐式的

在这种情况下，您必须检查所有规则，因为每个好的键都应该发出一个单词。您必须记住是否找到了好的键，否则只发出
i
数字

这就是你可以做到的：

var rules = []struct {
    n    int
    word string
}{
    {3, "fizz"},
    {5, "buzz"},
}

func fizzbuzz(i int) {
    found := false
    for _, rule := range rules {
        if i%rule.n == 0 {
            found = true
            fmt.Print(rule.word)
        }
    }
    if !found {
        fmt.Print(i)
    }
    fmt.Println()
}

试穿一下

注意：在这个解决方案中，您也可以使用映射而不是切片；我使用切片的原因是，如果有多个好键，则发出的单词将始终以相同的顺序排列（通过增加键来定义），因为没有定义映射中键的迭代顺序。有关详细信息，请参阅前面提到的，映射中项的顺序在Go中是不确定的。尽管这里有一些简单的解决方案：

func fizzbuzz(n int) {
    for i := 1; i <= n; i++ {
        switch {
        case i%15 == 0:
            println("fizzbuzz")
        case i%5 == 0:
            println(`buzz`)
        case i%3 == 0:
            println(`fizz`)
        default:
            println(i)
        }
    }
}

func fizzbuzzList(n int) []string {
    var res []string
    for i := 1; i <= n; i++ {
        switch {
        case i%15 == 0:
            res = append(res, `fizzbuzz`)
        case i%5 == 0:
            res = append(res, `buzz`)
        case i%3 == 0:
            res = append(res, `fizz`)
        default:
            res = append(res, strconv.Itoa(i))
        }
    }
    return res
}

func fizzbuzzLazy(n int) chan string {
    var res = make(chan string)
    go func() {
        for i := 1; i <= n; i++ {
            switch {
            case i%15 == 0:
                res <- `fizzbuzz`
            case i%5 == 0:
                res <- `buzz`
            case i%3 == 0:
                res <- `fizz`
            default:
                res <- strconv.Itoa(i)
            }
        }
        close(res)
    }()
    return res
}

请在问题中提供相关代码。不允许仅链接到源代码库。并询问有关您的问题的具体信息。
func fizzbuzz(n int) {
    for i := 1; i <= n; i++ {
        switch {
        case i%15 == 0:
            println("fizzbuzz")
        case i%5 == 0:
            println(`buzz`)
        case i%3 == 0:
            println(`fizz`)
        default:
            println(i)
        }
    }
}

func fizzbuzzList(n int) []string {
    var res []string
    for i := 1; i <= n; i++ {
        switch {
        case i%15 == 0:
            res = append(res, `fizzbuzz`)
        case i%5 == 0:
            res = append(res, `buzz`)
        case i%3 == 0:
            res = append(res, `fizz`)
        default:
            res = append(res, strconv.Itoa(i))
        }
    }
    return res
}

func fizzbuzzLazy(n int) chan string {
    var res = make(chan string)
    go func() {
        for i := 1; i <= n; i++ {
            switch {
            case i%15 == 0:
                res <- `fizzbuzz`
            case i%5 == 0:
                res <- `buzz`
            case i%3 == 0:
                res <- `fizz`
            default:
                res <- strconv.Itoa(i)
            }
        }
        close(res)
    }()
    return res
}

fizzbuzz(20)

for _, v := range fizzbuzzList(20) {
    println(v)
}

for v := range fizzbuzzLazy(20) {
    println(v)
}