[Hacker Rank] Interview Preparation Kit: Dictionaries and Hashmaps: Frequency Queries. Solved ✓.

Author: Gonzalo Diaz

docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency-queries.md

@@ -0,0 +1,145 @@
+# [Dictionaries and Hashmaps: Frequency Queries](https://www.hackerrank.com/challenges/frequency-queries)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingIntermediate` `#dictionaries` `#hashmaps`
+
+You are given  queries. Each query is of the form two integers described below:
+
+- `1 x`: Insert x in your data structure.
+- `2 y`: Delete one occurence of y from your data structure, if present.
+- `3 z`: Check if any integer is present whose frequency is exactly `z`.
+If yes, print `1` else `0`.
+
+The queries are given in the form of a 2-D array `queries` of
+size where `queries[i][0]` contains the operation,
+and `queries[i][0]` contains the data element.
+
+## Example
+
+The results of each operation are:
+
+```text
+Operation   Array   Output
+(1,1)       [1]
+(2,2)       [1]
+(3,2)                   0
+(1,1)       [1,1]
+(1,1)       [1,1,1]
+(2,1)       [1,1]
+(3,2)                   1
+```
+
+Return an array with the output: [0, 1].
+
+## Function Description
+
+Complete the freqQuery function in the editor below.
+
+freqQuery has the following parameter(s):
+
+- `int queries[q][2]`: a 2-d array of integers
+
+## Returns
+
+- `int[]`: the results of queries of type `3`
+
+## Input Format
+
+The first line contains of an integer `q`, the number of queries.
+
+Each of the next `q` lines contains two space-separated integers,
+`queries[i][0]` and `queries[i][1]`.
+
+## Constraints
+
+- $ 1 \leq q \leq 10^5 $
+- $ 1 \leq x, y, z \leq 10^9 $
+- All $ queries[i][0] \isin \{1, 2, 3\} $
+- $ 1 \leq queries[i][1] \leq 10^9 $
+
+## Sample Input 0
+
+```text
+8
+1 5
+1 6
+3 2
+1 10
+1 10
+1 6
+2 5
+3 2
+```
+
+## Sample Output 0
+
+```text
+0
+1
+```
+
+## Explanation 0
+
+For the first query of type `3`, there is no integer
+whose frequency is `2` (`array = [5, 6]`).
+So answer is `0`.
+
+For the second query of type `3`, there are two integers
+in `array = [6, 10, 10, 6]` whose frequency is `2`(integer = `6` and `10`).
+So, the answer is `1`.
+
+## Sample Input 1
+
+```†ext
+4
+3 4
+2 1003
+1 16
+3 1
+```
+
+## Sample Output 1
+
+```†ext
+0
+1
+```
+
+## Explanation 1
+
+For the first query of type `3`, there is no integer of frequency `4`.
+The answer is `0`. For the second query of type `3`,
+there is one integer, `16` of frequency `1` so the answer is `1`.
+
+## Sample Input 2
+
+```text
+10
+1 3
+2 3
+3 2
+1 4
+1 5
+1 5
+1 4
+3 2
+2 4
+3 2
+```
+
+## Sample Output 2
+
+```text
+0
+1
+1
+
+```
+
+## Explanation 2
+
+When the first output query is run, the array is empty.
+We insert two `4`'s and two `5`'s before the second output query,
+`arr = [4, 5, 5, 4]` so there are two instances of elements occurring twice.
+We delete a `4` and run the same query.
+Now only the instances of `5` satisfy the query.

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.go

