Add Aliquot Sum, Narcissistic Number (Armstrong Number), Perfect Square, and Perfect Number (#201)

Co-authored-by: Andrii Siriak <siryaka@gmail.com>

Author: simolab99

Algorithms.Tests/Numeric/AliquotTest.cs

@@ -0,0 +1,35 @@
+using System;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class AliquotTest
+    {
+        [Test]
+        [TestCase(1, 0)]
+        [TestCase(3, 1)]
+        [TestCase(25, 6)]
+        [TestCase(99, 57)]
+        public static void AliquotSumWork(int number, int expectedAS)
+        {
+            // Arrange
+
+            // Act
+            var result = Aliquot.AliquotSum(number);
+
+            // Assert
+            Assert.AreEqual(result, expectedAS);
+        }
+
+        [Test]
+        [TestCase(-2)]
+        public static void AliquotSumShouldThrowEx(int number)
+        {
+            // Arrange
+
+            // Assert
+            Assert.Throws<ArgumentException>(() => Aliquot.AliquotSum(number));
+        }
+    }
+}

Algorithms.Tests/Numeric/NarcissisticNumberTest.cs

@@ -0,0 +1,26 @@
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class NarcissisticNumberTest
+    {
+        [Test]
+        [TestCase(2, ExpectedResult = true)]
+        [TestCase(3, ExpectedResult = true)]
+        [TestCase(28, ExpectedResult = false)]
+        [TestCase(153, ExpectedResult = true)]
+        [TestCase(170, ExpectedResult = false)]
+        [TestCase(371, ExpectedResult = true)]
+        public static bool NarcissisticNumberWork(int number)
+        {
+            // Arrange
+
+            // Act
+            var result = NarcissisticNumber.IsNarcissistic(number);
+
+            // Assert
+            return result;
+        }
+    }
+}

Algorithms.Tests/Numeric/PerfectNumberTest.cs

@@ -0,0 +1,35 @@
+using System;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class PerfectNumberTests
+    {
+        [Test]
+        [TestCase(6)]
+        [TestCase(28)]
+        [TestCase(496)]
+        [TestCase(8128)]
+        public static void PerfectNumberWork(int number)
+        {
+            // Arrange
+
+            // Act
+            var result = PerfectNumber.IsPerfectNumber(number);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        [TestCase(-2)]
+        public static void PerfectNumberShouldThrowEx(int number)
+        {
+            // Arrange
+
+            // Assert
+            Assert.Throws<ArgumentException>(() => Aliquot.AliquotSum(number));
+        }
+    }
+}

Algorithms.Tests/Numeric/PerfectSquareTest.cs

@@ -0,0 +1,27 @@
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric
+{
+    public static class PerfectSquareTests
+    {
+        [Test]
+        [TestCase(-4, ExpectedResult = false)]
+        [TestCase(4, ExpectedResult = true)]
+        [TestCase(9, ExpectedResult = true)]
+        [TestCase(10, ExpectedResult = false)]
+        [TestCase(16, ExpectedResult = true)]
+        [TestCase(70, ExpectedResult = false)]
+        [TestCase(81, ExpectedResult = true)]
+        public static bool PerfectSquareWork(int number)
+        {
+            // Arrange
+
+            // Act
+            var result = PerfectSquare.IsPerfectSquare(number);
+
+            // Assert
+            return result;
+        }
+    }
+}

Algorithms/Numeric/Aliquot.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// In number theory, the aliquot sum s(n) of a positive integer n is the sum of all proper divisors
+    /// of n, that is, all divisors of n other than n itself. For example, the proper divisors of 15
+    /// (that is, the positive divisors of 15 that are not equal to 15) are 1, 3 and 5, so the aliquot
+    /// sum of 15 is 9 i.e. (1 + 3 + 5). Wikipedia: https://en.wikipedia.org/wiki/Aliquot_sum.
+    /// </summary>
+    public static class Aliquot
+    {
+        /// <summary>
+        /// Finds the aliquot sum of an integer number.
+        /// </summary>
+        /// <param name="number">Positive number.</param>
+        /// <returns>The Aliquot Sum.</returns>
+        /// <exception cref="ArgumentException">Error number is not on interval (0.0; int.MaxValue).</exception>
+        public static int AliquotSum(int number)
+        {
+            if (number < 0)
+            {
+                throw new ArgumentException($"{nameof(number)} cannot be negative");
+            }
+
+            int sum = 0;
+            for (int i = 1, limit = number / 2; i <= limit; ++i)
+            {
+                if (number % i == 0)
+                {
+                    sum += i;
+                }
+            }
+
+            return sum;
+        }
+    }
+}

