Iterate over m^n combinations with nested loops [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 1 year ago.
Improve this question
I have an array y of dimension n, every dimension has m entries.
How do I iterate over all combinations of indices using nested for loops?
I'd like to get all possible combinations of sums like shown in this code:
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
...
for (int k = 0; k < m; ++k) {
z = x[0] + y[i]*x[1] + y[j]*x[2] + ... + y[k]*x[n];
}
}
}
If this is not possible using for loops, how else can it be achieved?

Answer 1

Here's a solution to the problem, probably not the optimal one, but illustrates the idea. Since you need to index y with as many indices at a time as there are y's, you need an array. The array's indices will be incremented each iteration, starting at the 0th index. When the 0th index reaches m, we carry over a 1, just like normal addition. When the integer at that next index reaches m, we carry over a 1 to the next index. When all of the indices went from 0 through m - 1, we know we're done. Test it in the browser if you wish.
#include <iostream>
#include <string>
#include <vector>
int main()
{
std::vector<int> y = { 1, 2, 3 };
std::vector<int> x = { 0, 1, 2, 3 };
std::vector<int> indices = { 0, 0, 0 };
int m = y.size();
int sum = 0;
int index_to_increment_next = 0;
while (index_to_increment_next < m)
{
// sum up at current indices
sum += x[0];
for (int i = 0; i < m; i++)
{
sum += x[i + 1] * y[indices[i]];
}
int j;
for (j = 0; j < m; j++)
{
if (indices[j] < m - 1)
{
// increment indices
indices[j]++;
break;
}
// when the index reaches m, reset it to 0
// and try to increment the next one
indices[j] = 0;
}
// on the last iteration, this will be equal to m
// and all of the indices will be reset back to 0
index_to_increment_next = j;
}
std::cout << sum;
}
Update
I need a separate sum for every possible combination z = x[0] + y[i]*x[1] + y[j]*x[2] + ... + y[k]*x[n] where i,j,...k are n counters and take on values from 0 to m.
Just save the individual sums on each iteration and store them in e.g. a vector. See the code.
// declare above the while
std::vector<int> sums;
// ...
int sum = x[0];
for (int i = 0; i < m; i++)
{
sum += x[i + 1] * y[indices[i]];
}
sums.push_back(sum);

Answer 2

If I understand your problem correctly, then as Daniyal Shaikh said above in a comment
You can use recursion instead. it can prove to be a better alternate
An easy implementation of n for-loops is:
(n_counter and z are globals)
int n_counter = 0; // which is the 1,2,3 of your y[i]*x[**1**]
int z = x[0]; // all possible combinations of sums at every iteration
void recursion(int n, int m){
n_counter++;
for(int i=0 ; i<m ; i++){
z += y[i]*x[n_counter];
}
if(n_counter<=n){ // go deeper n times, which is equal to n for-loops
recursion(n, m);
}
return;
}
Every time we get deeper in the recursion, n_counter will increase because we need the number that increases.
For example with number 2: ".. + y[j]*x[2] + ..".
Lastly, all you have to do is to print z.