Maximize Happiness of Selected Children solution and explanation

def solve(arr):
    arr.sort()
    print(' '.join(map(str, arr)))

import java.util.Arrays;

public class Solution {
    public static void solve(int[] arr) {
        Arrays.sort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

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

void solve(std::vector<int>& arr) {
    std::sort(arr.begin(), arr.end());
    for(int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

function solve(arr) {
    arr.sort((a, b) => a - b);
    console.log(arr.join(' '));
}

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

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

void solve(int* arr, int n) {
    qsort(arr, n, sizeof(int), compare);
    // Perform operations on sorted arr
    for(int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

using System;
using System.Linq;

public class Solution {
    public static void Solve(int[] arr) {
        Array.Sort(arr);
        Console.WriteLine(string.Join(" ", arr));
    }
}

def solve(arr):
    hash_map = {}
    for num in arr:
        hash_map[num] = hash_map.get(num, 0) + 1
    for num, count in hash_map.items():
        print(f'{num} appears {count} times')

import java.util.HashMap;

public class Solution {
    public static void solve(int[] arr) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int num : arr) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        for (int key : map.keySet()) {
            System.out.println(key + " appears " + map.get(key) + " times");
        }
    }
}

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

void solve(std::vector<int>& arr) {
    std::unordered_map<int, int> hash;
    for(int num : arr) {
        hash[num]++;
    }
    for(const auto& entry : hash) {
        std::cout << entry.first << " appears " << entry.second << " times\n";
    }
}

function solve(arr) {
    const map = new Map();
    for (const num of arr) {
        map.set(num, (map.get(num) || 0) + 1);
    }
    map.forEach((count, num) => {
        console.log(`${num} appears ${count} times`);
    });
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1000

void solve(int* arr, int n) {
    int hash[MAX];
    memset(hash, 0, sizeof(hash));
    for(int i = 0; i < n; i++) {
        hash[arr[i]]++;
    }
    // Example to print all numbers and their counts
    for(int i = 0; i < MAX; i++) {
        if(hash[i] > 0) {
            printf("%d appears %d times\n", i, hash[i]);
        }
    }
}

using System;
using System.Collections.Generic;

public class Solution {
    public static void Solve(int[] arr) {
        Dictionary<int, int> map = new Dictionary<int, int>();
        foreach (int num in arr) {
            if (map.ContainsKey(num)) {
                map[num]++;
            } else {
                map[num] = 1;
            }
        }
        foreach (var key in map.Keys) {
            Console.WriteLine($"{key} appears {map[key]} times");
        }
    }
}

function maximumHappinessSum(happiness: number[], k: number): number {
    happiness.sort((a, b) => b - a);
    let ans = 0;
    for (let i = 0; i < k; ++i) {
        const x = happiness[i] - i;
        ans += Math.max(x, 0);
    }
    return ans;
}

func maximumHappinessSum(happiness []int, k int) (ans int64) {
	sort.Ints(happiness)
	for i := 0; i < k; i++ {
		x := happiness[len(happiness)-i-1] - i
		ans += int64(max(x, 0))
	}
	return
}

impl Solution {
    pub fn maximum_happiness_sum(mut happiness: Vec<i32>, k: i32) -> i64 {
        happiness.sort_unstable_by(|a, b| b.cmp(a));

        let mut ans: i64 = 0;
        for i in 0..(k as usize) {
            let x = happiness[i] as i64 - i as i64;
            if x > 0 {
                ans += x;
            }
        }
        ans
    }
}