How to insert zeros every x bits - c

Question

I represent a square of 1s and 0s with an integer type variable. Here's what it might look like:
1 1 1 0
0 1 0 0
0 0 0 0
0 0 0 0
The corresponding integer is coded from the bottom right corner to the top left, and the top left corner corresponds to 2^0. An integer representation of this grid is: 0000 0000 0010 0111 (2) = 39(10)
The grid is always a square with known width. In my code, I need to increment the width by 1 a lot of times, thus changing the map to:
1 1 1 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Which is equivalent to inserting a 0 every x = width bits (width = 4 in the example). Overflows can't happen because the size of the integer is much larger than required.
In C, how can I insert a zero every x bits?
Edit1: since this operation will be happening a lot of times on numerous grids, loops are to be avoided.
Edit2: the reason I use this packing is because I do bitwise operations between grids to search for combinations.

Answer 1

Look at the problem in the way you would look as adding 0 to every forth position in decimal number. What you would do in decimal is:
1 513 650 -> 105 130 650
You can see, that your are just preserving the numbers less than 10^3 and multiplying the rest by 10. Than preserving the number less than 10^7 (not 10^6, because you already multiplied) and multypling the right side by 10....
It works same way for binary.
#include <iostream>
#include <cmath>
int power(int x, int n){
return n == 1 ? x : x*power(x,n-1);
}
int main(int argc, char const *argv[])
{
int n = 4;
int grid = 1024;
int grid_len = std::floor(std::log2(grid)) ; // what is the position of last 1, = how long i need to insert 0
for (int steps = 0; steps*n < grid_len; ++steps)
{
std::cout << steps << std::endl;
int preserve = grid % power(2,n*(steps+1) );
grid = (grid - preserve) * 2;
grid += preserve;
}
std::cout << grid << std::endl;
return 0;
}
The code prints 71, which in binary is 1000111, so it works on example you provided.