function missingNumbers(arr: number[], brr: number[]): number[] {
    arr.forEach((a) => {
        const index = brr.indexOf(a);
        if(index > -1){
            brr.splice(index, 1)
        }
    })
    const isUnique = Array.from(new Set(brr));
    
    return isUnique.sort((a, b) => a-b);
}

vector<int> missingNumbers(vector<int> arr, vector<int> brr) {
    map<int, int> mp;
    for(int i = 0; i < brr.size(); i++) mp[brr[i]]++;
    for(int i = 0; i < arr.size(); i++) mp[arr[i]]--;
    map<int, int>::iterator it;
    vector<int> result;
    for(it = mp.begin(); it != mp.end(); it++)
        if(it->second > 0) result.push_back(it->first);
    
    return result;
}

public static List<Integer> missingNumbers(List<Integer> arr, List<Integer> brr) {
        //goal: determine which elements in brr are missing or underrepresented in arr
        
        //use a freq map for each val in brr and arr
        Map<Integer, Integer> brrFreqMap = 
            brr.stream()
            .collect(Collectors.
            groupingBy(Function.identity(), Collectors.collectingAndThen(Collectors.counting(), Long::intValue)));
        Map<Integer, Integer> arrFreqMap = 
            arr.stream()
            .collect(Collectors.
            groupingBy(Function.identity(), Collectors.collectingAndThen(Collectors.counting(), Long::intValue)));
        
        //iterate over each key in arr and check if its in brr
        Set<Integer> missingNumbersSet = new HashSet<>();
        for (Map.Entry<Integer, Integer> entry : brrFreqMap.entrySet()) {
            int key = entry.getKey();
            int freqInBrr = entry.getValue();
            int freqInArr = arrFreqMap.getOrDefault(key, 0); // avoids null issues

            if (freqInArr < freqInBrr) {
                missingNumbersSet.add(key);
            }
        }

        // Step 3: Convert to list and sort
        List<Integer> missingNumbers = new ArrayList<>(missingNumbersSet);
        Collections.sort(missingNumbers);
        return missingNumbers;
    }

int find_min(int* arr, int arr_count){
    int min_num = arr[0];
    for (int i=1; i<arr_count; i++){
        if(arr[i] < min_num){
            min_num = arr[i];
        }
    }
    return min_num;
}

int* append(int* arr, int* size, int number){
    int new_size = *size+1;
    arr = (int* )realloc(arr, new_size*sizeof(int));
    arr[*size] = number;
    *size = new_size;
    return arr;
}

int* missingNumbers(int arr_count, int* arr, int brr_count, int* brr, int* result_count) {
    // Initialize NULL pointer
    int* res_arr = NULL;
    *result_count = 0;
    
    // find brr minimum element
    int brr_min = find_min(brr, brr_count);
    // initialize the array with zeros
    int* brr_freq = (int* )calloc(100, sizeof(int));
    
    for (int i = 0; i<brr_count; i++){
        brr_freq[brr[i]-brr_min] ++;
    }    
    for (int i = 0; i< arr_count; i++){
        brr_freq[arr[i]-brr_min] --;
    }
    for (int i = 0; i<100; i++){
        if (brr_freq[i] != 0){
            res_arr = append(res_arr, result_count, (i+brr_min));
        }
    }
    return res_arr;
}

fn missingNumbers(arr: &[i32], brr: &[i32]) -> Vec<i32> {
    let mut count_arr: HashMap<i32,i32> = HashMap::new();
    let mut count_brr: HashMap<i32,i32> = HashMap::new();
    let mut result: Vec<i32> = Vec::new();

    for num in arr {
        count_arr.entry(*num).and_modify(|c| *c+=1).or_insert(1);
    }
    for num in brr {
        count_brr.entry(*num).and_modify(|c| *c+=1).or_insert(1);
    }
    for (num, _) in &count_brr {
        if count_brr.get(&num).unwrap_or(&0) > count_arr.get(&num).unwrap_or(&0) {
            result.push(*num);
        }
    }
    result.sort();
    result
}