Students and Examinations solution and explanation

SELECT s.student_id, s.student_name, sub.subject_name, COUNT(e.student_id) AS attended_exams FROM Students s CROSS JOIN Subjects sub LEFT JOIN Examinations e ON s.student_id = e.student_id AND sub.subject_name = e.subject_name GROUP BY s.student_id, s.student_name, sub.subject_name ORDER BY s.student_id, sub.subject_name;

SELECT Students.student_id, Students.student_name, Subjects.subject_name, COALESCE(Exams.attended_exams, 0) AS attended_exams FROM Students CROSS JOIN Subjects LEFT JOIN (SELECT student_id, subject_name, COUNT(*) AS attended_exams FROM Examinations GROUP BY student_id, subject_name) Exams ON Students.student_id = Exams.student_id AND Subjects.subject_name = Exams.subject_name ORDER BY Students.student_id, Subjects.subject_name;

def two_sum(nums, target):
    num_map = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_map:
            return [num_map[complement], i]
        num_map[num] = i
    return []

import java.util.HashMap;

public int[] twoSum(int[] nums, int target) {
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    return new int[] {};
}

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

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> map;
    for (int i = 0; i < nums.size(); ++i) {
        int complement = target - nums[i];
        if (map.find(complement) != map.end()) {
            return {map[complement], i};
        }
        map[nums[i]] = i;
    }
    return {};
}

function twoSum(nums, target) {
    const map = new Map();
    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];
        if (map.has(complement)) {
            return [map.get(complement), i];
        }
        map.set(nums[i], i);
    }
    return [];
}

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

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    int* map = (int*)calloc(numsSize, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        int complement = target - nums[i];
        if (map[complement] > 0) {
            result[0] = map[complement] - 1;
            result[1] = i;
            *returnSize = 2;
            free(map);
            return result;
        }
        map[nums[i]] = i + 1;
    }
    free(map);
    *returnSize = 0;
    return NULL;
}

using System.Collections.Generic;

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        Dictionary<int, int> dict = new Dictionary<int, int>();
        for (int i = 0; i < nums.Length; i++) {
            int complement = target - nums[i];
            if (dict.ContainsKey(complement)) {
                return new int[] { dict[complement], i };
            }
            dict[nums[i]] = i;
        }
        return new int[] {};
    }
}

def two_sum(nums, target):
    num_indices = [(num, i) for i, num in enumerate(nums)]
    num_indices.sort()
    left, right = 0, len(nums) - 1
    while left < right:
        current_sum = num_indices[left][0] + num_indices[right][0]
        if current_sum == target:
            return [num_indices[left][1], num_indices[right][1]]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

Code not provided for Java in this approach.

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

vector<int> twoSum(vector<int>& nums, int target) {
    vector<pair<int, int>> num_indices;
    for (int i = 0; i < nums.size(); ++i)
        num_indices.push_back({nums[i], i});
    sort(num_indices.begin(), num_indices.end());
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int sum = num_indices[left].first + num_indices[right].first;
        if (sum == target) {
            return {num_indices[left].second, num_indices[right].second};
        } else if (sum < target) {
            ++left;
        } else {
            --right;
        }
    }
    return {};
}

function twoSum(nums, target) {
    const numWithIndices = nums.map((num, index) => ({ num, index }));
    numWithIndices.sort((a, b) => a.num - b.num);
    let left = 0, right = nums.length - 1;
    while(left < right) {
        const sum = numWithIndices[left].num + numWithIndices[right].num;
        if (sum === target) {
            return [numWithIndices[left].index, numWithIndices[right].index];
        } else if (sum < target) {
            left++;
        } else {
            right--;
        }
    }
    return [];
}

Code not provided for C in this approach.

Code not provided for C# in this approach.