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

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

Author: sir-gon

algorithm-exercises-java/src/main/java/ae/hackerrank/interview_preparation_kit/greedy_algorithms/AngryFlorist.java

@@ -0,0 +1,35 @@
+package ae.hackerrank.interview_preparation_kit.greedy_algorithms;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * AngryFlorist.
+ *
+ * @link Problem definition
+ *       [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/angry-children.md]]
+ */
+public class AngryFlorist {
+
+  private AngryFlorist() {
+  }
+
+  /**
+   * maxMin.
+   */
+  public static int maxMin(int k, List<Integer> arr) {
+    List<Integer> sortedNums = arr.stream().collect(Collectors.toList());
+    Collections.sort(sortedNums);
+
+    int result = sortedNums.get(sortedNums.size() - 1) - sortedNums.get(0);
+
+    for (int i = 0; i < sortedNums.size() - k + 1; i++) {
+      int tmin = sortedNums.get(i);
+      int tmax = sortedNums.get(i + k - 1);
+      result = Math.min(result, tmax - tmin);
+    }
+
+    return result;
+  }
+}

algorithm-exercises-java/src/test/java/ae/hackerrank/interview_preparation_kit/greedy_algorithms/AngryFloristTest.java

@@ -0,0 +1,49 @@
+package ae.hackerrank.interview_preparation_kit.greedy_algorithms;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+import util.JsonLoader;
+
+/**
+ * AngryFloristTest.
+ */
+@TestInstance(Lifecycle.PER_CLASS)
+class AngryFloristTest {
+  public static class AngryFloristTestCase {
+    public String title;
+    public Integer k;
+    public List<Integer> arr;
+    public Integer expected;
+  }
+
+  private List<AngryFloristTestCase> testCases;
+
+  @BeforeAll
+  void setup() throws IOException {
+    String path = String.join("/",
+        "hackerrank",
+        "interview_preparation_kit",
+        "greedy_algorithms",
+        "angry_children.testcases.json");
+    this.testCases = JsonLoader.loadJson(path, AngryFloristTestCase.class);
+  }
+
+  @Test
+  void testLuckBalance() {
+    for (AngryFloristTestCase test : testCases) {
+      Integer result = AngryFlorist.maxMin(test.k, test.arr);
+
+      assertEquals(test.expected, result,
+          "%s(%s) => must be: %d".formatted(
+              "AngryFlorist.maxMin",
+              test.arr.toString(),
+              test.expected));
+    }
+  }
+}

algorithm-exercises-java/src/test/resources/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
+  }
+]

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`.