Algorithm problem- with the picture attached

I am attaching a picture where I have shown the diagram for which I need to check the good/bad blocks. Basically, I have the information of size of each block and number of rows and column. I also know if the row has even or odd number of blocks.

I need to make a cluster of 2 blocks and check if the resultant block(with the combination of 2) is good or bad. If the 2 blocks are good, then the resultant is good block , otherwise bad.

I need to know the algorithm of it.

If the row has odd numbers of blocks, I am ignoring the middle block and considering the last blocks.

The diagram is in the shape of circle but the blocks on the circumference are ignored. So, I have to consider only the middle block as shown in the picture.

I need to iterate over each row, make a group of 2, find the result. But if the row has odd number of blocks, ignore the middle one, and make a group of last two blocks at the corner.

The shape inside the circle as shown in picture, is the real figure.

I guess, I have given enough information this time.

NOTE: In this example, I making a group of two, but I need to make a group of 2, 3 or 4 blocks in the row ,just like a generic case. If any block in the group is bad,the whole group is bad whether its a group of ,3, or 4.I need to write the code in visual basic language. The size, no. of blocks in the row shown in the picture are not the real data.It is just an example.

I have some type of solution that checks for each block and its surrounding block which is not right. But Can it be done in this way:

Here's solution:

If you are adding two, then one badBlock means both on either side are also bad leading to 3 bad on

1) Set up NxN array of struct {bool inCircle, badBlock, badGroup;} Where inCircle is true if the block is in the circle, badBlock is true if the block is a bad on开发者_Python百科 and initially badGroup is false.

int length=2;
for (int i=0; i<N;i++)
  for(int j=0; j<N;j++)
     if(array[i,j].badBlock){
       for(int x=-length;x<=length;x++)
           if(i+x>=0 and i+x<N and array[i+x,j].inCircle) then array[i+x,j].badGroup=true; 
       for(int y=-length;y<=length;y++)
           if(j+y>=0 and j+y<N and array[i,j+y].inCircle) then array[i,j+y].badGroup=true; 
}

I also the know the x and Y co-ordinate of each block.

simple recursion will do, pseudo-code:

GroupSize = 2;
bool Calc(row, start, end)
{
   if (end-start <= GroupSize -1) return true;
   if (end - start < GroupSize*2) //Single group in the middle, but smaller than 2 groups (calculate only the first group size)
   {
      bool result = true;
      for (i = start ; i < GroupSize; i++)
      {
         result = result && row[i];
      }
   } 
   else
   {
       return Calc(row, start, start + GroupSize) && Calc(row,end-GroupSize,end) && GroupSize(row, start + GroupSize,end-GroupSize);

   }
}

Something like that.
The idea is to recursively calculate both sides of the row and then send the middle for some more calculating.

Recursion might be simplest way (or not for everyone), bu any recursion can be turned into a loop.