Maximum Frequency Stack

class FreqStack {
    unordered_map<int,int> freq;
    vector<stack<int>> group;
public:
    void push(int val) {
        int k = ++freq[val];
        if ((int)group.size() < k) group.emplace_back();
        group[k - 1].push(val);
    }

    int pop() {
        int val = group.back().top();
        group.back().pop();
        if (group.back().empty()) group.pop_back();
        --freq[val];
        return val;
    }
};

type FreqStack struct {
    freq  map[int]int
    group [][]int
}

func Constructor() FreqStack {
    return FreqStack{freq: map[int]int{}}
}

func (s *FreqStack) Push(val int) {
    s.freq[val]++
    k := s.freq[val]
    if len(s.group) < k {
        s.group = append(s.group, []int{})
    }
    s.group[k-1] = append(s.group[k-1], val)
}

func (s *FreqStack) Pop() int {
    top := len(s.group) - 1
    stack := s.group[top]
    val := stack[len(stack)-1]
    s.group[top] = stack[:len(stack)-1]
    if len(s.group[top]) == 0 {
        s.group = s.group[:top]
    }
    s.freq[val]--
    return val
}

from collections import defaultdict
from typing import List

class FreqStack:
    def __init__(self):
        self.freq: dict = defaultdict(int)
        self.group: List[List[int]] = []

    def push(self, val: int) -> None:
        self.freq[val] += 1
        k = self.freq[val]
        if len(self.group) < k:
            self.group.append([])
        self.group[k - 1].append(val)

    def pop(self) -> int:
        val = self.group[-1].pop()
        if not self.group[-1]:
            self.group.pop()
        self.freq[val] -= 1
        return val

class FreqStack {
    constructor() {
        this.freq = new Map();
        this.group = [];
    }

    push(val) {
        const k = (this.freq.get(val) ?? 0) + 1;
        this.freq.set(val, k);
        if (this.group.length < k) this.group.push([]);
        this.group[k - 1].push(val);
    }

    pop() {
        const top = this.group[this.group.length - 1];
        const val = top.pop();
        if (top.length === 0) this.group.pop();
        this.freq.set(val, this.freq.get(val) - 1);
        return val;
    }
}

class FreqStack {
    private Map<Integer, Integer> freq;
    private List<Deque<Integer>> group;

    public FreqStack() {
        freq = new HashMap<>();
        group = new ArrayList<>();
    }

    public void push(int val) {
        int k = freq.getOrDefault(val, 0) + 1;
        freq.put(val, k);
        if (group.size() < k) group.add(new ArrayDeque<>());
        group.get(k - 1).push(val);
    }

    public int pop() {
        Deque<Integer> top = group.get(group.size() - 1);
        int val = top.pop();
        if (top.isEmpty()) group.remove(group.size() - 1);
        freq.put(val, freq.get(val) - 1);
        return val;
    }
}

class FreqStack {
    private freq: Map<number, number> = new Map();
    private group: number[][] = [];

    push(val: number): void {
        const k = (this.freq.get(val) ?? 0) + 1;
        this.freq.set(val, k);
        if (this.group.length < k) this.group.push([]);
        this.group[k - 1].push(val);
    }

    pop(): number {
        const top = this.group[this.group.length - 1];
        const val = top.pop() as number;
        if (top.length === 0) this.group.pop();
        this.freq.set(val, (this.freq.get(val) as number) - 1);
        return val;
    }
}