Number of Distinct Averages solution and explanation

hash_map = {}

# Insert key-value pairs
hash_map[1] = 100
hash_map[2] = 200

# Search for keys
print(f"Value for key 1: {hash_map.get(1, -1)}")
print(f"Value for key 2: {hash_map.get(2, -1)}")

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, Integer> map = new HashMap<>();
        
        // Insert key-value pairs
        map.put(1, 100);
        map.put(2, 200);
        
        // Search for keys
        System.out.println("Value for key 1: " + map.getOrDefault(1, -1));
        System.out.println("Value for key 2: " + map.getOrDefault(2, -1));
    }
}

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    // Create an unordered_map
    unordered_map<int, int> map;
    
    // Insert key-value pairs
    map[1] = 100;
    map[2] = 200;
    
    // Search for keys
    cout << "Value for key 1: " << map[1] << endl;
    cout << "Value for key 2: " << (map.count(2) ? map[2] : -1) << endl;
    
    return 0;
}

const map = new Map();

// Insert key-value pairs
map.set(1, 100);
map.set(2, 200);

// Search for keys
console.log(`Value for key 1: ${map.get(1) ?? -1}`);
console.log(`Value for key 2: ${map.get(2) ?? -1}`);

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

#define TABLE_SIZE 1000

// Define a structure for the hash table entries.
typedef struct entry {
    int key;
    int value;
    struct entry *next;
} Entry;

Entry *hashTable[TABLE_SIZE];

unsigned int hashFunction(int key) {
    return key % TABLE_SIZE;
}

void insert(int key, int value) {
    unsigned int index = hashFunction(key);
    Entry *newEntry = (Entry *)malloc(sizeof(Entry));
    newEntry->key = key;
    newEntry->value = value;
    newEntry->next = hashTable[index];
    hashTable[index] = newEntry;
}

int search(int key) {
    unsigned int index = hashFunction(key);
    Entry *entry = hashTable[index];
    while (entry != NULL) {
        if (entry->key == key) {
            return entry->value;
        }
        entry = entry->next;
    }
    return -1;  // Key not found
}

int main() {
    // Initialize hash table
    for (int i = 0; i < TABLE_SIZE; i++) {
        hashTable[i] = NULL;
    }

    // Example usage
    insert(1, 100);
    insert(2, 200);
    printf("Value for key 1: %d\n", search(1));
    printf("Value for key 2: %d\n", search(2));

    return 0;
}

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Dictionary<int, int> dict = new Dictionary<int, int>();

        // Insert key-value pairs
        dict[1] = 100;
        dict[2] = 200;

        // Search for keys
        Console.WriteLine("Value for key 1: " + (dict.TryGetValue(1, out int value1) ? value1 : -1));
        Console.WriteLine("Value for key 2: " + (dict.TryGetValue(2, out int value2) ? value2 : -1));
    }
}

import bisect

arr = [3, 2, 1, 5, 4]
arr.sort()

# Use bisect for binary search
x = 3
index = bisect.bisect_left(arr, x)
if index < len(arr) and arr[index] == x:
    print(f"Element found at index {index}")
else:
    print("Element not found")

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {3, 2, 1, 5, 4};
        // Sort the array
        Arrays.sort(arr);

        // Use binary search
        int x = 3;
        int result = Arrays.binarySearch(arr, x);
        if (result >= 0)
            System.out.println("Element found at index " + result);
        else
            System.out.println("Element not found");
    }
}

#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    int arr[] = {3, 2, 1, 5, 4};
    int n = sizeof(arr) / sizeof(arr[0]);

    // Sort the array
    sort(arr, arr + n);

    // Use binary search
    int x = 3;
    if (binary_search(arr, arr + n, x))
        cout << "Element found." << endl;
    else
        cout << "Element not found." << endl;
    return 0;
}

const arr = [3, 2, 1, 5, 4];
arr.sort((a, b) => a - b);

const binarySearch = (arr, x) => {
    let start = 0, end = arr.length - 1;

    while (start <= end) {
        let mid = Math.floor((start + end) / 2);

        if (arr[mid] === x) return mid;
        else if (arr[mid] < x) start = mid + 1;
        else end = mid - 1;
    }
    return -1;
};

const x = 3;
const index = binarySearch(arr, x);
console.log(index !== -1 ? `Element found at index ${index}` : "Element not found");

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

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

int binarySearch(int arr[], int size, int x) {
    int l = 0, r = size - 1;
    while (l <= r) {
        int mid = l + (r - l) / 2;
        if (arr[mid] == x)
            return mid;
        if (arr[mid] < x)
            l = mid + 1;
        else
            r = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {3, 2, 1, 5, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, n, sizeof(int), compare);

    int x = 3;
    int result = binarySearch(arr, n, x);
    if (result != -1) printf("Element found at index %d\n", result);
    else printf("Element not found\n");
    return 0;
}

using System;

class Program {
    static void Main() {
        int[] arr = {3, 2, 1, 5, 4};
        Array.Sort(arr);

        int x = 3;
        int index = Array.BinarySearch(arr, x);
        if (index >= 0)
            Console.WriteLine($"Element found at index {index}");
        else
            Console.WriteLine("Element not found");
    }
}

function distinctAverages(nums: number[]): number {
    nums.sort((a, b) => a - b);
    const s: Set<number> = new Set();
    const n = nums.length;
    for (let i = 0; i < n >> 1; ++i) {
        s.add(nums[i] + nums[n - i - 1]);
    }
    return s.size;
}

func distinctAverages(nums []int) (ans int) {
	sort.Ints(nums)
	n := len(nums)
	s := map[int]struct{}{}
	for i := 0; i < n>>1; i++ {
		s[nums[i]+nums[n-i-1]] = struct{}{}
	}
	return len(s)
}

impl Solution {
    pub fn distinct_averages(nums: Vec<i32>) -> i32 {
        let mut nums = nums;
        nums.sort();
        let n = nums.len();
        let mut cnt = vec![0; 201];
        let mut ans = 0;

        for i in 0..n >> 1 {
            let x = (nums[i] + nums[n - i - 1]) as usize;
            cnt[x] += 1;

            if cnt[x] == 1 {
                ans += 1;
            }
        }

        ans
    }
}

function distinctAverages(nums: number[]): number {
    nums.sort((a, b) => a - b);
    const cnt: number[] = Array(201).fill(0);
    let ans = 0;
    const n = nums.length;
    for (let i = 0; i < n >> 1; ++i) {
        if (++cnt[nums[i] + nums[n - i - 1]] === 1) {
            ++ans;
        }
    }
    return ans;
}

func distinctAverages(nums []int) (ans int) {
	sort.Ints(nums)
	n := len(nums)
	cnt := [201]int{}
	for i := 0; i < n>>1; i++ {
		x := nums[i] + nums[n-i-1]
		cnt[x]++
		if cnt[x] == 1 {
			ans++
		}
	}
	return
}

use std::collections::HashMap;

impl Solution {
    pub fn distinct_averages(nums: Vec<i32>) -> i32 {
        let mut h = HashMap::new();
        let mut nums = nums;
        let mut ans = 0;
        let n = nums.len();
        nums.sort();

        for i in 0..n >> 1 {
            let x = nums[i] + nums[n - i - 1];
            *h.entry(x).or_insert(0) += 1;

            if *h.get(&x).unwrap() == 1 {
                ans += 1;
            }
        }

        ans
    }
}