Go 围棋分块

我有一个包含210万个日志字符串的切片，我想创建一个切片，使字符串尽可能均匀分布

以下是我到目前为止的情况：

// logs is a slice with ~2.1 million strings in it.
var divided = make([][]string, 0)
NumCPU := runtime.NumCPU()
ChunkSize := len(logs) / NumCPU
for i := 0; i < NumCPU; i++ {
    temp := make([]string, 0)
    idx := i * ChunkSize
    end := i * ChunkSize + ChunkSize
    for x := range logs[idx:end] {
        temp = append(temp, logs[x])
    }
    if i == NumCPU {
        for x := range logs[idx:] {
            temp = append(temp, logs[x])
        }
    }
    divided = append(divided, temp)
}

//日志是一个包含210万个字符串的切片。
var divided=make（[]字符串，0）
numpu:=runtime.numpu（）
ChunkSize:=len（日志）/numpu
对于i:=0；i

idx:=i*ChunkSize

将为

logs

索引提供当前的“chunk start”，而

end:=i*ChunkSize+ChunkSize

将为该块提供“chunk end”或该块范围的结尾。我找不到任何关于如何在Go中分块/分割切片或在有限范围内迭代的文档或示例，所以我想到了这一点。但是，它只会多次复制第一个块，因此无法工作

---

如何（尽可能均匀地）在Go中分块一个切片？

您不需要制作新切片，只需将

日志的切片添加到
分割的
切片中即可


var除以[][]字符串
chunkSize:=（len（日志）+numpu-1）/numpu
对于i:=0；i长度（日志）{
end=len（日志）
}
分割=追加（分割，记录[i:end]）
}
fmt.Printf（“%#v\n”，除以）
另一种变体。它的工作速度大约是我们提出的2.5倍。这些测试和基准是非常重要的


func块（xs[]string，chunkSize int）[]string{
如果len（xs）==0{
归零
}
分割：=make（[]string，（len（xs）+chunkSize-1）/chunkSize）
上一个：=0
i:=0
直到：=len（xs）-chunkSize
对于上一个<直到{
下一步：=prev+chunkSize
除以[i]=xs[prev:next]
上一个=下一个
我++
}
除以[i]=xs[prev:]
收益分配
}
ahhhh这就是我所缺少的。我一直试图在有限的范围内进行迭代，而不是通过块长度进行迭代。我花了8个小时想办法让我的工作起来，哈哈。谢谢你的回答，非常有帮助。你看起来在
除以
的长度上差了一个。例如，
numpu=3；日志=日志[：8]；chunkSize:=len（logs）/numpu；如果chunkSize==0{chunkSize=1}分为4个，而不是3个：。对于
chunkSize
，写入
chunkSize:=（len（logs）+numpu-1）/numpu：。@peterSO:谢谢，只是从原件上抄下来的，没想检查一下。
var divided [][]string

chunkSize := (len(logs) + numCPU - 1) / numCPU

for i := 0; i < len(logs); i += chunkSize {
    end := i + chunkSize

    if end > len(logs) {
        end = len(logs)
    }

    divided = append(divided, logs[i:end])
}

fmt.Printf("%#v\n", divided)

func chunks(xs []string, chunkSize int) [][]string {
    if len(xs) == 0 {
        return nil
    }
    divided := make([][]string, (len(xs)+chunkSize-1)/chunkSize)
    prev := 0
    i := 0
    till := len(xs) - chunkSize
    for prev < till {
        next := prev + chunkSize
        divided[i] = xs[prev:next]
        prev = next
        i++
    }
    divided[i] = xs[prev:]
    return divided
}