Merge pull request #330 from sir-gon/feature/sherlock_and_anagrams

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

Author: sir-gon

docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.md

@@ -0,0 +1,114 @@
+# [Sherlock and Anagrams](https://www.hackerrank.com/challenges/sherlock-and-anagrams)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingMedium` `#dictionaries` `#hashmaps` `#strings`
+
+Two strings are [http://en.wikipedia.org/wiki/Anagram](anagrams) of each other
+if the letters of one string can be rearranged to form the other string.
+Given a string, find the number of pairs of substrings of the string that are
+anagrams of each other.
+
+## Example
+
+`s = mom`
+
+The list of all anagrammatic pairs is `[m, m]`, `[mo, om]`
+at positions `[[0], [2]]`, `[[0, 1], [1, 2]]` respectively.
+
+## Function Description
+
+Complete the function sherlockAndAnagrams in the editor below.
+
+*sherlockAndAnagrams* has the following parameter(s):
+
+- `string s`: a string
+
+## Returns
+
+- `int`: the number of unordered anagrammatic pairs of substrings in **`s`**
+
+## Input Format
+
+The first line contains an integer `q`, the number of queries.
+Each of the next `q` lines contains a string `s` to analyze.
+
+## Constraints
+
+- $ 1 \leq 10 \leq 10 $
+- $ 2 \leq $ lenght of `s` $ \leq 100 $
+
+`s` contains only lowercase letters in the range ascii[a-z].
+
+## Sample Input 0
+
+```text
+2
+abba
+abcd
+```
+
+## Sample Output 0
+
+```text
+4
+0
+```
+
+## Explanation 0
+
+The list of all anagrammatic pairs is `[a, a]`, `[ab, ba]`,
+`[b, b]` and `[abb, bba]` at positions `[[0], [3]]`, `[[0, 1]], [[2, 3]]`,
+`[[1], [2]]` and `[[0, 1, 2], [1, 2, 3]]` respectively.
+
+No anagrammatic pairs exist in the second query as no character repeats.
+
+## Sample Input 1
+
+```text
+2
+ifailuhkqq
+kkkk
+````
+
+## Sample Output 1
+
+```text
+3
+10
+```
+
+## Explanation 1
+
+For the first query, we have anagram pairs `[i, i]`, `[q, q]`
+and `[ifa, fai]` at positions `[[0], [3]]`, `[[8], [9]]`
+and `[[0, 1, 2], [1, 2, 3]]` respectively.
+
+For the second query:
+
+There are `6` anagrams of the form `[k, k]` at positions `[[0, 1]]`,
+ `[[0], [2]]`, `[[0], [3]]`, `[[1], [2]]`, `[[1], [3]]` and `[[2], [3]]`.
+
+There are 3 anagrams of the form `[kk, kk]` at positions `[[0, 1], [1, 2]]`,
+`[[0, 1], [2, 3]]` and `[[1, 2], [2, 3]]`.
+
+There is 1 anagram of the form `[kkk, kkk]` at position `[[0, 1, 2], [1, 2, 3]]`.
+
+## Sample Input 2
+
+```text
+1
+cdcd
+```
+
+## Sample Output 2
+
+```text
+5
+```
+
+## Explanation 2
+
+There are two anagrammatic pairs of length `1`: `[c, c]` and `[d, d]`.
+There are three anagrammatic pairs of length `2`:
+`[cd, dc]`, `[cd, cd]`, `[dc, cd]` at positions
+`[[0, 1] [1, 2]]`, `[[0, 1], [2, 3]]`, `[1, 2], [2, 3]` respectively.

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock-and-anagrams.go

@@ -0,0 +1,88 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.md]]
+ */
+
+package hackerrank
+
+import (
+	"math/big"
+	"slices"
+	"strings"
+
+	"gon.cl/algorithms/utils/log"
+)
+
+func factorialBig(n int64) *big.Int {
+	if n <= 0 {
+		return big.NewInt(1)
+	}
+	result := big.NewInt(1)
+	for i := int64(2); i <= n; i++ {
+		result.Mul(result, big.NewInt(i))
+	}
+	return result
+}
+
+func sherlockAndAnagrams(s string) int32 {
+	candidates := make(map[string][]string)
+	size := len(s)
+
+	for i := 0; i < size; i++ {
+		for j := 0; j < size-i; j++ {
+			substr := s[i : size-j]
+
+			log.Debug("i: %d, size: %d, size - j: %d | substr: %s",
+				i, size, size-j, substr)
+
+			anagramCandidateSlice := strings.Split(substr, "")
+			slices.Sort(anagramCandidateSlice)
+			anagramCandidate := strings.Join(anagramCandidateSlice, "")
+
+			_, ok := candidates[anagramCandidate]
+			if ok {
+				// Key exists
+				candidates[anagramCandidate] = append(candidates[anagramCandidate], substr)
+			} else {
+				// Key does not exist
+				candidates[anagramCandidate] = []string{substr}
+			}
+		}
+	}
+
+	var total int32 = 0
+	var qCandidates int32 = 0
+
+	// # Final Anagram list
+	for word := range candidates {
+		quantityOfAnagrams := int32(len(candidates[word]))
+		k := int32(2)
+
+		if quantityOfAnagrams <= 1 {
+			delete(candidates, word)
+		} else {
+			// # Binomial coefficient: https://en.wikipedia.org/wiki/Binomial_coefficient
+			qCandidates += quantityOfAnagrams
+
+			result := big.NewInt(1)
+
+			count := result.Div(
+				factorialBig(int64(quantityOfAnagrams)),
+				result.Mul(
+					factorialBig(int64(k)),
+					factorialBig(int64(quantityOfAnagrams-k))))
+
+			total += int32(count.Int64())
+
+			log.Debug("Partial anagrams of %s: %d", word, count)
+		}
+
+		log.Debug(
+			"sherlock_and_anagrams(%s) Filtered # candidates: %d", s, qCandidates)
+		log.Debug("sherlock_and_anagrams(%s) # anagrams: %d", s, total)
+	}
+	return total
+}
+
+func SherlockAndAnagrams(s string) int32 {
+	return sherlockAndAnagrams((s))
+}

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock-and-anagrams.testcases.json

@@ -0,0 +1,47 @@
+[
+  {
+    "title": "Test case 3",
+    "tests": [
+      {
+        "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "expected": 166650
+      },
+      {
+        "input": "bbcaadacaacbdddcdbddaddabcccdaaadcadcbddadababdaaabcccdcdaacadcababbabbdbacabbdcbbbbbddacdbbcdddbaaa",
+        "expected": 4832
+      },
+      {
+        "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "expected": 166650
+      },
+      {
+        "input": "cacccbbcaaccbaacbbbcaaaababcacbbababbaacabccccaaaacbcababcbaaaaaacbacbccabcabbaaacabccbabccabbabcbba",
+        "expected": 13022
+      },
+      {
+        "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "expected": 166650
+      },
+      {
+        "input": "bbcbacaabacacaaacbbcaabccacbaaaabbcaaaaaaaccaccabcacabbbbabbbbacaaccbabbccccaacccccabcabaacaabbcbaca",
+        "expected": 9644
+      },
+      {
+        "input": "cbaacdbaadbabbdbbaabddbdabbbccbdaccdbbdacdcabdbacbcadbbbbacbdabddcaccbbacbcadcdcabaabdbaacdccbbabbbc",
+        "expected": 6346
+      },
+      {
+        "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "expected": 166650
+      },
+      {
+        "input": "babacaccaaabaaaaaaaccaaaccaaccabcbbbabccbbabababccaabcccacccaaabaccbccccbaacbcaacbcaaaaaaabacbcbbbcc",
+        "expected": 8640
+      },
+      {
+        "input": "bcbabbaccacbacaacbbaccbcbccbaaaabbbcaccaacaccbabcbabccacbaabbaaaabbbcbbbbbaababacacbcaabbcbcbcabbaba",
+        "expected": 11577
+      }
+    ]
+  }
+]

exercises/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock-and-anagrams_test.go

@@ -0,0 +1,50 @@
+package hackerrank
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"gon.cl/algorithms/utils"
+)
+
+type SherlockAndAnagramsTest struct {
+	Input    string `json:"input"`
+	Expected int32  `json:"expected"`
+}
+
+type SherlockAndAnagramsTests struct {
+	Title string                    `json:"title"`
+	Tests []SherlockAndAnagramsTest `json:"tests"`
+}
+
+var SherlockAndAnagramsTestCases []SherlockAndAnagramsTests
+
+// You can use testing.T, if you want to test the code without benchmarking
+func SherlockAndAnagramsSetupSuite(t testing.TB) {
+	wd, _ := os.Getwd()
+	filepath := wd + "/sherlock-and-anagrams.testcases.json"
+	t.Log("Setup test cases from JSON: ", filepath)
+
+	var _, err = utils.LoadJSON(filepath, &SherlockAndAnagramsTestCases)
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func TestSherlockAndAnagrams(t *testing.T) {
+
+	SherlockAndAnagramsSetupSuite(t)
+
+	for _, tt := range SherlockAndAnagramsTestCases {
+		for _, testCase := range tt.Tests {
+			testname := fmt.Sprintf("SherlockAndAnagrams(%s) => %d \n", testCase.Input, testCase.Expected)
+
+			t.Run(testname, func(t *testing.T) {
+				ans := SherlockAndAnagrams(testCase.Input)
+				assert.Equal(t, testCase.Expected, ans)
+			})
+		}
+	}
+}