WIP

Author: manastalukdar

.vscode/launch.json

@@ -4,6 +4,13 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+        {
+            "type": "java",
+            "name": "CodeLens (Launch) - Solution",
+            "request": "launch",
+            "mainClass": "EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC3_FrequencyStack.Java.Solution",
+            "projectName": "learning-computer-science"
+        },
         {
             "type": "java",
             "name": "Debug (Launch) Java",

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/Java/Element.java

@@ -0,0 +1,13 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC3_FrequencyStack.Java;
+
+class Element {
+    int number;
+    int frequency;
+    int sequenceNumber;
+
+    public Element(int number, int frequency, int sequenceNumber) {
+        this.number = number;
+        this.frequency = frequency;
+        this.sequenceNumber = sequenceNumber;
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/Java/ElementComparator.java

@@ -0,0 +1,13 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC3_FrequencyStack.Java;
+
+import java.util.Comparator;
+
+class ElementComparator implements Comparator<Element> {
+    public int compare(Element e1, Element e2) {
+        if (e1.frequency != e2.frequency) {
+            return e2.frequency - e1.frequency;
+        }
+        // if both elements have same frequency, return the one that was pushed later
+        return e2.sequenceNumber - e1.sequenceNumber;
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/Java/Solution.java

@@ -0,0 +1,44 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC3_FrequencyStack.Java;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class Solution {
+    int sequenceNumber = 0;
+    PriorityQueue<Element> maxHeap = new PriorityQueue<Element>(new ElementComparator());
+    Map<Integer, Integer> frequencyMap = new HashMap<>();
+
+    public static void main(String[] args) {
+        Solution frequencyStack = new Solution();
+        frequencyStack.push(1);
+        frequencyStack.push(2);
+        frequencyStack.push(3);
+        frequencyStack.push(2);
+        frequencyStack.push(1);
+        frequencyStack.push(2);
+        frequencyStack.push(5);
+        System.out.println(frequencyStack.pop());
+        System.out.println(frequencyStack.pop());
+        System.out.println(frequencyStack.pop());
+    }
+
+    public void push(int num) {
+        frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        maxHeap.offer(new Element(num, frequencyMap.get(num), sequenceNumber++));
+    }
+
+    public int pop() {
+        int num = maxHeap.poll().number;
+
+        // decrement the frequency or remove if this is the last number
+        if (frequencyMap.get(num) > 1) {
+            frequencyMap.put(num, frequencyMap.get(num) - 1);
+        } else {
+            frequencyMap.remove(num);
+        }
+
+        return num;
+    }
+
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/Java/SolutionTest.java

@@ -0,0 +1,41 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC3_FrequencyStack.Java;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public class SolutionTest {
+
+    Solution solution;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        solution = new Solution();
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        solution = null;
+    }
+
+    @Test
+    public void MainFunction() {
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String[] args = new String[0];
+            assertAll(() -> Solution.main(args));
+        });
+    }
+
+    @Test
+    public void TrivialCase1() {
+        // input = ;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            // expected = ;
+            // actual = Solution.;
+            // assertEquals(expected, actual);
+        });
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/metadata.json

@@ -0,0 +1,33 @@
+{
+    "type": "Coding",
+    "name": "Frequency Stack",
+    "origin": {
+        "name": "Educative",
+        "link": "https://www.educative.io/courses/grokking-the-coding-interview/Y5zDWlVRz2p"
+    },
+    "companies": ["", ""],
+    "categories": [{
+            "name": "Courses",
+            "children": [{
+                "name": "Grokking the Coding Interview: Patterns for Coding Questions",
+                "children": []
+            }]
+        },
+        {
+            "name": "Difficulty",
+            "children": [{
+                "name": "Hard",
+                "children": []
+            }]
+        },
+        {
+            "name": "Pattern",
+            "children": [{
+                "name": "Top K Elements",
+                "children": []
+            }]
+        }
+    ],
+    "tags": ["Top K Elements"],
+    "buckets": []
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC3_FrequencyStack/readme.md

@@ -0,0 +1,49 @@
+# Problem Definition
+
+## Description
+
+Design a class that simulates a Stack data structure, implementing the following two operations:
+
+1. `push(int num)`: Pushes the number ‘num’ on the stack.
+2. `pop()`: Returns the most frequent number in the stack. If there is a tie, return the number which was pushed later.
+
+Example:
+
+```plaintext
+After following push operations: push(1), push(2), push(3), push(2), push(1), push(2), push(5)
+
+1. pop() should return 2, as it is the most frequent number
+2. Next pop() should return 1
+3. Next pop() should return 2
+```
+
+## Discussion
+
+### Approach
+
+This problem follows the **Top ‘K’ Elements** pattern, and shares similarities with **Top ‘K’ Frequent Numbers**.
+
+We can use a **Max Heap** to store the numbers. Instead of comparing the numbers we will compare their frequencies so that the root of the heap is always the most frequently occurring number. There are two issues that need to be resolved though:
+
+1. How can we keep track of the frequencies of numbers in the heap? When we are pushing a new number to the **Max Heap**, we don’t know how many times the number has already appeared in the **Max Heap**. To resolve this, we will maintain a **HashMap** to store the current frequency of each number. Thus whenever we push a new number in the heap, we will increment its frequency in the HashMap and when we pop, we will decrement its frequency.
+2. If two numbers have the same frequency, we will need to return the number which was pushed later while popping. To resolve this, we need to attach a sequence number to every number to know which number came first.
+
+In short, we will keep three things with every number that we push to the heap:
+
+```plaintext
+    1. number // value of the number
+    2. frequency // current frequency of the number when it was pushed to the heap
+    3. sequenceNumber // a sequence number, to know what number came first
+```
+
+#### Time Complexity
+
+The time complexity of `push()` and `pop()` is O(logN) where ‘N’ is the current number of elements in the heap.
+
+#### Space Complexity
+
+We will need O(N) space for the heap and the map, so the overall space complexity of the algorithm is O(N).
+
+## Notes
+
+## References