[Hacker Rank] Warm up: Plus Minus solved ✓

algorithm-exercises-java/src/main/java/ae/hackerrank/PlusMinus.java

@@ -0,0 +1,47 @@
+package ae.hackerrank;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Plus Minus.
+ *
+ * @link Problem definition [[docs/hackerrank/warmup/plus_minus.md]]
+ */
+public class PlusMinus {
+
+  private PlusMinus() {
+  }
+
+  static java.util.logging.Logger logger = util.CustomLogger.getLogger();
+
+  /**
+   * plusMinus.
+   */
+  public static String plusMinus(List<Integer> arr) {
+
+    int positives = 0;
+    int negatives = 0;
+    int zeros = 0;
+
+    for (int x : arr) {
+      if (x > 0) {
+        positives += 1;
+      }
+      if (x < 0) {
+        negatives += 1;
+      }
+      if (x == 0) {
+        zeros += 1;
+      }
+    }
+
+    List<String> result = new ArrayList<>();
+    result.add(String.format(Locale.ROOT, "%.6f", (double) positives / arr.size()));
+    result.add(String.format(Locale.ROOT, "%.6f", (double) negatives / arr.size()));
+    result.add(String.format(Locale.ROOT, "%.6f", (double) zeros / arr.size()));
+
+    return String.join("\n", result);
+  }
+}

algorithm-exercises-java/src/test/java/ae/hackerrank/PlusMinusTest.java

@@ -0,0 +1,48 @@
+package ae.hackerrank;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+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;
+
+@TestInstance(Lifecycle.PER_CLASS)
+class PlusMinusTest {
+
+  public class PlusMinusTestCase {
+    public List<Integer> input;
+    public String expected;
+
+    public PlusMinusTestCase(List<Integer> _input, String _expected) {
+      this.input = _input;
+      this.expected = _expected;
+    }
+  }
+
+  public List<PlusMinusTestCase> testCases;
+
+  @BeforeAll
+  public void setup() {
+    this.testCases = Arrays.asList(
+        new PlusMinusTestCase(
+            Arrays.asList(-4, 3, -9, 0, 4, 1),
+            String.join("\n", "0.500000", "0.333333", "0.166667")));
+  }
+
+  @Test
+  void testPlusMinus() {
+
+    for (PlusMinusTestCase testCase : this.testCases) {
+      String solutionFound = PlusMinus.plusMinus(testCase.input);
+
+      assertEquals(testCase.expected, solutionFound,
+          String.format("%s(%s) answer must be: %s",
+              "PlusMinus.plusMinus",
+              testCase.input.toString(),
+              testCase.expected.toString()));
+    }
+  }
+}

docs/hackerrank/warmup/plus_minus.md

@@ -0,0 +1,80 @@
+# [Plus Minus](https://www.hackerrank.com/challenges/plus-minus)
+
+Difficulty: #easy
+Category: #warmup
+
+Given an array of integers, calculate the ratios of its elements
+that are positive, negative, and zero. Print the decimal value of
+each fraction on a new line with 6 places after the decimal.
+
+**Note**: This challenge introduces precision problems.
+The test cases are scaled to six decimal places, though answers
+with absolute error of up to $ 10^{-4} $ are acceptable.
+
+## Example
+
+$ arr = [1, 1, 0, -1, -1] $
+
+There are $ n = 5 $ elements, two positive, two negative and one zero.
+Their ratios are $ 2/5 = 0.400000 $, $ 2/5 = 0.400000 $ and $ 1/5 = 0.200000 $.
+Results are printed as:
+
+```text
+0.400000
+0.400000
+0.200000
+```
+
+## Function Description
+
+Complete the plusMinus function in the editor below.
+plusMinus has the following parameter(s):
+
+- int arr[n]: an array of integers
+
+## Print
+
+Print the ratios of positive, negative and zero values in the array.
+Each value should be printed on a separate line with $ 6 $ digits after
+the decimal. The function should not return a value.
+
+## Input Format
+
+The first line contains an integer, `n`, the size of the array.
+The second line contains `n` space-separated integers that describe `arr[n]`.
+
+## Constraints
+
+$ 0 < n \leq 100 $ \
+$ -100 \leq arr[i] \leq 100 $
+
+## Output Format
+
+**Print** the following  lines, each to  decimals:
+
+1. proportion of positive values
+2. proportion of negative values
+3. proportion of zeros
+
+## Sample Input
+
+```text
+STDIN           Function
+-----           --------
+6               arr[] size n = 6
+-4 3 -9 0 4 1   arr = [-4, 3, -9, 0, 4, 1]
+```
+
+## Sample Output
+
+```text
+0.500000
+0.333333
+0.166667
+```
+
+## Explanation
+
+There are $ 3 $ positive numbers, negative numbers, and $ 1 $ zero in the array.
+The proportions of occurrence are positive: $ 3/6 = 0.500000 $,
+negative: $ 2/6 = 0.333333 $ and zeros: $ 1/6 = 0.166667 $.