How to calculate the intersection of two polygons?

Pointer arithmetic

• QUESTION: Hello Zlatko. Using header. If I want to compare two char arrays and display whether their elements are union & intersect. Can I make use of 'strncmp' to acheive the results? I am not sure which functions can be used to my code. [Code] using namespace std; const int MAX = 10; void isEmpty (char*); void outputChar1 (char*, int); void outputChar2 (char*, int); int main () { char x[MAX]; char* a = x; srand (time(NULL)); isEmpty (a); cout (rand () % 26 + 97); cout maxSize) size = maxSize; /* rest of code */ return size; } int main(void) { char x[MAX]; char y[MAX]; int size_x; int size_y; size_x = outputChar(x, MAX); size_y = outputChar(y, MAX); } Notice you don't actually need to assign x or y to a char*. A char array can be passed to a function accepting a char* because when the array is passed, it is actually the pointer to the start of the array that is passed. Now you need 2 more functions, one for union and one for intersect. I assume you want to determine the union and intersection of the two generated character arrays and store the results in a third array. It is good to always specify your available result space and check that you don't overflow it. int findIntersection(char* a, int size_a, char* b, int size_b, char* result, int result_space) { int intersectionSize = 0; // The actual size of the intersection /* calculate intersection */ return intersectionSize; } int findUnion(char* a, int size a, char* b, int size_b, char* result, int result_space) { int unionSize = 0; // The actual size of the union /* calculate union*/ return unionSize; } Now your main function looks like this: int main(void) { char x[MAX]; char y[MAX]; char union[MAX * 2]; char intersection[MAX]; int size_x; int size_y; size_x = outputChar(x, MAX); size_y = outputChar(y, MAX); int intersectionSize = findIntersection(x, size_x, y, size_y, intersection, MAX); int unionSize = findUnion(x, size_x, y, size_y, union, MAX * 2); } At this point you might notice that the idea of size can be confusing. Is it the amount of space in an array, or is it the amount of data stored in an array? When things become confusing, it is good to make an exact definition of what something means and stick to it. My code above does not stick to an exact definition. Sometimes I use size to show space, sometimes to show a count of data. Your code should be better. One more comment. Your outputChar functions do not put a 0 (the C string null terminator) at the end of the generated data, so I assumed that you will be keeping track of how much data is generated with a separate integer. But now I notice that you have an IsEmpty function that does look for the null terminator. First, you have to make up your mind about which method you want to use and stick to it. Also, if you are going to use a null terminator, make sure you leave space for it. Now that I've set it up for you, you can try to come up with a union or intersection algorithm. The strcmp will not work. For intersection, you need to go through each element of the first array and see if it exists in the second array AND is not already in the result. For union, you need to go through both arrays, and place their elements into result IF the element is not already there. Let me know how it goes. ---------- FOLLOW-UP ---------- QUESTION: Is this going to work? [Code for union] int findUnion (char* a, int size a, char* b, int size_b, char* result, int result_space) { int unionSize = 0; // The actual size of the union int size; char lookup[257] = {' ANSWER: Steve, you need to resend your code. You sent only a fragment with the last message. ---------- FOLLOW-UP ---------- QUESTION: This is it. [Code] int findUnion (char* a, int size a, char* b, int size_b, char* result, int result_space) { int unionSize = 0; // The actual size of the union int size; char lookup[300] = {'\0'}; // Add all of set a and b to the lookup table for(int i = 0; i // Now all we have to do is loop through the lookup table // and see which values were set. int result_space = 0; // size of result space for(int i = 0; i result = new char[result_space + 1]; (*c)[result_space] = '\0'; // loop through again to assign the result set the values for(int i = 0, j = 0; i }

• Answer:

  Steve, I really like the lookup table idea! But since the two arrays may be of different sizes, I think you need two loops, one for inserting the 'a' elements into the lookup table, and one loop for the 'b' elements. My idea was that the char* result array would be the storage space for the union. The memory that you are allocating in findUnion will not be seen by the caller unless you return the pointer. Allocating memory makes it more complicated. I suggest that for a first try, you declare a result array in main, like I showed you in my last message. That way, the union function will work in the same way as the outputChar function. Also, my idea was that result_space tells the union function how much space is available in the result array. The unionSize integer declared in the union function should hold the resulting size of the union. It is the variable that should be incremented when an item is added to the result array and it is the variable that should be returned. I don't want to frustrate you too much. Below is how I would do the program using your ideas. I'll leave the intersection function for you to do. The only idea I would change in your code is that the display function should be separate, on its own, so it can be reused. In the code below, I am not relying on a 0 byte to show the end of data in an array. Instead, I am keeping track of the size of each array. Also, I am defining size as the amount of data in an array, and space as the amount of data an array can hold. I hope this helps you. using namespace std; void displayArray(char* a, int size) { cout } int generateArray(char* a, int space) { //Get random size of 2 - maxSize int size = rand() % (space+1); if (size space) size = space; for (int i = 0; i (rand () % 26 + 97); } return size; } int findUnion (char* a, int size_a, char* b, int size_b, char* result, int resultSpace) { int unionSize = 0; // The actual size of the union char lookup[300] = {'\0'}; // Add all of set a and b to the lookup table for(int i = 0; i // Now all we have to do is loop through the lookup table // and see which values were set. for(int i = 0; i return unionSize; } int main(void) { const int MAX = 10; char x[MAX]; char y[MAX]; int size_x; int size_y; srand((unsigned int)time(NULL)); size_x = generateArray(x, MAX); cout size_y = generateArray(y, MAX); cout char unionResult[MAX * 2]; int unionSize = findUnion(x, size_x, y, size_y, unionResult, MAX * 2); cout }