Thread: Function for my grid array

I'm writing a function that will take as arguments only two integer indices i, j , and will return the number of nonzero entries of the array grid that are adjacent to the ith, jth element of the array.
I have gotten to this point with my code. Can someone give me a pointer on how to continue with the function? I'm assuming I'll be using if statements but I'm not sure how.

Code:

#include<stdio.h>
#define SIZE 7
int grid[SIZE][SIZE];

int neighbors (int i,int j);
void main ()
{
  int i, j, n;
  /* initializing the entire grid to be zero */
  for(i =0; i < SIZE; i++)
  for(j =0; j < SIZE; j++)
  grid[i][j]=0;

  grid[1][2]=1;
  grid[2][2]=1;
  grid[1][4]=1;
  grid[2][4]=1;
  grid[3][2]=1;
  grid[3][3]=1;
  grid[3][4]=1;
  grid[5][3]=1;
  grid[6][2]=1;

  for(i =0; i < SIZE; i++)
  for(j =0; j < SIZE; j++){

  n = neighbors(i,j);
  printf ("Number of neighbors to element %d,%d = %d\n",i,j,n);
  }

  return;
  }

  /* function to compute an element's neighbors */
  int neighbors (int i,int j)
  {

How would I go on to putting that in my code? Do you recommend doing an if statement with [i -1][j]?

Thanks for your help

In English language it is called orthogonal.

https://en.wikipedia.org/wiki/Orthogonality

Code:

#include <stdio.h>
#include <stdint.h>

#define SIZE 7
int grid[SIZE][SIZE];

int neighbors (int i,int j);

int main()
{
  int i, j, n;
  /* initializing the entire grid to be zero */
  for(i =0; i < SIZE; i++)
  for(j =0; j < SIZE; j++)
  grid[i][j]=0;

  grid[1][2]=1;
  grid[2][2]=1;
  grid[1][4]=1;
  grid[2][4]=1;
  grid[3][2]=1;
  grid[3][3]=1;
  grid[3][4]=1;
  grid[5][3]=1;
  grid[6][2]=1;

  for(i =0; i < SIZE; i++)
  {
      for(j =0; j < SIZE; j++)
      {

      n = neighbors(i,j);
      printf ("Number of neighbors to element %d,%d = %d\n",i,j,n);
      }
  }

  return 0;
}



/* function to compute an element's neighbors */
int neighbors (int i,int j)
{
int total=0;

if(((i-1)>=0) && ((i-1)<=SIZE))
{
    if((grid[i-1][j]!=0))
    {
        total++;
    }
}



if(((i+1)>=0) && ((i+1)<=SIZE))
{
    if((grid[i+1][j]!=0))
    {
        total++;
    }
}


if(((j-1)>=0) && ((j-1)<=SIZE))
{
    if((grid[i][j-1]!=0))
    {
        total++;
    }
}



if(((j+1)>=0) && ((j+1)<=SIZE))
{
    if((grid[i][j+1]!=0))
    {
        total++;
    }
}

return total;
}

Originally Posted by nerio

In English language it is called orthogonal.

In England maybe.

In Virginia it is orthagonal

I should have mentioned something about this code:

Code:

if( (i-1) >= 0 && grid[i-1][j])    // test if top neighbor is within grid AND neighbor is nonzero
    total = total + 1;

One should not reference an element outside the array bounds. So one would not want to ever evaluate grid[i-1][j] if i were zero. In that case grid[-1][j] would refer to a value at an invalid address.

This is not a problem in the code just above due to what is called "short circuit evaluation". Once the truth or falsehood of an expression is determined, the remainder of the sub-expressions will not be evaluated. This guarantees that grid[i-1][j] will only be evaluated if i-1 is >= 0.

The order of the two sub-expressions is important though. This would cause problems:

Code:

if( grid[i-1][j] && (i-1) >= 0 )    
    total = total + 1;

-

Another possibility:

Code:

int neighbors(int i, int j) {
    int cnt = 0;
    if (i > 0)      cnt += grid[i-1][j];
    if (i < SIZE-1) cnt += grid[i+1][j];
    if (j > 0)      cnt += grid[i][j-1];
    if (j < SIZE-1) cnt += grid[i][j+1];
    return cnt;
}