Merge pull request #43 from sir-gon/feature/plus_minus

[Hacker Rank]: Plus Minus solved ✓

Author: sir-gon

algorithm-exercises-csharp-test/src/hackerrank/warmup/PlusMinus.Test.cs

@@ -0,0 +1,17 @@
+namespace algorithm_exercises_csharp.hackerrank;
+
+[TestClass]
+public class PlusMinusTest
+{
+  [TestMethod]
+  public void testPlusMinus()
+  {
+    List<int> a = [-4, 3, -9, 0, 4, 1];
+    string expectedAnswer = String.Join("\n", "0.500000", "0.333333", "0.166667");
+    string result = PlusMinus.plusMinus(a);
+
+    Assert.AreEqual(expectedAnswer, result);
+
+  }
+}
+

algorithm-exercises-csharp/src/hackerrank/warmup/PlusMinus.cs

@@ -0,0 +1,45 @@
+// @link Problem definition [[docs/hackerrank/warmup/plus_minus.md]]
+
+namespace algorithm_exercises_csharp.hackerrank;
+
+using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
+
+public class PlusMinus
+{
+  [ExcludeFromCodeCoverage]
+  protected PlusMinus() { }
+
+  public static string plusMinus(List<int> arr)
+  {
+    int positives = 0;
+    int negatives = 0;
+    int zeros = 0;
+
+    foreach (int value in arr)
+    {
+      if (value > 0)
+      {
+        positives += 1;
+      }
+      if (value < 0)
+      {
+        negatives += 1;
+      }
+      if (value == 0)
+      {
+        zeros += 1;
+      }
+    }
+
+
+    List<string> result = [];
+    var nfi = new NumberFormatInfo() { NumberDecimalSeparator = "." };
+
+    result.Add(String.Format(nfi, "{0:F6}", (double)positives / arr.Count));
+    result.Add(String.Format(nfi, "{0:F6}", (double)negatives / arr.Count));
+    result.Add(String.Format(nfi, "{0:F6}", (double)zeros / arr.Count));
+
+    return String.Join("\n", result);
+  }
+}

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