Recyclable and Low Fat Products solution and explanation

SELECT product_id FROM Products WHERE low_fats = 'Y' AND recyclable = 'Y';

products = [
    {'product_id': 0, 'low_fats': 'Y', 'recyclable': 'N'},
    {'product_id': 1, 'low_fats': 'Y', 'recyclable': 'Y'},
    {'product_id': 2, 'low_fats': 'N', 'recyclable': 'Y'},
    {'product_id': 3, 'low_fats': 'Y', 'recyclable': 'Y'},
    {'product_id': 4, 'low_fats': 'N', 'recyclable': 'N'}
]

result = [product['product_id'] for product in products if product['low_fats'] == 'Y' and product['recyclable'] == 'Y']
print(result)

def frequency_counter(arr):
    freq_map = {}
    for num in arr:
        if num in freq_map:
            freq_map[num] += 1
        else:
            freq_map[num] = 1
    return freq_map

arr = [1, 2, 3, 4, 2, 3, 3]
freq_map = frequency_counter(arr)
print(freq_map)

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int[] nums = {1, 2, 2, 3, 4, 3};
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
    }
}

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

int main() {
    unordered_map<int, int> map;
    int arr[] = {1, 2, 2, 3, 3, 3};
    for (int n : arr) {
        map[n]++;
    }
    for (auto& pair : map) {
        cout << "Element: " << pair.first << " Frequency: " << pair.second << endl;
    }
    return 0;
}

const arr = [1, 2, 3, 4, 4, 5, 5, 5];
const freqMap = {};

arr.forEach(num => {
    if (freqMap[num]) {
        freqMap[num] += 1;
    } else {
        freqMap[num] = 1;
    }
});

console.log(freqMap);

#include <stdio.h>
#include <stdlib.h>
#define TABLE_SIZE 1000

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

void insert(int* hashtable, int key) {
    int index = hashFunction(key);
    hashtable[index]++;
}

int main() {
    int hashtable[TABLE_SIZE] = {0};
    int keys[] = {1, 2, 2, 3, 4, 5};
    for (int i = 0; i < 6; i++) {
        insert(hashtable, keys[i]);
    }
    // Further implementation can vary depending on the specific task, e.g., check frequency
    return 0;
}

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Dictionary<int, int> dict = new Dictionary<int, int>();
        int[] nums = { 1, 2, 3, 4, 2, 2, 5 };
        foreach (int num in nums) {
            if (dict.ContainsKey(num)) {
                dict[num]++;
            } else {
                dict[num] = 1;
            }
        }
        foreach (var pair in dict) {
            Console.WriteLine($"Key: {pair.Key}, Value: {pair.Value}");
        }
    }
}

def frequency_counter(arr):
    arr.sort()
    count = 1
    for i in range(1, len(arr)):
        if arr[i] == arr[i-1]:
            count += 1
        else:
            print(f'Element: {arr[i-1]}, Frequency: {count}')
            count = 1
    print(f'Element: {arr[-1]}, Frequency: {count}')

arr = [2, 3, 1, 4, 4, 2, 1]
frequency_counter(arr)

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {4, 2, 2, 3, 3, 1, 1};
        Arrays.sort(nums);
        int current = nums[0];
        int count = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == current) {
                count++;
            } else {
                System.out.println("Element: " + current + ", Frequency: " + count);
                current = nums[i];
                count = 1;
            }
        }
        System.out.println("Element: " + current + ", Frequency: " + count);
    }
}

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

int main() {
    std::vector<int> vec = {3, 3, 2, 1, 1, 2};
    std::sort(vec.begin(), vec.end());
    int current = vec[0];
    int count = 1;
    for (std::size_t i = 1; i < vec.size(); ++i) {
        if (vec[i] == current) {
            ++count;
        } else {
            std::cout << "Element: " << current << " Frequency: " << count << std::endl;
            current = vec[i];
            count = 1;
        }
    }
    std::cout << "Element: " << current << " Frequency: " << count << std::endl;
    return 0;
}

let arr = [9, 8, 7, 9, 7, 9];
arr.sort((a, b) => a - b);
let count = 1;
for (let i = 1; i < arr.length; i++) {
    if (arr[i] === arr[i - 1]) {
        count++;
    } else {
        console.log(`Element: ${arr[i - 1]}, Frequency: ${count}`);
        count = 1;
    }
}
console.log(`Element: ${arr[arr.length - 1]}, Frequency: ${count}`);

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

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

void countFrequency(int* arr, int n) {
    qsort(arr, n, sizeof(int), compare);
    int count = 1;
    for (int i = 1; i < n; i++) {
        if (arr[i] == arr[i-1]) {
            count++;
        } else {
            printf("Element: %d, Frequency: %d\n", arr[i-1], count);
            count = 1;
        }
    }
    printf("Element: %d, Frequency: %d\n", arr[n-1], count);
}

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

using System;
using System.Linq;

class Program {
    static void Main() {
        int[] nums = { 6, 5, 4, 6, 4 }; 
        Array.Sort(nums);
        int count = 1;
        for (int i = 1; i < nums.Length; i++) {
            if (nums[i] == nums[i - 1]) {
                count++;
            } else {
                Console.WriteLine($"Element: {nums[i - 1]}, Frequency: {count}");
                count = 1;
            }
        }
        Console.WriteLine($"Element: {nums[nums.Length - 1]}, Frequency: {count}");
    }
}