查找数组组合的中点答案

【问题标题】：Finding the midpoint of the combinations of an array查找数组组合的中点
【发布时间】：2018-02-01 17:49:29
【问题描述】：

我有一个在 Rust 中实现 Iterator 的结构（尽管该问题可能适用于任何语言）来计算数组的组合。迭代器是用一个初始数组创建的，该数组定义了数组中每个条目的最大值。迭代器的实际代码仍在进行中，因此可能有很多地方可以改进。

例如，如果我使用Combo::new() 函数创建一个Combo，并给出set_max 数组[4,3,2,1]，那么迭代器将生成长度为4 的数组的所有组合，这样没有条目超过set_max 中给出的条目。

因此，生成的第一个数组是[0,0,0,1]，然后是[0,0,1,0]、[0,0,1,1]、[0,0,2,0]、[0,0,2,1]、[0,1,0,0] 等。本质上，它一次增加一个条目，直到条目被最大化。然后它重置它并开始一次增加两个条目。

我希望这个迭代器在某个时候实现rayon::ParallelIterator，但首先，我相信我需要一种方法将组合的计算分成两半。

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

找到这个中点后，我对实现拆分函数有了一些想法：添加一个 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())
    }
}

【问题讨论】：

您是否希望在同一个 Combo 上创建两个迭代器？
这更像是一个数学问题而不是编程。

标签： arrays parallel-processing iterator rust combinations

【解决方案1】：

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

[4, 3, 2, 1]

可以这样剪：

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]。

【讨论】：