Question

如何实现一个带深度参数的嵌套迭代器。一个简单的迭代器就是当depth = 1时。它是一个简单的迭代器，它运行就像一个简单的for循环。

func Iter () chan int {
    ch := make(chan int);
    go func () {
        for i := 1; i < 60; i++ {
            ch <- i
        }
        close(ch)
    } ();
    return ch
}

输出为1,2,3...59

深度= 2输出为"1,1" "1,2" ... "1,59" "2,1" ... "59,59"

深度= 3输出为"1,1,1" ... "59,59,59＆＃34;

我想避免嵌套的for循环。这里有什么解决方案？

Answer 1

我不知道是否可以避免嵌套循环，但一种解决方案是使用渠道管道。例如：

const ITER_N = 60

// ----------------

func _goFunc1(out chan string) {
    for i := 1; i < ITER_N; i++ {
        out <- fmt.Sprintf("%d", i)
    }
    close(out)
}

func _goFuncN(in chan string, out chan string) {
    for j := range in {
        for i := 1; i < ITER_N; i++ {
            out <- fmt.Sprintf("%s,%d", j, i)
        }
    }
    close(out)
}

// ----------------

// create the pipeline
func IterDepth(d int) chan string {
    c1 := make(chan string)
    go _goFunc1(c1)

    var c2 chan string
    for ; d > 1; d-- {
        c2 = make(chan string)
        go _goFuncN(c1, c2)
        c1 = c2

    }
    return c1
}

您可以使用以下方法进行测试：

func main() {
    c := IterDepth(2)

    for i := range c {
        fmt.Println(i)
    }
}

Answer 2

我通常使用闭包来实现迭代器。多个维度不会使问题变得更加困难。以下是如何执行此操作的一个示例：

package main

import "fmt"

func iter(min, max, depth int) func() ([]int, bool) {
    s := make([]int, depth)
    for i := range s { 
        s[i] = min 
    }   
    s[0] = min - 1 
    return func() ([]int, bool) {
        s[0]++
        for i := 0; i < depth-1; i++ {
            if s[i] >= max {
                s[i] = min 
                s[i+1]++
            }   
        }   
        if s[depth-1] >= max {
            return nil, false
        }   
        return s, true
    }   
}   

func main() {
    // Three dimensions, ranging between [1,4)
    i := iter(1, 4, 3)
    for s, ok := i(); ok; s, ok = i() {
        fmt.Println(s)
    }   

}

在Playground上试一试。

这是一个简单的更改，例如，将参数作为单个int切片提供，这样您就可以拥有每维度限制，如果需要这样的话。

编写深度为d的嵌套迭代器

2 个答案: