Maximum Number of Tasks You Can Assign solution and explanation

hash_map = {}
hash_map[1] = 10
hash_map[2] = 20
print(f'Key: 1, Value: {hash_map.get(1)}')
print(f'Key: 3, Value: {hash_map.get(3, "Not Found")})'

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        hashMap.put(1, 10);
        hashMap.put(2, 20);
        System.out.println("Key: 1, Value: " + hashMap.get(1));
        System.out.println("Key: 3, Value: " + hashMap.getOrDefault(3, -1));
    }
}

#include <iostream>
#include <unordered_map>

int main() {
  std::unordered_map<int, int> hashMap;
  hashMap[1] = 10;
  hashMap[2] = 20;
  std::cout << "Key: 1, Value: " << hashMap[1] << std::endl;
  if (hashMap.find(3) != hashMap.end()) {
    std::cout << "Key: 3, Value: " << hashMap[3] << std::endl;
  } else {
    std::cout << "Key: 3, Value: Not Found" << std::endl;
  }
  return 0;
}

let hashMap = new Map();
hashMap.set(1, 10);
hashMap.set(2, 20);
console.log(`Key: 1, Value: ${hashMap.get(1)}`);
console.log(`Key: 3, Value: ${hashMap.has(3) ? hashMap.get(3) : 'Not Found'}`);

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

#define TABLE_SIZE 100

// Structure of each item in the hashmap
struct item {
  int key;
  int value;
};

// Hash function
int hashFunction(int key) {
  return key % TABLE_SIZE;
}

// Function to insert a key-value pair into the hashmap
void insert(struct item* table[], int key, int value) {
  int index = hashFunction(key);
  table[index] = malloc(sizeof(struct item));
  table[index]->key = key;
  table[index]->value = value;
}

// Function to search for a value by key
int search(struct item* table[], int key) {
  int index = hashFunction(key);
  if (table[index] != NULL && table[index]->key == key) {
    return table[index]->value;
  }
  return -1; // Indicates not found
}

int main() {
  struct item* table[TABLE_SIZE] = {NULL};
  insert(table, 1, 10);
  insert(table, 2, 20);
  printf("Key: 1, Value: %d\n", search(table, 1));
  printf("Key: 3, Value: %d\n", search(table, 3));
  return 0;
}

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Dictionary<int, int> hashMap = new Dictionary<int, int>();
        hashMap[1] = 10;
        hashMap[2] = 20;
        Console.WriteLine("Key: 1, Value: " + hashMap[1]);
        Console.WriteLine("Key: 3, Value: " + (hashMap.ContainsKey(3) ? hashMap[3].ToString() : "Not Found"));
    }
}

from sortedcontainers import SortedDict

tree_map = SortedDict()
tree_map[10] = 100
tree_map[20] = 200
print(f'Key: 10, Value: {tree_map[10]}')
del tree_map[10]
print(tree_map)

import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        treeMap.put(10, 100);
        treeMap.put(20, 200);
        System.out.println("Key: 10, Value: " + treeMap.get(10));
        treeMap.remove(10);
        System.out.println("TreeMap after removal: " + treeMap);
    }
}

#include <iostream>
#include <set>

int main() {
    std::set<int> bst;
    bst.insert(10);
    bst.insert(20);
    std::cout << "20 found: " << (bst.find(20) != bst.end()) << std::endl;
    bst.erase(10);
    return 0;
}

// JavaScript does not have a native balanced tree structure.
// This example uses sorted key access through an array workaround.

let treeMap = new Map();
treeMap.set(10, 100);
treeMap.set(20, 200);

console.log(`Key: 10, Value: ${treeMap.get(10)}`);
treeMap.delete(10);
console.log('Map after removal:', Array.from(treeMap).sort((a,b) => a[0] - b[0]));

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

struct Node {
    int key, value;
    struct Node* left, * right;
    int height;
};

int height(struct Node* node) {
    return (node == NULL) ? 0 : node->height;
}

// Auxiliary functions for AVL rebalancing (rotations)
// And typical AVL operations like inserting or balancing.
// For complete AVL implementation, resource usage exceeds the fit here.

int main() {
    // Example placeholder to demonstrate implementation.
    struct Node* root = NULL;
    // Use AVL insert & other functionalities here
    return 0;
}

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        SortedDictionary<int, int> treeMap = new SortedDictionary<int, int>();
        treeMap[10] = 100;
        treeMap[20] = 200;
        Console.WriteLine("Key: 10, Value: " + treeMap[10]);
        treeMap.Remove(10);
        Console.WriteLine("SortedDictionary after removal:");
        foreach (var kvp in treeMap) {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

function maxTaskAssign(
    tasks: number[],
    workers: number[],
    pills: number,
    strength: number,
): number {
    tasks.sort((a, b) => a - b);
    workers.sort((a, b) => a - b);

    const n = tasks.length;
    const m = workers.length;

    const check = (x: number): boolean => {
        const dq = new Array<number>(x);
        let head = 0;
        let tail = 0;
        const empty = () => head === tail;
        const pushBack = (val: number) => {
            dq[tail++] = val;
        };
        const popFront = () => {
            head++;
        };
        const popBack = () => {
            tail--;
        };
        const front = () => dq[head];

        let i = 0;
        let p = pills;

        for (let j = m - x; j < m; j++) {
            while (i < x && tasks[i] <= workers[j] + strength) {
                pushBack(tasks[i]);
                i++;
            }

            if (empty()) return false;

            if (front() <= workers[j]) {
                popFront();
            } else {
                if (p === 0) return false;
                p--;
                popBack();
            }
        }
        return true;
    };

    let [left, right] = [0, Math.min(n, m)];
    while (left < right) {
        const mid = (left + right + 1) >> 1;
        if (check(mid)) left = mid;
        else right = mid - 1;
    }
    return left;
}

func maxTaskAssign(tasks []int, workers []int, pills int, strength int) int {
	sort.Ints(tasks)
	sort.Ints(workers)
	n, m := len(tasks), len(workers)
	left, right := 0, min(m, n)
	check := func(x int) bool {
		p := pills
		q := []int{}
		i := 0
		for j := m - x; j < m; j++ {
			for i < x && tasks[i] <= workers[j]+strength {
				q = append(q, tasks[i])
				i++
			}
			if len(q) == 0 {
				return false
			}
			if q[0] <= workers[j] {
				q = q[1:]
			} else if p == 0 {
				return false
			} else {
				p--
				q = q[:len(q)-1]
			}
		}
		return true
	}
	for left < right {
		mid := (left + right + 1) >> 1
		if check(mid) {
			left = mid
		} else {
			right = mid - 1
		}
	}
	return left
}