unpredictable number of nested loops - c++

Question

I'm trying to make a program that requires nested loops to work properly.
But the number of nested loops depend on the number of character the user inputs also the character to output.
This is my code so far.
#include<iostream>
using namespace std;
int main(){
string str;
cout<<"Enter some string: ";
cin>>str;
// for two characters
for(int i = 0; i < 2; i++){
for(int j = 0; j < 2 ; j++){
cout<<str[i]<<str[j]<<endl;
}
};
// for four characters
for(int i = 0; i<4; i++){
for(int j=0;j<4;j++){
for(int k =0;k<4;k++){
for(int z=0;z<4;z++)
cout<<str[i]<<str[j]<<str[k]<<str[z]<<endl;
}
}
}
return 0;
}
So, is there any way to solve this issue.

Answer 1

You need to do it dynamically:
std::vector<unsigned int> offsets(s.size());
bool isContinue;
do
{
for(auto offset : offsets)
{
std::cout << s[offset];
}
std::cout << std::endl;
isContinue = false;
for(auto offset = offsets.rbegin(); offset != offsets.rend(); ++offset)
{
if(++*offset < s.size())
{
isContinue = true;
break;
}
*offset = 0;
}
}
while(isContinue);
The idea behind is like upcounting numbers (decimally): Once you've reached 9, you increment next digit. Alike, each offset in the vector stands for one loop variable, on 'overflow', increment next offset, and as soon as most significant offset 'overflows', we are done.
High performance variant (using goto, sparing one comparison and the condition variable):
std::vector<unsigned int> offsets(s.size());
NEXT:
for(auto offset : offsets)
{
std::cout << s[offset];
}
std::cout << std::endl;
for(auto offset = offsets.rbegin(); offset != offsets.rend(); ++offset)
{
if(++*offset < s.size())
goto NEXT;
*offset = 0;
}

Answer 2

There are a couple basic ways to do that looping.
The first is the explicit one: you need to use an array of indexes instead of a single variable for the loop index. Then at each step you increment the last index and when that gets past the limit you reset it and increment the previous one:
int n = str.size(); // Get rid of unsigned
std::vector<int> index(n);
for(;;) {
// Generate output
for (int i=0; i<n; i++) {
std::cout << str[index[i]];
}
std::cout << std::endl;
// Increment
int i = n-1; // start from last index
while (i>=0 && index[i] == n-1) {
// I-th index has reached the end of the string, flip over to 0
index[i] = 0;
--i;
}
if (i == -1) break; // all of them returned to 0... that's all, folks
index[i] += 1;
}
The second way is using recursion, for example with a function accepting the partial string being built as argument and that if this prefix is not complete loops over the string and calls itself passing an extended prefix:
std::function<void(const std::string&)> proc = [&](const std::string& prefix) {
if (prefix.size() == str.size()) {
// Prefix is complete, just output result
std::cout << prefix << std::endl;
} else {
// Extend the prefix and call yourself for the nested loops
for (int j=0; j<n; j++) {
proc(prefix + str[j]);
}
}
};
proc("");
The recursive approach is more compact but takes some time to become comfortable and it can be problematic in certain cases.
A different way avoiding nested loops be to use simple counting and math... it's easy to write a function that returns the n-th string you're looking for without looping over the previous ones...
for (int i=0,loops=pow(n, n); i<loops; i++){
std::string s = "";
int k = i;
for (int j=0; j<n; j++) {
s = str[k % n] + s;
k /= n;
}
std::cout << s << std::endl;
}

Answer 3

Let's fold all your N nested loops into one nested loop. First, we need N indices, which will be incremented properly:
class Multiindex
{
public:
Multiindex(int size, int last_) : idx(size,0), last(last_) {}
void inc()
{
for (int i = idx.size() - 1; i >= 0; --i) {
if (idx[i] == last - 1) {
idx[i] = 0;
if (i == 0) complete = true;
}
else {
++idx[i];
break;
}
}
}
const auto& getIdx() const { return idx; }
const auto isComplete() const { return complete; }
private:
std::vector<int> idx;
int last;
bool complete = false;
};
It's a minimal example of a multiindex class. You also may write a decrement method or use a vector of last indices, if you need different indices in your nested loop.
Now everything is ready to replace your nested loop:
std::string s;// From user
Multiindex midx(s.length(), s.length());
while (!midx.isComplete()) { // Your nested loop
const auto& idx = midx.getIdx();
for (int i = 0; i < idx.size(); ++i) { // Replacement for cout << s[i] << s[j] << ... << s[z] << endl;
std::cout << s[idx[i]];
}
std::cout << std::endl;
midx.inc();
}