Thanks!

Boilerplate is great :), makes you make sure code works. Hints: Input does not fit memory, there are requests for too hight frequencies.

Same! The new boilerplate fixed 9, 11 but 10, 12, 13 still failing. I even tried taking OP's suggestion a step further and changed the boilerplate to int[q][2] (instead of just List<int[2]>) and still times out. Bummer.

Hashmap.containsValue is O(n) time complexity - more expensive than needed. In my solution, I use both a counter Hashmap to know how many times a specific number appears and a frequency Hashmap to count how many numbers appeared for a specific amount of times. Then, for op==3 I just check if frequency is greater than zero.

All tests passed after changing the boilerplate.

This solution works

static List<Integer> freqQuery(List<int[]> queries) {
    final Map<Integer, Integer> valueToFreq = new HashMap<>();
    final Map<Integer, Integer> freqToOccurrence = new HashMap<>();
    final List<Integer> frequencies = new ArrayList<>();

    int key;
    int value;
    Integer oldFreq;
    Integer newFreq;
    Integer oldOccurrence;
    Integer newOccurrence;
    for (int[] query : queries) {
        key = query[0];
        value = query[1];
        if (key == 3) {
            if (value == 0) {
                frequencies.add(1);
            }
            frequencies.add(freqToOccurrence.get(value) == null ? 0 : 1);
        } else {
            oldFreq = valueToFreq.get(value);
            oldFreq = oldFreq == null ? 0 : oldFreq;
            oldOccurrence = freqToOccurrence.get(oldFreq);
            oldOccurrence = oldOccurrence == null ? 0 : oldOccurrence;

            if (key == 1) {
                newFreq = oldFreq + 1;
            } else {
                newFreq = oldFreq - 1;
            }
            newOccurrence = freqToOccurrence.get(newFreq);
            newOccurrence = newOccurrence == null ? 0 : newOccurrence;

            if (newFreq < 1) {
                valueToFreq.remove(value);
            } else {
                valueToFreq.put(value, newFreq);
            }

            if ((oldOccurrence - 1) < 1) {
                freqToOccurrence.remove(oldFreq);
            } else {
                freqToOccurrence.put(oldFreq, oldOccurrence - 1);
            }
            freqToOccurrence.put(newFreq, newOccurrence + 1);
        }
    }
    return frequencies;
}

Interesting. Do you know why defaultdict is faster. From what I understand, defaultdict is very similar to Counter except that if we call a missing key, the defaultdict will include that key in its key set while Counter does not, which means defaultdict cost more operations and thus cost more time? (I'm a total newbie to computer science so excuse me for my naive question

Thank you My first time sharing a solution (as well as earning compliments from it)

I have only put 1 condition in second case for if map[x] > 0 then execute the code.

let result = [];
let freq = [];
let map = {};

for (let i = 0; i < queries.length; i++) {
    const [op, x] = queries[i];
    const f = map[x] || 0;

    if (op === 1) {
        map[x] = f + 1;
        freq[f] = (freq[f] || 0) - 1;
        freq[f + 1] = (freq[f + 1] || 0) + 1;
    }
    if (op === 2) {
        if (map[x] > 0) { 
            map[x] = f - 1;
            freq[f - 1] += 1;
            freq[f] -= 1;
        }
    }
    if (op === 3) {
        result.push(freq[x] > 0 ? 1 : 0);
    }
}
return result;

Learned something that I never used before: javascript engine can increase the size of an array with previous value intialized to undefined. Also the speed of accessing an array element using index, is way faster than the properties of an object. Thank you, ivanduka!

My solution is slightly more verbose but does more or less the same thing but also doesn't pass 7 - 13.

// Complete the freqQuery function below.
function freqQuery(queries) {
    let hashMap = {};
    let freqMap = [];
    let results = [];

    for(let q in queries) {
        let action = queries[q][0];
        let actionValue = queries[q][1];
        let oldValue = hashMap[actionValue] || 0

        if(action === 1) {
            hashMap[actionValue] = oldValue + 1;
            setFreqMapValue(oldValue, hashMap[actionValue], freqMap);
        } else if(action === 2) {
            hashMap[actionValue] = oldValue - 1
            setFreqMapValue(oldValue, hashMap[actionValue], freqMap);
        } else if (action === 3) {
            results.push(freqMap[actionValue] > 0 ? 1 : 0);
        }
    }

    return results;

}

function setFreqMapValue(oldValue, newValue, freqMap) {
    let oldFreq = freqMap[oldValue] || 0;
    let newFreq = freqMap[newValue] || 0;
    if(oldFreq > 0) {
        freqMap[oldValue] -= 1;
    }
    freqMap[newValue] = newFreq +1;
}

we just needed to store frequencies of elements in such a way that we can perform search efficiently. So, to store them in keys, just storing their frequency count (frequency of frequencies) in values. so, frequency count is just used to store the actual element frequencies in keys.

I ended up creating a frequancy dictionary to store the frequancy as a key, and a Hash Set of values. I did this because the key needs to be unique, and in most cases, using a frequancy dictionary of integers alone would fail.

If you follow this path, always remember to remove the value from the current frequancy hash set before you move it onto the next, whenever you add or subtract. Don't worry about removing the entry, if there are no more values in a certain frequencies Hash Set. Just check that the Hash Set has a Count greater than 0, when asserting that the frequancy can be found.