Arrays 求数组组合的中点

我有一个struct，它在Rust中实现了

迭代器

（尽管这个问题可能适用于任何语言）来计算数组的组合。迭代器由一个初始数组创建，该数组定义数组中每个项的最大值。迭代器的实际代码仍在进行中，因此可能有许多地方需要改进

例如，如果我使用

Combo:：new（）

函数创建了一个

Combo

，并且我给出了

set\u max

数组，

[4,3,2,1]

，那么迭代器将生成长度为4的数组的所有组合，这样就没有条目超过

set\u max

中给出的条目

因此，生成的第一个数组是

[0,0,0,1]

，后面是

[0,0,1,0]

，

[0,0,1,1]

，

[0,0,2,0]

，

[0,0,2,1]

，

[0,1,0]

，等等。本质上，它一次递增一个条目，直到条目最大化。然后它重置它并开始一次递增两个条目

我希望这个迭代器在某个时候实现

rayon:：ParallelIterator

，但首先，我认为我需要一种将组合的计算一分为二的方法

如何找到迭代器的中间点，以便将其分成两部分

找到这个中点后，我对实现split函数有了一些想法：添加一个set_min数组，该数组指定一个起点，从该起点开始递增条目。但问题的重点是如何找到一般的中点

#[derive(Clone)]
pub struct Combos {
    pub set_max: Vec<usize>,
    set_current: Vec<usize>,
    size: usize,
}

impl Combos {
    pub fn new(set_max: Vec<usize>) -> Combos {
        Combos {
            set_current: vec![0; set_max.len()],
            size: set_max.iter().fold(1, |acc, x| (x + 1) * acc) - 1,
            set_max: set_max,
        }
    }

    fn increment_combo(&self, length: usize, combo: &[usize]) -> Vec<usize> {
        if let Some(last) = combo.last() {
            if *last == self.set_max[length - 1] {
                let mut v = self.increment_combo(length - 1, &combo[..length - 1]);
                v.push(0);
                return v
            } else {
                let mut v = combo.to_vec();
                v[length - 1] = last + 1;
                return v
            }
        } else {
            return Vec::new()
        }
    }
}

impl Iterator for Combos {
    type Item=Vec<usize>;

    fn next(&mut self) -> Option<Vec<usize>> {
        if self.set_current == self.set_max {
            return None
        }

        self.set_current = self.increment_combo(self.set_max.len(), &self.set_current);
        return Some(self.set_current.clone())
    }
}

#[派生（克隆）]
发布结构组合{
pub set_max:Vec，
设置_电流：Vec，
大小：usize，
}
impl组合{
pub fn new（set_max:Vec）->组合{
组合{
设置当前值：vec！[0；设置最大值（），
尺寸：设置最大iter（）.折叠（1，| acc，x |（x+1）*acc）-1，
设置最大值：设置最大值，
}
}
fn增量组合（&self，长度：usize，组合：&usize]）->Vec{
如果让Some（last）=combo.last（）{
如果*last==self.set_max[length-1]{
设mut v=self.increment_combo（长度-1，&combo[…长度-1]）；
v、 推（0）；
返回v
}否则{
设mut v=combo.to_vec（）；
v[长度-1]=最后一个+1；
返回v
}
}否则{
返回Vec:：new（）
}
}
}
组合的impl迭代器{
项目类型=Vec；
fn下一步（&mut self）->选项{
如果self.set\u current==self.set\u max{
一无所获
}
self.set\u current=self.increment\u组合（self.set\u max.len（），&self.set\u current）；
返回一些（self.set\u current.clone（））
}
}

由于第一个值是算法中最后一个递增的值（最重要的值），因此只需将数组的第一个值减半即可将操作减半：

可以这样切割：

first part:  [0, 3, 2, 1] -> [1, 3, 2, 1]
second part: [2, 3, 2, 1] -> [3, 3, 2, 1]

---

因此，这很容易将算法分成两半：用

[2,3,2,1]

调用第一部分，用

[4,3,2,1]

调用第二部分，开头如下：

[2,0,0,0]

将操作分成两半，由于第一个值是算法中最后一个递增的值（最重要的值）：

可以这样切割：

first part:  [0, 3, 2, 1] -> [1, 3, 2, 1]
second part: [2, 3, 2, 1] -> [3, 3, 2, 1]

---

因此，将算法分成两半很容易：用

[2,3,2,1]

调用第一部分，用

[4,3,2,1]

调用第二部分，开头是：

[2,0,0]

您是否希望在同一个

组合上创建两个迭代器

？这与其说是编程，不如说是一个数学问题。您是否希望在同一个

组合上创建两个迭代器

？这与其说是编程，不如说是一个数学问题。