@@ -0,0 +1,51 @@
+/*
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency-queries.md]]
+ */
+
+package hackerrank
+
+const __INITIAL__ = 0
+
+const __INSERT__ = 1
+const __DELETE__ = 2
+const __SELECT__ = 3
+
+const __NOT_FOUND__ = 0
+const __FOUND__ = 1
+
+func freqQuery(queries [][]int32) []int32 {
+	m := make(map[int32]int32)
+	freq := make(map[int32]int32)
+	var result []int32
+
+	for _, query := range queries {
+		switch query[0] {
+		case __INSERT__:
+			if m[query[1]] == __INITIAL__ {
+				m[query[1]] = 1
+			} else {
+				freq[m[query[1]]]--
+				m[query[1]]++
+			}
+			freq[m[query[1]]]++
+		case __DELETE__:
+			if m[query[1]] > __INITIAL__ {
+				freq[m[query[1]]]--
+				m[query[1]]--
+				freq[m[query[1]]]++
+			}
+		case __SELECT__:
+			if freq[query[1]] > __NOT_FOUND__ {
+				result = append(result, __FOUND__)
+			} else {
+				result = append(result, __NOT_FOUND__)
+			}
+		}
+	}
+
+	return result
+}
+
+func FreqQuery(queries [][]int32) []int32 {
+	return freqQuery(queries)
+}

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries.testcases.json

@@ -0,0 +1,84 @@
+[
+  {
+    "title": "Sample Test Case 0",
+    "input": [
+      [1, 5],
+      [1, 6],
+      [3, 2],
+      [1, 10],
+      [1, 10],
+      [1, 6],
+      [2, 5],
+      [3, 2]
+    ],
+    "expected": [0, 1]
+  },
+  {
+    "title": "Sample Test Case 2",
+    "input": [
+      [1, 3],
+      [2, 3],
+      [3, 2],
+      [1, 4],
+      [1, 5],
+      [1, 5],
+      [1, 4],
+      [3, 2],
+      [2, 4],
+      [3, 2]
+    ],
+    "expected": [0, 1, 1]
+  },
+  {
+    "title": "Sample Test Case 3",
+    "input": [
+      [1, 3],
+      [1, 38],
+      [2, 1],
+      [1, 16],
+      [2, 1],
+      [2, 2],
+      [1, 64],
+      [1, 84],
+      [3, 1],
+      [1, 100],
+      [1, 10],
+      [2, 2],
+      [2, 1],
+      [1, 67],
+      [2, 2],
+      [3, 1],
+      [1, 99],
+      [1, 32],
+      [1, 58],
+      [3, 2]
+    ],
+    "expected": [1, 1, 0]
+  },
+  {
+    "title": "Sample Test Case 3",
+    "input": [
+      [1, 3],
+      [1, 38],
+      [2, 1],
+      [1, 16],
+      [2, 1],
+      [2, 2],
+      [1, 64],
+      [1, 84],
+      [3, 1],
+      [1, 100],
+      [1, 10],
+      [2, 2],
+      [2, 1],
+      [1, 67],
+      [2, 2],
+      [3, 1],
+      [1, 99],
+      [1, 32],
+      [1, 58],
+      [3, 2]
+    ],
+    "expected": [1, 1, 0]
+  }
+]

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_test.go

@@ -0,0 +1,44 @@
+package hackerrank
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gon.cl/algorithms/utils"
+)
+
+type FrequencyQueriesTestCase struct {
+	Input    [][]int32 `json:"input"`
+	Expected []int32   `json:"expected"`
+}
+
+var FrequencyQueriesTestCases []FrequencyQueriesTestCase
+
+// You can use testing.T, if you want to test the code without benchmarking
+func FrequencyQueriesSetupSuite(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/frequency_queries.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &FrequencyQueriesTestCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func TestFrequencyQueries(t *testing.T) {
+
+	FrequencyQueriesSetupSuite(t)
+
+	for _, tt := range FrequencyQueriesTestCases {
+		testname := fmt.Sprintf("FreqQuery(%v) => %v \n", tt.Input, tt.Expected)
+		t.Run(testname, func(t *testing.T) {
+
+			ans := FreqQuery(tt.Input)
+			assert.Equal(t, tt.Expected, ans)
+		})
+
+	}
+}