Add Automorphic Number Calculator (#344)

Author: Kalkwst

Algorithms.Tests/Numeric/AutomorphicNumberTests.cs

@@ -0,0 +1,114 @@
+using Algorithms.Numeric;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Algorithms.Tests.Numeric
+{
+    public class AutomorphicNumberTests
+    {
+        [TestCase(1)]
+        [TestCase(5)]
+        [TestCase(6)]
+        [TestCase(25)]
+        [TestCase(76)]
+        [TestCase(376)]
+        [TestCase(625)]
+        [TestCase(9376)]
+        [TestCase(90625)]
+        [TestCase(109376)]
+        
+        public void TestAutomorphicNumbers(int number)
+        {
+            Assert.That(AutomorphicNumber.IsAutomorphic(number), Is.True);
+        }
+
+        [TestCase(2)]
+        [TestCase(3)]
+        [TestCase(7)]
+        [TestCase(18)]
+        [TestCase(79)]
+        [TestCase(356)]
+        [TestCase(623)]
+        [TestCase(9876)]
+        [TestCase(90635)]
+        [TestCase(119376)]
+        [TestCase(891625)]
+        [TestCase(2990625)]
+        [TestCase(7209376)]
+        [TestCase(12891625)]
+        [TestCase(87129396)]
+        public void TestNonAutomorphicNumbers(int number)
+        {
+            Assert.That(AutomorphicNumber.IsAutomorphic(number), Is.False);
+        }
+
+        [TestCase(0)]
+        [TestCase(-1)]
+        public void TestInvalidAutomorphicNumbers(int number)
+        {
+            Assert.Throws(Is.TypeOf<ArgumentException>()
+                .And.Message.EqualTo($"An automorphic number must always be positive."),
+                delegate
+                {
+                    AutomorphicNumber.IsAutomorphic(number);
+                });
+        }
+
+        [TestCase(1, 100)]
+        public void TestAutomorphicNumberSequence(int lower, int upper)
+        {
+            List<long> automorphicList = new() { 1, 5, 6, 25, 76 };
+            Assert.That(AutomorphicNumber.GetAutomorphicNumbers(lower, upper), Is.EqualTo(automorphicList));
+        }
+
+        [TestCase(8, 12)]
+        public void TestNoAutomorphicNumberInTheSequence(int lower, int upper)
+        {
+            List<long> automorphicList = new();
+            Assert.That(AutomorphicNumber.GetAutomorphicNumbers(lower, upper), Is.EqualTo(automorphicList));
+        }
+
+        [TestCase(25,25)]
+        public void TestAutomorphicNumberSequenceSameBounds(int lower, int upper)
+        {
+            List<long> automorphicList = new() { 25 };
+            Assert.That(AutomorphicNumber.GetAutomorphicNumbers(lower, upper), Is.EqualTo(automorphicList));
+        }
+
+        [TestCase(-1,1)]
+        [TestCase(0, 1)]
+        public void TestAutomorphicNumberSequenceInvalidLowerBound(int lower, int upper)
+        {
+            Assert.Throws(Is.TypeOf<ArgumentException>()
+                .And.Message.EqualTo($"Lower bound must be greater than 0."),
+                delegate
+                {
+                    AutomorphicNumber.GetAutomorphicNumbers(lower, upper);
+                });
+        }
+
+        [TestCase(1, -1)]
+        [TestCase(10, -1)]
+        public void TestAutomorphicNumberSequenceInvalidUpperBound(int lower, int upper)
+        {
+            Assert.Throws(Is.TypeOf<ArgumentException>()
+                .And.Message.EqualTo($"Upper bound must be greater than 0."),
+                delegate
+                {
+                    AutomorphicNumber.GetAutomorphicNumbers(lower, upper);
+                });
+        }
+
+        [TestCase(25, 2)]
+        public void TestAutomorphicNumberSequenceReversedBounds(int lower, int upper)
+        {
+            Assert.Throws(Is.TypeOf<ArgumentException>()
+                .And.Message.EqualTo($"The lower bound must be less than or equal to the upper bound."),
+                delegate
+                {
+                    AutomorphicNumber.GetAutomorphicNumbers(lower, upper);
+                });
+        }
+    }
+}

Algorithms/Numeric/AutomorphicNumber.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace Algorithms.Numeric
+{
+    /// <summary>
+    /// Calculates Automorphic numbers. A number is said to be an Automorphic number
+    /// if the square of the number will contain the number itself at the end.
+    /// </summary>
+    public static class AutomorphicNumber
+    {
+        /// <summary>
+        /// Generates a list of automorphic numbers that are between <paramref name="lowerBound"/> and <paramref name="upperBound"/>
+        /// inclusive.
+        /// </summary>
+        /// <param name="lowerBound">The lower bound of the list.</param>
+        /// <param name="upperBound">The upper bound of the list.</param>
+        /// <returns>A list that contains all of the automorphic numbers between <paramref name="lowerBound"/> and <paramref name="upperBound"/> inclusive.</returns>
+        /// <exception cref="ArgumentException">If the <paramref name="lowerBound"/>
+        /// or <paramref name="upperBound"/> is not greater than zero
+        /// or <paramref name="upperBound"/>is lower than the <paramref name="lowerBound"/>.</exception>
+        public static IEnumerable<int> GetAutomorphicNumbers(int lowerBound, int upperBound)
+        {
+            if (lowerBound < 1)
+            {
+                throw new ArgumentException($"Lower bound must be greater than 0.");
+            }
+
+            if (upperBound < 1)
+            {
+                throw new ArgumentException($"Upper bound must be greater than 0.");
+            }
+
+            if (lowerBound > upperBound)
+            {
+                throw new ArgumentException($"The lower bound must be less than or equal to the upper bound.");
+            }
+
+            return Enumerable.Range(lowerBound, upperBound).Where(IsAutomorphic);
+        }
+
+        /// <summary>
+        /// Checks if a given natural number is automorphic or not.
+        /// </summary>
+        /// <param name="number">The number to check.</param>
+        /// <returns>True if the number is automorphic, false otherwise.</returns>
+        /// <exception cref="ArgumentException">If the number is non-positive.</exception>
+        public static bool IsAutomorphic(int number)
+        {
+            if (number < 1)
+            {
+                throw new ArgumentException($"An automorphic number must always be positive.");
+            }
+
+            BigInteger square = BigInteger.Pow(number, 2);
+
+            // Extract the last digits of both numbers
+            while (number > 0)
+            {
+                if (number % 10 != square % 10)
+                {
+                    return false;
+                }
+
+                number /= 10;
+                square /= 10;
+            }
+
+            return true;
+        }
+    }
+}

README.md

@@ -81,6 +81,7 @@ find more than one implementation for the same objective but using different alg
     * [Euler Method](./Algorithms/Numeric/EulerMethod.cs)
     * [Miller-Rabin primality check](./Algorithms/Numeric/MillerRabinPrimalityChecker.cs)
     * [KrishnamurthyNumberChecker](./Algorithms/Numeric/KrishnamurthyNumberChecker.cs)
+    * [Automorphic Number](./Algorithms/Numeric/AutomorphicNumber.cs)
   * [Searches](./Algorithms/Search)
     * [A-Star](./Algorithms/Search/AStar/)
     * [Binary Search](./Algorithms/Search/BinarySearcher.cs)