Algorithms/Numeric/NarcissisticNumber.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// A Narcissistic number is equal to the sum of the cubes of its digits. For example, 370 is a
+    /// Narcissistic number because 3*3*3 + 7*7*7 + 0*0*0 = 370.
+    /// </summary>
+    public static class NarcissisticNumber
+    {
+        /// <summary>
+        /// Checks if a number is a Narcissistic number or not.
+        /// </summary>
+        /// <param name="number">Number to check.</param>
+        /// <returns>True if is a Narcissistic number; False otherwise.</returns>
+        public static bool IsNarcissistic(int number)
+        {
+            int sum = 0;
+            int temp = number;
+            int numberOfDigits = 0;
+            while (temp != 0)
+            {
+                numberOfDigits++;
+                temp /= 10;
+            }
+
+            temp = number;
+            while (number > 0)
+            {
+                int remainder = number % 10;
+                int power = (int)Math.Pow(remainder, numberOfDigits);
+
+                sum += power;
+                number /= 10;
+            }
+
+            return sum == temp;
+        }
+    }
+}

Algorithms/Numeric/PerfectNumber.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// In number theory, a perfect number is a positive integer that is equal to the sum of its positive
+    /// divisors, excluding the number itself.For instance, 6 has divisors 1, 2 and 3 (excluding
+    /// itself), and 1 + 2 + 3 = 6, so 6 is a perfect number.
+    /// </summary>
+    public static class PerfectNumber
+    {
+        /// <summary>
+        /// Checks if a number is a perfect number or not.
+        /// </summary>
+        /// <param name="number">Number to check.</param>
+        /// <returns>True if is a perfect number; False otherwise.</returns>
+        /// <exception cref="ArgumentException">Error number is not on interval (0.0; int.MaxValue).</exception>
+        public static bool IsPerfectNumber(int number)
+        {
+            if (number < 0)
+            {
+                throw new ArgumentException($"{nameof(number)} cannot be negative");
+            }
+
+            int sum = 0; /* sum of its positive divisors */
+            for (int i = 1; i < number; ++i)
+            {
+                if (number % i == 0)
+                {
+                    sum += i;
+                }
+            }
+
+            return sum == number;
+        }
+    }
+}

Algorithms/Numeric/PerfectSquare.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// A perfect square is an element of algebraic structure that is equal to the square of another element.
+    /// </summary>
+    public static class PerfectSquare
+    {
+        /// <summary>
+        /// Checks if a number is a perfect square or not.
+        /// </summary>
+        /// <param name="number">Number too check.</param>
+        /// <returns>True if is a perfect square; False otherwise.</returns>
+        public static bool IsPerfectSquare(int number)
+        {
+            if (number < 0)
+            {
+                return false;
+            }
+
+            int sqrt = (int)Math.Sqrt(number);
+            return sqrt * sqrt == number;
+        }
+    }
+}

DIRECTORY.md

@@ -23,6 +23,7 @@
     * Eigenvalue
       * [Poweriterationtests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/LinearAlgebra/Eigenvalue/PowerIterationTests.cs)
   * Numeric
+    * [Aliquottest](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/AliquotTest.cs)
     * [Binomialcoefficienttests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/BinomialCoefficientTests.cs)
     * Decomposition
       * [Lutests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/Decomposition/LUTests.cs)
@@ -35,6 +36,9 @@
     * Greatestcommondivisor
       * [Binarygreatestcommondivisorfindertests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinderTests.cs)
       * [Euclideangreatestcommondivisorfindertests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinderTests.cs)
+    * [Narcissisticnumbertest](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/NarcissisticNumberTest.cs)
+    * [Perfectnumbertest](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/PerfectNumberTest.cs)
+    * [Perfectsquaretest](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/PerfectSquareTest.cs)
     * Pseudoinverse
       * [Pseudoinversetests](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms.Tests/Numeric/PseudoInverse/PseudoInverseTests.cs)
   * Other
@@ -115,6 +119,7 @@
     * Eigenvalue
       * [Poweriteration](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/LinearAlgebra/Eigenvalue/PowerIteration.cs)
   * Numeric
+    * [Aliquot](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/Aliquot.cs)
     * [Binomialcoefficient](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/BinomialCoefficient.cs)
     * Decomposition
       * [Lu](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/Decomposition/LU.cs)
@@ -128,6 +133,9 @@
       * [Binarygreatestcommondivisorfinder](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/GreatestCommonDivisor/BinaryGreatestCommonDivisorFinder.cs)
       * [Euclideangreatestcommondivisorfinder](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/GreatestCommonDivisor/EuclideanGreatestCommonDivisorFinder.cs)
       * [Igreatestcommondivisorfinder](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/GreatestCommonDivisor/IGreatestCommonDivisorFinder.cs)
+    * [Narcissisticnumber](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/NarcissisticNumber.cs)
+    * [Perfectnumber](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/PerfectNumber.cs)
+    * [Perfectsquare](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/PerfectSquare.cs)
     * Pseudoinverse
       * [Pseudoinverse](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Numeric/Pseudoinverse/PseudoInverse.cs)
     * Series