Factorial and combinations. (#103)

* new numeric algorithms with new tests.

* mod on binomial

* included suggestions.

* Update Algorithms/Numeric/Factorial.cs

Co-Authored-By: Andrii Siriak <siryaka@gmail.com>

Author: 1fisedi

Algorithms.Tests/Numeric/BinomialCoefficientTests.cs

@@ -0,0 +1,34 @@
+using System;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class BinomialCoefficientTests
+    {
+        [TestCase(4, 2, 6)]
+        [TestCase(7, 3, 35)]
+        public static void CalculateFromPairs(int n, int k, long expected)
+        {
+            // Arrange
+
+            // Act
+            var result = BinomialCoefficient.Calculate(n, k);
+
+            // Assert
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        [TestCase(3, 7)]
+        public static void TeoremCalculateThrowsException(int n, int k)
+        {
+            // Arrange
+
+            // Act
+
+            // Assert
+            _ = Assert.Throws<ArgumentException>(() => BinomialCoefficient.Calculate(n, k));
+        }
+    }
+}

Algorithms.Tests/Numeric/FactorialTests.cs

@@ -0,0 +1,40 @@
+using System;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class FactorialTests
+    {
+        [Test]
+        [TestCase(5, 120)]
+        [TestCase(1, 1)]
+        [TestCase(0, 1)]
+        [TestCase(4, 24)]
+        [TestCase(18, 6402373705728000)]
+        [TestCase(10, 3628800)]
+        public static void GetsFactorial(int input, long expected)
+        {
+            // Arrange
+
+            // Act
+            var result = Factorial.Calculate(input);
+
+            // Assert
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        public static void GetsFactorialExceptionForNonPositiveNumbers([Random(-1000, -1, 10, Distinct = true)]int input)
+        {
+            // Arrange
+
+            // Act
+            void Act() => Factorial.Calculate(input);
+
+            // Assert
+
+            _ = Assert.Throws<ArgumentException>(Act);
+        }
+    }
+}

Algorithms/Numeric/BinomialCoefficient.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// The binomial coefficients are the positive integers
+    /// that occur as coefficients in the binomial theorem.
+    /// </summary>
+    public static class BinomialCoefficient
+    {
+        /// <summary>
+        /// Calculates Binomial coefficients for given input.
+        /// </summary>
+        /// <param name="num">First number.</param>
+        /// <param name="k">Second number.</param>
+        /// <returns>Binimial Coefficients.</returns>
+        public static long Calculate(int num, int k)
+        {
+            if (num < k || k < 0)
+            {
+                throw new ArgumentException("n ≥ k ≥ 0");
+            }
+
+            return Factorial.Calculate(num) / (Factorial.Calculate(k) * Factorial.Calculate(num - k));
+        }
+    }
+}

Algorithms/Numeric/Factorial.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// The factorial of a positive integer n, denoted by n!,
+    /// is the product of all positive integers less than or equal to n.
+    /// </summary>
+    public static class Factorial
+    {
+        /// <summary>
+        /// Calculates factorial of a number.
+        /// </summary>
+        /// <param name="num">Input number.</param>
+        /// <returns>Factorial of input number.</returns>
+        public static long Calculate(int num)
+        {
+            if (num < 0)
+            {
+                throw new ArgumentException("Only for num >= 0");
+            }
+
+            return num == 0 ? 1 : num * Calculate(num - 1);
+        }
+    }
+}