[Hacker Rank] Interview Preparation Kit: Greedy Algorithms: Greedy Florist. Solved ✅.

Author: Gonzalo Diaz

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

@@ -0,0 +1,40 @@
+package ae.hackerrank.interview_preparation_kit.greedy_algorithms;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * GreedyFlorist.
+ *
+ * @link Problem definition
+ *       [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/greedy-florist.md]]
+ * @link Solution notes
+ *      [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/greedy-florist-solution-notes.md]]
+ */
+public class GreedyFlorist {
+
+  private GreedyFlorist() {
+  }
+
+  /**
+   * getMinimumCost.
+   */
+  public static int getMinimumCost(int k, int[] c) {
+    List<Integer> flowers = Arrays.stream(c).boxed().collect(Collectors.toList());
+    Collections.reverse(flowers);
+
+    int totalCost = 0;
+    int i = 0;
+
+    for (Integer flowerCost : flowers) {
+      int position = (int) (i / k);
+      totalCost += (position + 1) * flowerCost;
+
+      i += 1;
+    }
+
+    return totalCost;
+  }
+}

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

@@ -0,0 +1,50 @@
+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;
+
+/**
+ * GreedyFloristTest.
+ */
+@TestInstance(Lifecycle.PER_CLASS)
+class GreedyFloristTest {
+  public static class GreedyFloristTestCase {
+    public String title;
+    public List<Integer> c;
+    public Integer k;
+    public Integer expected;
+  }
+
+  private List<GreedyFloristTestCase> testCases;
+
+  @BeforeAll
+  void setup() throws IOException {
+    String path = String.join("/",
+        "hackerrank",
+        "interview_preparation_kit",
+        "greedy_algorithms",
+        "greedy_florist.testcases.json");
+    this.testCases = JsonLoader.loadJson(path, GreedyFloristTestCase.class);
+  }
+
+  @Test
+  void testLuckBalance() {
+    for (GreedyFloristTestCase test : testCases) {
+      int[] inputArray = test.c.stream().mapToInt(Integer::intValue).toArray();
+      Integer result = GreedyFlorist.getMinimumCost(test.k, inputArray);
+
+      assertEquals(test.expected, result,
+          "%s(%s) => must be: %d".formatted(
+              "GreedyFlorist.getMinimumCost",
+              test.c.toString(),
+              test.expected));
+    }
+  }
+}

algorithm-exercises-java/src/test/resources/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.testcases.json

@@ -0,0 +1,20 @@
+[
+  {
+    "title": "Sample Test case 0",
+    "k": 3,
+    "c": [2, 5, 6],
+    "expected": 13
+  },
+  {
+    "title": "Sample Test case 1",
+    "k": 2,
+    "c": [2, 5, 6],
+    "expected": 15
+  },
+  {
+    "title": "Sample Test case 2",
+    "k": 3,
+    "c": [1, 3, 5, 7, 9],
+    "expected": 29
+  }
+]

docs/hackerrank/interview_preparation_kit/greedy_algorithms/greedy-florist-solution-notes.md

