2671-FrequencyTracker.go

package main

// 2671. Frequency Tracker
// Design a data structure that keeps track of the values in it and answers some queries regarding their frequencies.
// Implement the FrequencyTracker class.
//     FrequencyTracker(): Initializes the FrequencyTracker object with an empty array initially.
//     void add(int number): Adds number to the data structure.
//     void deleteOne(int number): Deletes one occurrence of number from the data structure. The data structure may not contain number, and in this case nothing is deleted.
//     bool hasFrequency(int frequency): Returns true if there is a number in the data structure that occurs frequency number of times, otherwise, it returns false.
    
// Example 1:
// Input
// ["FrequencyTracker", "add", "add", "hasFrequency"]
// [[], [3], [3], [2]]
// Output
// [null, null, null, true]
// Explanation
// FrequencyTracker frequencyTracker = new FrequencyTracker();
// frequencyTracker.add(3); // The data structure now contains [3]
// frequencyTracker.add(3); // The data structure now contains [3, 3]
// frequencyTracker.hasFrequency(2); // Returns true, because 3 occurs twice

// Example 2:
// Input
// ["FrequencyTracker", "add", "deleteOne", "hasFrequency"]
// [[], [1], [1], [1]]
// Output
// [null, null, null, false]
// Explanation
// FrequencyTracker frequencyTracker = new FrequencyTracker();
// frequencyTracker.add(1); // The data structure now contains [1]
// frequencyTracker.deleteOne(1); // The data structure becomes empty []
// frequencyTracker.hasFrequency(1); // Returns false, because the data structure is empty

// Example 3:
// Input
// ["FrequencyTracker", "hasFrequency", "add", "hasFrequency"]
// [[], [2], [3], [1]]
// Output
// [null, false, null, true]
// Explanation
// FrequencyTracker frequencyTracker = new FrequencyTracker();
// frequencyTracker.hasFrequency(2); // Returns false, because the data structure is empty
// frequencyTracker.add(3); // The data structure now contains [3]
// frequencyTracker.hasFrequency(1); // Returns true, because 3 occurs once

// Constraints:
//     1 <= number <= 10^5
//     1 <= frequency <= 10^5
//     At most, 2 * 10^5 calls will be made to add, deleteOne, and hasFrequency in total.

import "fmt"

type FrequencyTracker struct {
    data map[int]int
    freq map[int]int
}

func Constructor() FrequencyTracker {
    return FrequencyTracker{
        data: map[int]int{},
        freq: map[int]int{},
    }
}

func (ft *FrequencyTracker) Add(number int)  {
    if ft.data[number] >= 1 {
        ft.freq[ft.data[number]]--
    }
    ft.data[number]++
    ft.freq[ft.data[number]]++
}

func (ft *FrequencyTracker) DeleteOne(number int)  {
    if ft.data[number] == 0 {
        return
    }
    ft.freq[ft.data[number]]--
    ft.data[number]--
    if ft.data[number] != 0 {
        ft.freq[ft.data[number]]++
    } else {
        delete(ft.data, number)
    }
}

func (ft *FrequencyTracker) HasFrequency(frequency int) bool {
    return ft.freq[frequency] > 0
}


/**
 * Your FrequencyTracker object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Add(number);
 * obj.DeleteOne(number);
 * param_3 := obj.HasFrequency(frequency);
 */

func main() {
    obj := Constructor()
    obj.Add(3) // The data structure now contains [3]
    obj.Add(3) // The data structure now contains [3, 3]
    fmt.Println(obj.HasFrequency(2)) // Returns true, because 3 occurs twice

    // FrequencyTracker frequencyTracker = new FrequencyTracker();
    obj = Constructor()
    obj.Add(1) // The data structure now contains [1]
    obj.DeleteOne(1); // The data structure becomes empty []
    fmt.Println(obj.HasFrequency(1)) // Returns false, because the data structure is empty

    obj = Constructor()
    fmt.Println(obj.HasFrequency(2)) // Returns false, because the data structure is empty
    obj.Add(3) // The data structure now contains [3]
    fmt.Println(obj.HasFrequency(1)) // Returns true, because 3 occurs once
}