Find the Difference of Two Arrays solution and explanation

def solve_problem(arr):
    arr.sort()
    # Further problem-specific logic goes here

arr = [5, 3, 8, 4, 2]
solve_problem(arr)
print(arr)

import java.util.Arrays;

public class Solution {
    public static void solveProblem(int[] arr) {
        Arrays.sort(arr);
        // Further problem-specific logic goes here
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        solveProblem(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

#include <iostream>
#include <vector>
#include <algorithm>

void solveProblem(std::vector<int>& arr) {
    std::sort(arr.begin(), arr.end());
    // Further problem-specific logic goes here
}

int main() {
    std::vector<int> arr = {5, 3, 8, 4, 2};
    solveProblem(arr);

    for(int i : arr) {
        std::cout << i << " ";
    }
    return 0;
}

function solveProblem(arr) {
    arr.sort((a, b) => a - b);
    // Further problem-specific logic goes here
}

const arr = [5, 3, 8, 4, 2];
solveProblem(arr);
console.log(arr.join(' '));

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void solveProblem(int* arr, int size) {
    qsort(arr, size, sizeof(int), compare);
    // Further problem-specific logic goes here
}

int main() {
    int arr[] = {5, 3, 8, 4, 2};
    int size = sizeof(arr)/sizeof(arr[0]);
    solveProblem(arr, size);

    for(int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

using System;

class Solution {
    static void SolveProblem(int[] arr) {
        Array.Sort(arr);
        // Further problem-specific logic goes here
    }

    static void Main() {
        int[] arr = {5, 3, 8, 4, 2};
        SolveProblem(arr);

        Console.WriteLine(string.Join(" ", arr));
    }
}

def solve_problem(arr):
    hash_set = set()
    for num in arr:
        if num not in hash_set:
            hash_set.add(num)
            # Process this unique element

arr = [5, 3, 8, 4, 2]
solve_problem(arr)

import java.util.HashSet;

public class Solution {
    public static void solveProblem(int[] arr) {
        HashSet<Integer> set = new HashSet<>();
        for (int num : arr) {
            if (!set.contains(num)) {
                set.add(num);
                // Process this unique element
            }
        }
        // Further problem-specific logic goes here
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        solveProblem(arr);
    }
}

#include <iostream>
#include <unordered_map>
#include <vector>

void solveProblem(const std::vector<int>& arr) {
    std::unordered_map<int, bool> hashMap;
    for (int num : arr) {
        if (hashMap.find(num) == hashMap.end()) {
            hashMap[num] = true;
            // Process this unique element
        }
    }
    // Further problem-specific logic goes here
}

int main() {
    std::vector<int> arr = {5, 3, 8, 4, 2};
    solveProblem(arr);
    return 0;
}

function solveProblem(arr) {
    const map = new Map();
    for (const num of arr) {
        if (!map.has(num)) {
            map.set(num, true);
            // Process this unique element
        }
    }
    // Further problem-specific logic goes here
}

const arr = [5, 3, 8, 4, 2];
solveProblem(arr);

#include <stdio.h>
#include <stdbool.h>
#define SIZE 100

bool hashTable[SIZE] = {false};

void solveProblem(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        if (!hashTable[arr[i]]) {
            hashTable[arr[i]] = true;
            // Process this unique element
        }
    }
    // Further problem-specific logic goes here
}

int main() {
    int arr[] = {5, 3, 8, 4, 2};
    int size = sizeof(arr) / sizeof(arr[0]);
    solveProblem(arr, size);
    return 0;
}

using System;
using System.Collections.Generic;

class Solution {
    static void SolveProblem(int[] arr) {
        HashSet<int> set = new HashSet<int>();
        foreach (int num in arr) {
            if (!set.Contains(num)) {
                set.Add(num);
                // Process this unique element
            }
        }
        // Further problem-specific logic goes here
    }

    static void Main() {
        int[] arr = {5, 3, 8, 4, 2};
        SolveProblem(arr);
    }
}

function findDifference(nums1: number[], nums2: number[]): number[][] {
    const s1: Set<number> = new Set(nums1);
    const s2: Set<number> = new Set(nums2);
    nums1.forEach(num => s2.delete(num));
    nums2.forEach(num => s1.delete(num));
    return [Array.from(s1), Array.from(s2)];
}

func findDifference(nums1 []int, nums2 []int) [][]int {
	s1, s2 := make(map[int]bool), make(map[int]bool)
	for _, v := range nums1 {
		s1[v] = true
	}
	for _, v := range nums2 {
		s2[v] = true
	}
	ans := make([][]int, 2)
	for v := range s1 {
		if !s2[v] {
			ans[0] = append(ans[0], v)
		}
	}
	for v := range s2 {
		if !s1[v] {
			ans[1] = append(ans[1], v)
		}
	}
	return ans
}

use std::collections::HashSet;
impl Solution {
    pub fn find_difference(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<Vec<i32>> {
        vec![
            nums1
                .iter()
                .filter_map(|&v| if nums2.contains(&v) { None } else { Some(v) })
                .collect::<HashSet<i32>>()
                .into_iter()
                .collect(),
            nums2
                .iter()
                .filter_map(|&v| if nums1.contains(&v) { None } else { Some(v) })
                .collect::<HashSet<i32>>()
                .into_iter()
                .collect(),
        ]
    }
}

class Solution {
    /**
     * @param Integer[] $nums1
     * @param Integer[] $nums2
     * @return Integer[][]
     */
    function findDifference($nums1, $nums2) {
        $s1 = array_flip($nums1);
        $s2 = array_flip($nums2);

        $diff1 = array_diff_key($s1, $s2);
        $diff2 = array_diff_key($s2, $s1);

        return [array_keys($diff1), array_keys($diff2)];
    }
}