@@ -0,0 +1,48 @@
+# [Greedy Algorithms: Greedy Florist](https://www.hackerrank.com/challenges/greedy-florist)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingBasic`
+
+## About the problem statement
+
+At first it seems a bit confusing. Due the problem statement tends to
+make us believe that the most convenient thing is to start with the highest
+numbers, but the examples doesn't not present a logical descending order.
+
+## Way of thinking
+
+After rereading the problem several times it can be determined that:
+
+- It does not matter who the buyers are, nor in what order they buy,
+nor how much each one buys.
+The important thing is how many people are organized
+into a group to minimize the purchase price.
+
+- If the number of people in the group is greater than or equal to
+the number of different flowers, then the price is the lowest possible,
+because they can all be purchased "in a single pass",
+making each person in the group (or less) buy 1 unit.
+
+- The price of flowers does matter, therefore it is more convenient to buy
+the most expensive ones first.
+Each "round" of purchasing makes the flowers more expensive,
+therefore it is better to buy the cheapest ones in the last "round."
+
+## Deductions
+
+- It seems convenient to sort the flower price list entry in descending order
+(or in ascending order, traversing the new sorted list in reverse).
+
+- The number of passes depends on how many "groups" of "k - people"
+fit in the list of flowers, that is:
+$ \textbf{\#(c) / k}$ (integer division)
+
+- At first I assumed that the order in which the traversal is done in
+the examples was a suggestion of the criteria in which the list of flowers
+should be traversed to reach the solution.
+
+    Finally, realizing that the price calculation in descending order
+    (and "the round" in which the purchase is made)
+    and the example were equivalent, made me consider the idea that the order of
+    the examples might just be a distractor,
+    introduced on purpose to make deducing the solution a little more difficult.

docs/hackerrank/interview_preparation_kit/greedy_algorithms/greedy-florist.md

@@ -0,0 +1,135 @@
+# [Greedy Algorithms: Greedy Florist](https://www.hackerrank.com/challenges/greedy-florist)
+
+- Difficulty:  `#medium`
+- Category: `#ProblemSolvingBasic`
+
+A group of friends want to buy a bouquet of flowers.
+The florist wants to maximize his number of new customers and the money he makes.
+To do this, he decides he'll multiply the price of each flower by the number
+of that customer's previously purchased flowers plus `1`.
+The first flower will be original price, $(0 + 1) \times \text{original price}$,
+the next will be $(1 + 1) \times \text{original price}$ and so on.
+
+Given the size of the group of friends, the number of flowers they want
+to purchase and the original prices of the flowers, determine the minimum cost
+to purchase all of the flowers.
+The number of flowers they want equals the length of the  array.
+
+## Example
+
+`c = [1, 2, 3, 4]`
+`k = 3`
+
+The length of `c = 4`, so they want to buy `4`  flowers total.
+Each will buy one of the flowers priced `[2, 3, 4]` at the original price.
+Having each purchased `x = 1` flower,
+the first flower in the list, `c[0]`, will now cost
+$ (
+    \textsf{\textbf{current purchase}}
+        +
+    \textsf{\textbf{previous purchase}}
+) \times
+\textsf{\textbf{c[0]}} $.
+The total cost is `2 + 3 + 4 + 2 = 11`.
+
+## Function Description
+
+Complete the getMinimumCost function in the editor below.
+
+getMinimumCost has the following parameter(s):
+
+- `int c[n]`: the original price of each flower
+- `int k`: the number of friends
+
+## Returns
+
+- `int`: the minimum cost to purchase all flowers
+
+## Input Format
+
+The first line contains two space-separated integers `n` and `k`,
+the number of flowers and the number of friends.
+The second line contains `n` space-separated positive integers `c[i]`,
+the original price of each flower.
+
+## Constraints
+
+- $ 1 \leq n, k \leq 100 $
+- $ 1 \leq c[i] \leq 10^5 $
+- $ answer < 2^31 $
+- $ 0 \leq i \leq n $
+
+## Sample Input 0
+
+```text
+3 3
+2 5 6
+```
+
+## Sample Output 0
+
+```text
+13
+```
+
+## Explanation 0
+
+There are `n = 3` flowers with costs `c = [2, 5, ,6]` and `k = 3` people in the group.
+If each person buys one flower,
+the total cost of prices paid is `2 + 5 + 6 = 13` dollars.
+Thus, we print `13` as our answer.
+
+## Sample Input 1
+
+```text
+3 2
+2 5 6
+```
+
+## Sample Output 1
+
+```text
+15
+```
+
+## Explanation 1
+
+There are `n = 3` flowers with costs `c = [2, 5, 6]` and `k = 2`
+people in the group.
+We can minimize the total purchase cost like so:
+
+1. The first person purchases 2 flowers in order of decreasing price;
+this means they buy the more expensive flower ($ c_1 = 5 $) first at price
+$
+    p_1 = (0 + 1) \times 5 = 5
+$
+dollars and the less expensive flower ($ c_0 = 5 $) second at price
+$
+    p_0 = (1 + 1) \times 2 = 4
+$
+ dollars.
+2. The second person buys the most expensive flower at price
+$
+    p_2 = (0 + 1) \times 6 = 6
+$
+dollars.
+
+We then print the sum of these purchases, which is `5 + 4 + 6 = 15`, as our answer.
+
+## Sample Input 2
+
+```text
+5 3
+1 3 5 7 9
+```
+
+## Sample Output 2
+
+```text
+29
+```
+
+## Explanation 2
+
+The friends buy flowers for `9, 7`,  and `3, 5`,  and `1` for a cost of
+`9 + 7 + 3 * (1 + 1) + 5 + 1 * (1 + 1) = 29`.