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:

Input: nums1 = [1,2,3], nums2 = [2,4,6]
Output: [[1,3],[4,6]]
Explanation:
For nums1, nums1[1] = 2 is present at index 0 of nums2, whereas nums1[0] = 1 and nums1[2] = 3 are not present in nums2. Therefore, answer[0] = [1,3].
For nums2, nums2[0] = 2 is present at index 1 of nums1, whereas nums2[1] = 4 and nums2[2] = 6 are not present in nums2. Therefore, answer[1] = [4,6].

Example 2:

Input: nums1 = [1,2,3,3], nums2 = [1,1,2,2]
Output: [[3],[]]
Explanation:
For nums1, nums1[2] and nums1[3] are not present in nums2. Since nums1[2] == nums1[3], their value is only included once and answer[0] = [3].
Every integer in nums2 is present in nums1. Therefore, answer[1] = [].

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;
}