Merge pull request #353 from sir-gon/feature/angry-children

[Hacker Rank] Interview Preparation Kit: Greedy Algorithms: Max Min. …

Author: sir-gon

docs/hackerrank/interview_preparation_kit/greedy_algorithms/angry-children.md

@@ -0,0 +1,143 @@
+# [Greedy Algorithms: Max Min](https://www.hackerrank.com/challenges/angry-children)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingBasic` `#greedyalgorithms`
+
+You will be given a list of integers, `arr`, and a single integer `k`.
+You must create an array of length `k` from elements of `arr` such that
+its unfairness is minimized.
+Call that array `arr'`.
+Unfairness of an array is calculated as
+
+$$
+\textsf{\textbf{max(arr')}} - \textsf{\textbf{min(arr')}}
+$$
+
+Where:
+
+- max denotes the largest integer in `arr'`.
+- min denotes the smallest integer in `arr'`.
+
+## Example
+
+`arr = [1, 4, 7, 2]`
+`k = 2`
+
+Pick any two elements, say `arr' = [4, 7]`.
+
+$ \textsf{\textbf{unfairness}}
+    =
+    \textsf{\textbf{max(4, 7)}}
+    -
+    \textsf{\textbf{min(4, 7)}}
+    = 7 - 4 = 3
+$
+
+Testing for all pairs, the solution [1, 2] provides the minimum unfairness.
+
+**Note**: Integers in `arr` may not be unique.
+
+## Function Description
+
+Complete the maxMin function in the editor below.
+maxMin has the following parameter(s):
+
+- `int k`: the number of elements to select
+- `int arr[n]`: an array of integers
+
+## Returns
+
+- int: the minimum possible unfairness
+
+## Input Format
+
+The first line contains an integer , the number of elements in array .
+The second line contains an integer .
+Each of the next  lines contains an integer  where .
+
+## Constraints
+
+- $ 2 \leq n \leq 10^5 $
+- $ 2 \leq k \leq n $
+- $ 0 \leq arr[i] \leq 10^9 $
+
+## Sample Input 0
+
+```text
+7
+3
+10
+100
+300
+200
+1000
+20
+30
+```
+
+## Sample Output 0
+
+```text
+20
+```
+
+## Explanation 0
+
+Here `k = 3`; selecting the `3` integers `10, 20,30`, unfairness equals
+
+```text
+max(10,20,30) - min(10,20,30) = 30 - 10 = 20
+```
+
+## Sample Input 1
+
+```text
+10
+4
+1
+2
+3
+4
+10
+20
+30
+40
+100
+200
+```
+
+## Sample Output 1
+
+```text
+3
+```
+
+## Explanation 1
+
+Here `k = 4`; selecting the `4` integers `1, 2, 3, 4`, unfairness equals
+
+```text
+max(1,2,3,4) - min(1,2,3,4) = 4 - 1 = 3
+```
+
+## Sample Input 2
+
+```text
+5
+2
+1
+2
+1
+2
+1
+```
+
+## Sample Output 2
+
+```text
+0
+```
+
+## Explanation 2
+
+Here `k = 2`. `arr' = [2, 2]` or `arr' = [1, 1]` give the minimum unfairness of `0`.

exercises/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.go

@@ -0,0 +1,30 @@
+/**
+ * @link Problem definition [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/angry-children.md]]
+ */
+
+package hackerrank
+
+import (
+	"slices"
+)
+
+func maxMin(k int32, arr []int32) int32 {
+	// Sort the array
+	sortedlist := make([]int32, len(arr))
+	copy(sortedlist, arr)
+	slices.Sort(sortedlist)
+
+	var result = sortedlist[len(arr)-1] - sortedlist[0]
+
+	for i := range int32(len(arr)) - k + 1 {
+		var tmin = sortedlist[i]
+		var tmax = sortedlist[i+k-1]
+		result = min(result, tmax-tmin)
+	}
+
+	return result
+}
+
+func MaxMin(k int32, arr []int32) int32 {
+	return maxMin(k, arr)
+}

exercises/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.testcases.json

@@ -0,0 +1,26 @@
+[
+  {
+    "title": "Sample Test case 0",
+    "k": 3,
+    "arr": [10, 100, 300, 200, 1000, 20, 30],
+    "expected": 20
+  },
+  {
+    "title": "Sample Test case 1",
+    "k": 4,
+    "arr": [1, 2, 3, 4, 10, 20, 30, 40, 100, 200],
+    "expected": 3
+  },
+  {
+    "title": "Sample Test case 2",
+    "k": 2,
+    "arr": [1, 2, 1, 2, 1],
+    "expected": 0
+  },
+  {
+    "title": "Sample Test case 16",
+    "k": 3,
+    "arr": [100, 200, 300, 350, 400, 401, 402],
+    "expected": 2
+  }
+]

exercises/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children_test.go

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