Best way to find all unique combinations of elements of an array? - arrays

Question

I have an array of some particular ints, and I want to find all the unique combinations (by addition) of these ints. I'm sure there's a way to do this functionally; I'm trying to avoid the iterative way of shoving for loops inside of for loops. I'm using Rust in this case, but this question is more generally a, "functional programming, how do?" take.
My first thought is that I should just zip every entry in v with every other entry, reduce them by addition to a single element, and filter duplicates. This is O(|v|^2), which feels bad, meaning I'm probably missing something fairly obvious to the functional whiz kids. Also I'm not even sure how to do it, I'd probably use a for loop to construct my new massive array.
My first pass: note that v holds all the numbers I care about.
let mut massive_arr = Vec::new();
for &elem in v.iter(){
for &elem2 in v.iter(){
massive_arr.push((elem,elem2));
}
}
let mut single_massive = Vec::new();
for &tuple in massive_arr.iter(){
single_massive.push(tuple.0 + tuple.1);
}
single_massive.dedup();
let summand: usize = single_massive.iter().sum(); println!("The sum of all that junk is {:?}", summand);```
Help me baptize my depraved iterations in the pure light of functional programming.
edited: I threw up an example before as I was still figuring out the implementation that actually worked, and the question was more of a, how do I do this better question. The thing above now actually works (but is still ugly!).

Answer 1

You can possibly use itertools (I do not have a compiler at hand, but you probably get the idea):
use itertools::Itertools;
iproduct!(v.iter(), v.iter()) // construct all pairs
.map(|tuple| tuple.0+tuple.1) // sum each pair
.unique() // de-duplicate (uses a HashMap internally)
.sum() // sum up
All this is still O(n^2) which is -- as far as I see -- asymptotically optimal, because all pairs of numbers might be needed.
To avoid the obvious duplicates, you can use tuple_combinations:
v.iter()
.tuple_combinations()
.map(|(a, b)| a+b)
.unique()
.sum()

Answer 2

Improving on #phimuemue's answer, you can avoid the obvious duplicates like this:
v.iter()
.enumerate()
.flat_map (|(i, a)| v[i+1..].iter().map (move |b| a+b))
.unique() // May not be needed or what you really want, see note below
.sum()
Playground
Note however that this may not give you the answer you really want if multiple pairs of numbers have the same sum. For example, given vec![1, 2, 3, 4] as input, which do you expect:
(1+2) + (1+3) + (1+4) + (2+3) + (2+4) + (3+4) = 30
or 3 + 4 + 5 + 6 + 7 = 25 because 1+4 == 2+3 == 5 is only counted once?