Question

I need to find the duplicate elements in a two dimensional array.

route_ptr->route[0][1] = 24;
route_ptr->route[0][2] = 18;
route_ptr->route[1][1] = 25;
route_ptr->route[2][1] = 18;
route_ptr->route[3][1] = 26;
route_ptr->route[3][2] = 19;
route_ptr->route[4][1] = 25;
route_ptr->route[4][2] = 84;

Those are my data; the duplicate entries of route[2][1] (duplicate of route[0][2]) and route[4][1] (duplicate of route[1][1]) has to be found.

The solution is the duplicate ‘i’ value of route[i][j] which is 2 & 4 from this example.

please guide me.

#include <stdio.h>

struct route{
    int route[6][6];
    int no_routes_found;
    int count_each_route[6];
};

int main() {
    struct route *route_ptr, route_store;  
    route_ptr=&route_store;

    int i,j,k;

    // the data
    route_ptr->route[0][1] = 24;
    route_ptr->route[0][2] = 18;
    route_ptr->route[1][1] = 25;
    route_ptr->route[2][1] = 18;
    route_ptr->route[3][1] = 26;
    route_ptr->route[3][2] = 19;
    route_ptr->route[4][1] = 25;
    route_ptr->route[4][2] = 84;
    route_ptr->count_each_route[0]=3;
    route_ptr->count_each_route[1]=2;
    route_ptr->count_each_route[2]=2;
    route_ptr->count_each_route[3]=3;
    route_ptr->count_each_route[4]=3;
    route_ptr->no_routes_found=5;

    ////  process
    for (i = 0; i <(route_ptr->no_routes_found) ; i++)
    {
        for (j = 1; j < route_ptr->count_each_route[i]; j++)
        {
            printf("\nroute[%d][%d] = ", i, j);
            printf("%d",route_ptr->route[i][j]);
        }
    }
}

The solution expected is:

route[0][1] is compared by route [0][2] i.e [24 !=18]
route[0][1] and route [0][2] is compared by route[1][1] i.e [24 && 18 !=25]
route[0][1] and route[0][2] and route[1][1] is compared by route[2][1] i.e [ 24&&18&&25 is compared by 18, there is a matching element,
   save the newcomer 'i' value which matches to the existence and drop it for next checking]
   break the 'i' loop
route[0][1], route[0][2], route[1][1] is now compared route[3][1]
route[0][1], route[0][2], route[1][1] ,[3][1] is now compared route[3][2]
route[0][1], route[0][2], route[1][1] ,[3][1] ,[3][2] is now compared to route [4][1] i.e [ now there is a match to route[1][1], so save the newcomer 'i' value and  break the 'i' loop

So i values [2 and 4] are duplicate, and that is my expected result of my code.

Answer 1

Got something against index zero, zero?

I also don’t see the point of the pointer shenanigans.

It’s a general safety thing to initialize all your data. You know, to zero or something.

The algorithm you suggest in your solution is rather hard to be faithful to, but this will find your duplicates. You have to walk through the entire array, in both dimensions, twice.

This will also match all the zeroes in your data, so you could add an exception to ignore routes values of zero.

//Cycling through the array the first time.
for (i = 0; i < 6 ; i++)
{
    for (j = 0; j < 6; j++)
    {
        //Cycling through the array the second time
        for (x = 0; x < 6 ; x++)
        {
            for (y = 0; y < 6; y++)
            {
               if(i==x && j==y)
                   continue;
               if(routestore.route[i][j] == routestore.route[x][y])
                   printf("You have a match [%d][%d] =  [%d][%d]", i, j, x,y);
            }
        }
    }
}

Ok, so if you only want to see matches once, ie [0][2] == [2][1] but not [2][1] == [0][2], then you can do something like what I have below. This one made me scratch my head. Usually, when it’s a simple list of items, you initialize the inner loop to the value of the outer loop, plus one. But you can’t quite do that when it’s a 2D array. So I gave up and made a super-lame hack-job. I’m a big fan of brute forcing things when possible. I’d normally tell you not to use pointers like this.

Now… this will still have multiple hits if you have three similar values. If that irks you then you need to start building a list and comparing hits against that as you walk through the data.

#include <stdio.h>
#include <string.h>

struct route{
    int route[6][6];
    int no_routes_found;
    int count_each_route[6];
};

int lameAddOneAlternative(int *i, int *j)
{
  if((*j)<6)
  {
    (*j)++;
    return 1;
  }
  else if (*i<6)
  {
    (*i)++;
    (*j) = 0;
    return 1;
  }  
  return 0;
}

int main(int argc, char **argv)
{
  struct route routeStore;  
  int i,j,x,y;

  memset(routeStore.route,0,sizeof(int)*36);

  // the data
  routeStore.route[0][1] = 24;
  routeStore.route[0][2] = 18;
  routeStore.route[1][1] = 25;
  routeStore.route[2][1] = 18;
  routeStore.route[3][1] = 26;
  routeStore.route[3][2] = 19;
  routeStore.route[4][1] = 25;
  routeStore.route[4][2] = 84;

  //Cycling through the array the first time.
  for (i = 0; i < 6 ; i++)
  {
    for (j = 0; j < 6; j++)
    {
      x=i;
      y=j;
      //Cycling through the array the second time
      while(lameAddOneAlternative(&x,&y))
      {
        if(routeStore.route[i][j] == 0 )
          continue;
        if(routeStore.route[i][j] == routeStore.route[x][y])
          printf("You have a match [%d][%d], [%d][%d] == %d\n", i, j, x,y, routeStore.route[i][j] );

      }
    }
  }
}