在一定范围内生成一组双精度数的所有排列C ++

Question

Basically I have n doubles, each of which can have any value within a certain range (the range is different for each value). I want a C++ function that can generate all possible permutations of these n values given a certain interval i (this too, can vary for each value).

As an example, if n = 2 , i = 0.5 (for both values), min(0) = 0 , max(0) = 1 , min(1) = 0.5 , max(1) = 1.5 , where min(0) is the lower limit for the first value, max(0) is the upper limit for the first value etc., then the function should return the following:

  - [0.0, 0.5]
  - [0.0, 1.0]
  - [0.0, 1.5]
  - [0.5, 0.5]
  - [0.5, 1.0]
  - [0.5, 1.5]
  - [1.0, 0.5]
  - [1.0, 1.0]
  - [1.0, 1.5]

In my implementation so far, I have the intervals stored in a vector of size n and the ranges for each value stored in a vector of std::pair<double, double> objects, where the first value corresponds to the lower limit and the second value corresponds to the upper limit. I'm a bit stuck on what to do next though, not very good with recursion unfortunately. I just need a brief pseudo-code to get things going.

PS The order is irrelevant.

Answer 1

Since you struggle with recursion, avoid it. Take a look at the repeating patterns in your output:

The first column contains the list (0.0, 0.5, 1.0). I presume you know how to use a for loop to get these.

The second column contains repeated blocks of the list (0.5, 1.0, 1.5). Again, I presume you know how to use a for loop for this. There's one such block for each value in the first column.

You just need to think about three lists: The solutions for columns left of the column being processed, the values that the currently processed column should take, and the results you are building.

For each column, use a nested loop across the columns-left list and the this-column list, placing each combination into the building-output. When you finish one column, move the building-output to the columns-left results and start processing the next column. Continue until all columns are added.

No matter how many columns there are, you still only need three loops (one iterates across column number, one across the columns-left results, one across the this-column values). Since the loop nesting depth is fixed, recursion is not needed.