Merge pull request #332 from sir-gon/feature/count_triplets_1

[Hacker Rank] Interview Preparation Kit: Dictionaries and Hashmaps: C…

Author: sir-gon

docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1-solution-notes.md

@@ -0,0 +1,13 @@
+# [Dictionaries and Hashmaps: Count Triplets](https://www.hackerrank.com/challenges/count-triplets-1)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingIntermediate`
+
+## Working solution
+
+This solution in O(N), is based on considering that each
+number analyzed is in the center of the triplet and asks
+"how many" possible cases there are on the left and
+right to calculate how many possible triplets are formed.
+
+- Source: [Hackerrank - Count Triplets Solution](https://www.thepoorcoder.com/hackerrank-count-triplets-solution/)

docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.md

@@ -0,0 +1,99 @@
+# [Dictionaries and Hashmaps: Count Triplets](https://www.hackerrank.com/challenges/count-triplets-1)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingIntermediate` `#dictionaries` `#hashmaps`
+
+You are given an array and you need to find number of
+tripets of indices (i, j, k) such that the elements at
+those indices are in geometric progression for a given
+common ratio `r` and $ i < j < k $.
+
+## Example
+
+`arr = [1, 4, 16, 64]   r = 4`
+
+There are `[1, 4, 16]` and `[4, 16, 64]` at indices  (0, 1, 2) and (1, 2, 3).
+Return `2`.
+
+## Function Description
+
+Complete the countTriplets function in the editor below.
+
+countTriplets has the following parameter(s):
+
+- `int arr[n]`: an array of integers
+- `int r`: the common ratio
+
+## Returns
+
+- `int`: the number of triplets
+
+## Input Format
+
+The first line contains two space-separated integers `n` and `r`,
+the size of `arr` and the common ratio.
+The next line contains `n` space-seperated integers `arr[i]`.
+
+## Constraints
+
+- $ 1 \leq n \leq 10^5 $
+- $ 1 \leq r \leq 10^9 $
+- $ 1 \leq arr[i] \leq 10^9 $
+
+## Sample Input 0
+
+```text
+4 2
+1 2 2 4
+```
+
+## Sample Output 0
+
+```text
+2
+```
+
+## Explanation 0
+
+There are `2` triplets in satisfying our criteria,
+whose indices are (0, 1, 3) and (0, 2, 3)
+
+## Sample Input 1
+
+```text
+6 3
+1 3 9 9 27 81
+```
+
+## Sample Output 1
+
+```text
+6
+```
+
+## Explanation 1
+
+The triplets satisfying are index
+`(0, 1, 2)`, `(0, 1, 3)`, `(1, 2, 4)`, `(1, 3, 4)`, `(2, 4, 5)` and `(3, 4, 5)`.
+
+## Sample Input 2
+
+```text
+5 5
+1 5 5 25 125
+```
+
+## Sample Output 2
+
+```text
+4
+```
+
+## Explanation 2
+
+The triplets satisfying are index
+`(0, 1, 3)`, `(0, 2, 3)`, `(1, 2, 3)`, `(2, 3, 4)`.
+
+## Appendix
+
+[Solution notes](count_triplets_1-solution-notes.md)

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count-triplets-1.big.testcases.json

@@ -0,0 +1,12 @@
+[
+  {
+    "title": "Sample Test Case 2",
+    "input": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    "r": 1,
+    "expected": 161700
+  }
+]

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count-triplets-1.go

@@ -0,0 +1,55 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1.md]]
+ */
+
+package hackerrank
+
+func countTripletsBruteForce(arr []int64, r int64) int64 {
+	size := len(arr)
+	counter := int64(0)
+	for i := 0; i < size-2; i++ {
+		for j := i + 1; j < size-1; j++ {
+			for k := j + 1; k < size; k++ {
+				if r*arr[i] == arr[j] && r*arr[j] == arr[k] {
+					counter++
+				}
+			}
+		}
+	}
+	return counter
+}
+
+func countTriplets(arr []int64, r int64) int64 {
+	aCounter := make(map[int64]int64)
+	bCounter := make(map[int64]int64)
+	triplets := int64(0)
+
+	for _, item := range arr {
+		if _, ok := aCounter[item]; ok && aCounter[item] > 0 {
+			aCounter[item] += 1
+		} else {
+			aCounter[item] = 1
+		}
+	}
+
+	for _, item := range arr {
+		j := item / r
+		k := item * r
+
+		aCounter[item]--
+		if bCounter[j] > 0 && aCounter[k] > 0 && item%r == 0 {
+			triplets += bCounter[j] * aCounter[k]
+		}
+		bCounter[item]++
+	}
+
+	return triplets
+}
+
+func CountTriplets(arr []int64, r int64) int64 {
+	return countTriplets(arr, r)
+}
+
+func CountTripletsBruteForce(arr []int64, r int64) int64 {
+	return countTripletsBruteForce(arr, r)
+}

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count-triplets-1.small.testcases.json

