Generate distinct entires for a string (dots to be used) - c++

Question

I have the following string:
char *str = "test";
I need to generate distinct entries from it using dots, e.g. the following would be generated:
test
t.est
te.st
tes.t
t.e.s.t
t.e.st
te.s.t
...
Note: cannot have a dot at the start nor at the end.
What I have currently is able to generate some of them, but not all, I tried multiple things, such as:
1. On the bit level (dot on and off for each iteration) which sounded like the most reasonable to date, but I had an obstacle.
2. Just a nested loop which would generate based on equality, e.g. (x, y, and compare x, y with i (where i would serve as the loop for generating the new string).
Current code I have:
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "test";
for (int k = 0; k < sizeof(str) - 1; ++k) {
for (int x = k; x < sizeof(str) - 1; ++x) {
for (int y = x + 1; y < sizeof(str) - 1; ++y) {
char tmp[512], *p = tmp;
for (int i = 0; i < sizeof(str); ++i) {
*p++ = str[i];
if (i == x || i == y)
*p++ = '.';
}
*p++ = '\0';
printf("%s\n", tmp);
}
}
}
return 0;
}
This gives:
t.e.st
t.es.t
t.est.
te.s.t
te.st.
tes.t.
te.s.t
te.st.
tes.t.
tes.t.
Is it best to use the bit-level thing and if so, any suggestions to it? Or is it better if I continue on the current and fix it up to work correctly (please provide solutions)?
Note, that performance isn't really needed here, this is just a one time thing (on startup) so, anything will do as long as it works.

Answer 1

The word has four letters, so there are three breaks where you could insert a dot '.'. There will be 2n-1 combinations of inserting/not inserting dots. You can encode them as binary numbers:
dec bin word
--- --- -------
0 000 test
1 001 t.est
2 010 te.st
3 011 t.e.st
4 100 tes.t
5 101 t.es.t
6 110 te.s.t
7 111 t.e.s.t
What you need to do now is to make a "mask" that changes from 0 to 2n-1-1, inclusive, and interpret this mask as a sequence of dots in a nested loop, like this:
string s = "test";
for (int mask = 0 ; mask != 1 << (s.size()-1) ; mask++) {
cout << s[0];
for (int i = 0 ; i != s.size()-1 ; i++) {
if (mask & (1<<i)) {
cout << ".";
}
cout << s[i+1];
}
cout << endl;
}
Demo.

Answer 2

Use an integer as a bitmask: for each bit, print a . if it is set. If you iterate all values from 0 to 2 ** (len-1) you will enumerate all possible positions for the dot with all possible combinations:
#include <stdio.h>
#include <string.h>
int main(void) {
char str[] = "test";
int len = strlen(str);
for (int bits = 0; bits < (1 << (len - 1)); bits++) {
putchar(str[0]);
for (int j = 1; j < len; j++) {
if (bits & (1 << (j - 1)))
putchar('.');
putchar(str[j]);
}
putchar('\n');
}
return 0;
}

Answer 3

This function should do what you expect:
void dotify(char *str) {
int nr = 1 << (strlen(str)-1);
char buf[strlen(str)*2];
while (nr--) {
int i;
char *ptr = buf;
for (i = 0; i < strlen(str); i++) {
*ptr++ = str[i];
if (nr & (1 << i))
*ptr++ = '.';
}
*ptr = '\0';
puts(buf);
}
}
The fundamental idea behind this solution is to map each dot-place to a digit of a binary number with strlen(str)-1 digits. Count this number from 0-n. Digit 0 means "don't set dot", while 1 means "set dot"