Simplifying C++ For Loop

Question

at the moment I have the following code:

for(int i = 0; i < 4; i++){
    cout << rowNo[i] << endl;
}

for(int i = 0; i < 4; i++){
    for(int j = 0; j < 4; j++){
        cout << rowNo[i] << '.';
        cout << rowNo[j] << endl;
    }
}

for(int i = 0; i < 4; i++){
    for(int j = 0; j < 4; j++){
        for(int k = 0; k < 4; k++){
            cout << rowNo[i] << '.';
            cout << rowNo[j] << '.';
            cout << rowNo[k] << endl;
        }
    }
}

for(int i = 0; i < 4; i++){
    for(int j = 0; j < 4; j++){
        for(int k = 0; k < 4; k++){
            for(int l = 0; l < 4; l++){
                cout << rowNo[i] << '.';
                cout << rowNo[j] << '.';
                cout << rowNo[k] << '.';
                cout << rowNo[l] << endl;
            }
        }
    }
}

Where rowNo[] is an array {1,2,3,4}

And I was wondering two things:

1. Can this be simplified, so maybe put into some sort of recursive loop?
2. Following that, can this then be made for an array of size N?

Answer 1

Your looking for Cartesian_product

With

bool increment(std::vector<std::size_t>& v, std::size_t maxSize)
{
    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        ++*it;
        if (*it != maxSize) {
            return true;
        }
        *it = 0;
    }
    return false;
}

then you can do:

void print_cartesian_product(const std::vector<int>&v, int n)
{
    std::vector<std::size_t> indexes(n);

    do {
        print(v, indexes);
    } while (increment(indexes, v.size()));

}

Demo

Answer 2

First solution it comes my mind is that on every loop to put in a buffer and finally to print all the buffers. I think there are some other ingenious methods

for(int i = 0; i < 4; i++){
        put in buffer1 rowNo[i]
        for(int j = 0; j < 4; j++){
            put in buffer2 rowNo[i],rowNo[j]
            for(int k = 0; k < 4; k++){
                 put in buffer3 rowNo[i],rowNo[j],rowNo[k]
                for(int l = 0; l < 4; l++){
                    put in buffer4 rowNo[i],rowNo[j],rowNo[k],rowNo[l],endl.
                }
            }
        }
    }
     print(buffer1);
     print(buffer2);
     print(buffer3);
     print(buffer4);

Answer 3

You are actually trying to print a number encoded in base4 with digit {1, 2, 3, 4}. To achieve it, You only need to define a function to increment by one. I propose a generic solution in the term of amount of number to print and base. Like others, I use a number to mean "empty digit", and I use zero which is quite convenient.

Complete source code :

#include <iostream>
#include <vector>

bool increment_basep(std::vector<int>& number, int p)
{ 
    int i = 0; 
    while(i < number.size() && number[i] == p)
    { 
       number[i] = 1;
       ++i;
    }
    if(i >= number.size())
        return false;

    ++number[i];
    return true;
}

void print_vect(std::vector<int>& number)
{
   for(int i = number.size() -1 ; i >= 0; --i)
   {
       if(number[i] != 0)
          std::cout << number[i];
   }
   std::cout << std::endl;
}

int main() {
    int n = 4;
    int p = 4;
    std::vector<int> num4(n);
    std::fill(num4.begin(), num4.end(), 0);

    while(increment_basep(num4, p))
    {
        print_vect(num4);
    }
    return 0;
}

The increment return whether or not the computation has overflown. When we overflow we know we need to stop.

Answer 4

The following is the simplest code I came up with. There has to be a more direct way of doing this though...

It basically introduces a "ghost" index -1, corresponding to an empty place in a number. The ternary operators in the loops conditions are there to avoid duplicates.

int main()
{
    int N = 4;
    int rowNo[4] = {1, 2, 3, 4};

    for (int i = -1; i < N; i++)
        for (int j = (i > -1 ? 0 : -1); j < N; j++)
            for (int k = (j > -1 ? 0 : -1); k < N; k++)
                for (int l = (k > -1 ? 0 : -1); l < N; l++)
                {
                    if (i > -1) std::cout << rowNo[i] << '.';
                    if (j > -1) std::cout << rowNo[j] << '.';
                    if (k > -1) std::cout << rowNo[k] << '.';
                    if (l > -1) std::cout << rowNo[l];
                    std::cout << std::endl;
                }
}

It can of course be generalized to an array of arbitraty size, possibly with some code generation script.