@@ -0,0 +1,26 @@
+[
+  {
+    "title": "Sample Test Case 0",
+    "input": [1, 2, 2, 4],
+    "r": 2,
+    "expected": 2
+  },
+  {
+    "title": "Sample Test Case 1",
+    "input": [1, 3, 9, 9, 27, 81],
+    "r": 3,
+    "expected": 6
+  },
+  {
+    "title": "Sample Test Case 1 (unsorted)",
+    "input": [9, 3, 1, 81, 9, 27],
+    "r": 3,
+    "expected": 1
+  },
+  {
+    "title": "Sample Test Case 12",
+    "input": [1, 5, 5, 25, 125],
+    "r": 5,
+    "expected": 4
+  }
+]

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count-triplets-1_test.go

@@ -0,0 +1,84 @@
+package hackerrank
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gon.cl/algorithms/utils"
+)
+
+type CountTripletsTestCase struct {
+	Input    []int64 `json:"Input"`
+	Ratio    int64   `json:"r"`
+	Expected int64   `json:"expected"`
+}
+
+var CountTripletsTestCases []CountTripletsTestCase
+var CountTripletsBigTestCases []CountTripletsTestCase
+
+// You can use testing.T, if you want to test the code without benchmarking
+func CountTripletsSetupSuite(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/count-triplets-1.small.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &CountTripletsTestCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func CountTripletsSetupSuiteBigCases(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/count-triplets-1.big.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &CountTripletsBigTestCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func TestCountTriplets(t *testing.T) {
+
+	CountTripletsSetupSuite(t)
+
+	for _, tt := range CountTripletsTestCases {
+		testname := fmt.Sprintf("CountTriplets(%v, %v) => %v \n", tt.Input, tt.Ratio, tt.Expected)
+		t.Run(testname, func(t *testing.T) {
+			ans := CountTriplets(tt.Input, tt.Ratio)
+			assert.Equal(t, tt.Expected, ans)
+		})
+
+	}
+}
+
+func TestCountTripletsBigCases(t *testing.T) {
+
+	CountTripletsSetupSuiteBigCases(t)
+
+	for _, tt := range CountTripletsBigTestCases {
+		testname := fmt.Sprintf("CountTriplets(%v, %v) => %v \n", tt.Input, tt.Ratio, tt.Expected)
+		t.Run(testname, func(t *testing.T) {
+			ans := CountTriplets(tt.Input, tt.Ratio)
+			assert.Equal(t, tt.Expected, ans)
+		})
+
+	}
+}
+
+func TestCountTripletsBruteForce(t *testing.T) {
+
+	CountTripletsSetupSuiteBigCases(t)
+
+	for _, tt := range CountTripletsTestCases {
+		testname := fmt.Sprintf("CountTripletsBruteForce(%v, %v) => %v \n", tt.Input, tt.Ratio, tt.Expected)
+		t.Run(testname, func(t *testing.T) {
+			ans := CountTripletsBruteForce(tt.Input, tt.Ratio)
+			assert.Equal(t, tt.Expected, ans)
+		})
+
+	}
+}