LeetCode //C - 2215. Find the Difference of Two Arrays

2215. Find the Difference of Two Arrays

Given two 0-indexed integer arrays nums1 and nums2, return a list answer of size 2 where:

• answer[0] is a list of all distinct integers in nums1 which are not present in nums2.
• answer[1] is a list of all distinct integers in nums2 which are not present in nums1.

Note that the integers in the lists may be returned in any order.
 

Example 1:

Example 2:

Constraints:

• 1 <= nums1.length, nums2.length <= 1000
• -1000 <= nums1[i], nums2[i] <= 1000

From: LeetCode
Link: 2215. Find the Difference of Two Arrays

Solution:

Ideas：

1. Create two dynamic arrays (using malloc) to store the unique elements from nums1 and nums2 that are not found in the other.
2. Use a helper function or a simple loop to check if an element in one array is present in the other.
3. Add the unique elements to the respective dynamic arrays.
4. Return the dynamic arrays along with their sizes.

Code:

bool isPresent(int* array, int size, int value) {
    for (int i = 0; i < size; ++i) {
        if (array[i] == value) {
            return true;
        }
    }
    return false;
}

int** findDifference(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize, int** returnColumnSizes) {
    int* result1 = (int*)malloc(nums1Size * sizeof(int));
    int result1Size = 0;
    int* result2 = (int*)malloc(nums2Size * sizeof(int));
    int result2Size = 0;

    // Find unique elements in nums1
    for (int i = 0; i < nums1Size; ++i) {
        if (!isPresent(nums2, nums2Size, nums1[i]) && !isPresent(result1, result1Size, nums1[i])) {
            result1[result1Size++] = nums1[i];
        }
    }

    // Find unique elements in nums2
    for (int i = 0; i < nums2Size; ++i) {
        if (!isPresent(nums1, nums1Size, nums2[i]) && !isPresent(result2, result2Size, nums2[i])) {
            result2[result2Size++] = nums2[i];
        }
    }

    // Prepare the return values
    *returnSize = 2;
    *returnColumnSizes = (int*)malloc(*returnSize * sizeof(int));
    (*returnColumnSizes)[0] = result1Size;
    (*returnColumnSizes)[1] = result2Size;

    int** result = (int**)malloc(*returnSize * sizeof(int*));
    result[0] = result1;
    result[1] = result2;

    return result;
}