digit counter and ring buffer

Author: justcoding121

Advanced.Algorithms.Tests/Advanced.Algorithms.Tests.csproj

@@ -123,6 +123,7 @@
     <Compile Include="DataStructures\Lists\ArrayList_Tests.cs" />
     <Compile Include="DataStructures\Lists\SkipList_Tests.cs" />
     <Compile Include="DataStructures\Queues\PriorityQueue\MaxPriorityQueue_Tests.cs" />
+    <Compile Include="DataStructures\Queues\CircularQueue_Tests.cs" />
     <Compile Include="DataStructures\Queues\Queue_Tests.cs" />
     <Compile Include="DataStructures\Set\BloomFilter_Tests.cs" />
     <Compile Include="DataStructures\Set\DisJointSet_Tests.cs" />
@@ -149,6 +150,7 @@
     <Compile Include="DataStructures\Tree\TestHelpers\BinarySearchTreeTester.cs" />
     <Compile Include="DataStructures\Tree\Tree_Tests.cs" />
     <Compile Include="DataStructures\Tree\BinaryTree_Tests.cs" />
+    <Compile Include="DynamicProgramming\Count\DigitCounter_Tests.cs" />
     <Compile Include="Geometry\PointRotation_Tests.cs" />
     <Compile Include="Miscellaneous\CountInversions_Tests.cs" />
     <Compile Include="Miscellaneous\MatrixMultiplication_Tests.cs" />

Advanced.Algorithms.Tests/DataStructures/Queues/CircularQueue_Tests.cs

@@ -0,0 +1,62 @@
+using Advanced.Algorithms.DataStructures;
+using Advanced.Algorithms.DataStructures.Queues;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Advanced.Algorithms.Tests.DataStructures.Queues
+{
+    [TestClass]
+    public class CircularQueue_Tests
+    {
+
+        [TestMethod]
+        public void CircularQueue_Test()
+        {
+            var Queue = new CircularQueue<int>(7);
+
+            Queue.Enqueue(1);
+            Queue.Enqueue(2);
+
+            Queue.Enqueue(3);
+            Queue.Enqueue(4);
+            Queue.Enqueue(5);
+            Queue.Enqueue(6);
+            Queue.Enqueue(7);
+            Queue.Enqueue(8);
+            Queue.Enqueue(9);
+
+            Assert.AreEqual(Queue.Count, 7);
+            Assert.AreEqual(3, Queue.Dequeue());
+
+            Assert.AreEqual(Queue.Count, 6);
+            Assert.AreEqual(Queue.Dequeue(), 4);
+
+            Assert.AreEqual(Queue.Count, 5);
+            Assert.AreEqual(Queue.Dequeue(), 5);
+
+            Assert.AreEqual(Queue.Count, 4);
+            Assert.AreEqual(Queue.Dequeue(), 6);
+
+            Assert.AreEqual(Queue.Count, 3);
+            Assert.AreEqual(Queue.Dequeue(), 7);
+
+            Assert.AreEqual(Queue.Count, 2);
+            Assert.AreEqual(Queue.Dequeue(), 8);
+
+            Assert.AreEqual(Queue.Count, 1);
+            Assert.AreEqual(Queue.Dequeue(), 9);
+
+            Assert.AreEqual(Queue.Count, 0);
+
+            Queue.Enqueue(1);
+            Queue.Enqueue(2);
+
+            Assert.AreEqual(Queue.Count, 2);
+            Assert.AreEqual(1, Queue.Dequeue());
+
+            Assert.AreEqual(Queue.Count, 1);
+            Assert.AreEqual(Queue.Dequeue(), 2);
+        }
+
+ 
+    }
+}

Advanced.Algorithms.Tests/DynamicProgramming/Count/DigitCounter_Tests.cs

@@ -0,0 +1,32 @@
+using Advanced.Algorithms.DynamicProgramming.Count;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Advanced.Algorithms.Tests.DynamicProgramming.Count
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [TestClass]
+    public class DigitCounter_Tests
+    {
+        [TestMethod]
+        public void DigitCount_Smoke_Test()
+        {
+            Assert.AreEqual(0, DigitCounter.Count(5, 9));
+            Assert.AreEqual(1, DigitCounter.Count(9, 9));
+
+            Assert.AreEqual(9, DigitCounter.Count(25, 2));
+            Assert.AreEqual(3, DigitCounter.Count(26, 6));
+            Assert.AreEqual(4, DigitCounter.Count(30, 3));
+
+            Assert.AreEqual(280, DigitCounter.Count(898, 6));
+
+            Assert.AreEqual(910116681, DigitCounter.Count(1015242410, 6));
+        }
+    }
+}

Advanced.Algorithms/DataStructures/Queues/CircularQueue.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Advanced.Algorithms.DataStructures.Queues
+{
+    /// <summary>
+    /// Cicular queue aka Ring Buffer using fixed size array
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class CircularQueue<T>
+    {
+        private T[] queue;
+
+        //points to the index of next element to be deleted
+        private int start = 0;
+
+        //points to the index new element should be inserted
+        private int end = 0;
+
+        public int Count { get; private set; }
+
+        public CircularQueue(int size)
+        {
+            queue = new T[size];
+        }
+
+        /// <summary>
+        /// Note: When buffer overflows oldest data will be erased
+        /// </summary>
+        /// <param name="data"></param>
+        public void Enqueue(T data)
+        {
+            //wrap around removing oldest element
+            if (end > queue.Length - 1)
+            {
+                end = 0;
+
+                if(start == 0)
+                {
+                    start++;
+                }
+            }
+
+            //when end meets start after wraping around
+            if (end == start && Count > 1)
+            {
+                start++;
+            }
+
+            queue[end] = data;
+            end++;
+
+            if (Count < queue.Length)
+            {
+                Count++;
+            }
+        }
+
+
+        public T Dequeue()
+        {
+            if (Count == 0)
+            {
+                throw new Exception("Empty queue.");
+            }
+
+            var element = queue[start];
+            start++;
+
+            //wrap around 
+            if (start > queue.Length - 1)
+            {
+                start = 0;
+
+                if (end == 0)
+                {
+                    end++;
+                }
+            }
+
+            Count--;
+
+            if (start == end && Count > 1)
+            {
+                end++;
+            }
+
+            //reset
+            if (Count == 0)
+            {
+                start = end = 0;
+            }
+
+            return element;
+        }
+    }
+}

Advanced.Algorithms/DynamicProgramming/Count/DigitCounter.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Advanced.Algorithms.DynamicProgramming.Count
+{
+    public class DigitCounter
+    {
+        /// <summary>
+        ///  Counts the appearences of given digit (0-9) in all numbers from 0 to given number
+        /// </summary>
+        /// <param name="number"></param>
+        /// <param name="digit"></param>
+        /// <returns></returns>
+        public static int Count(int number, int digit)
+        {
+            if(digit < 0 || digit > 9)
+            {
+                throw new ArgumentException("Invalid digit.");
+            }
+
+            if(number < 0)
+            {
+                throw new ArgumentException("Invalid number.");
+            }
+
+            if (number < 10)
+            {
+                if(digit == number)
+                {
+                    return 1;
+                }
+
+                return 0;
+            }
+
+            return Count(number, digit, new Dictionary<int, int>());
+        }
+        /// <summary>
+        /// Counts the appearences of given digit (0-9) in all numbers from 0 to number
+        /// </summary>
+        /// <param name="number"></param>
+        /// <param name="digit"></param>
+        public static int Count(int number, int digit, Dictionary<int, int> cache)
+        {
+            //comments below explains each step with the assumption number = 898
+            if (number < 10)
+            {
+                return 1;
+            }
+
+            if (cache.ContainsKey(number))
+            {
+                return cache[number];
+            }
+
+            //898 => 3
+            var digits = (int)Math.Log10(number) + 1;
+
+            //most significant 
+            //898 => 8
+            var msd = (int)(number / Math.Pow(10, digits - 1));
+
+            //898 => count(0-99) * 8
+            var result = Count((int)Math.Pow(10, digits - 1) - 1, digit, cache) * msd;
+
+            //(for 600 - 699)
+            //6 < 8
+            if (digit < msd)
+            {
+                //+100 (for 600 - 699)
+                result += (int)Math.Pow(10, digits - 1);
+            }
+
+            //898 => 98
+            var remaining = number - msd * (int)Math.Pow(10, digits - 1);
+
+            if(remaining > 0)
+            {
+               result += Count(remaining, digit, cache);
+            }
+          
+            //6 == 8?
+            // (for 800 - 898)
+            if (digit == msd)
+            {
+                //+98 (for 800 - 898)
+                //+1 for 800
+                result += remaining + 1;
+            }
+
+            cache.Add(number, result);
+
+            return result;
+        }
+    }
+}

README.md

@@ -41,6 +41,7 @@ Supports
 ### Queue
 
 - [X] Queue (using [Dynamic Array](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DataStructures/Queues/ArrayQueue.cs) and optionally using [Doubly Linked List](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DataStructures/Queues/LinkedListQueue.cs)) ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DataStructures/Queues/Queue.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DataStructures/Queues/Queue_Tests.cs))
+- [X] Circular Queue (Ring Buffer) ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DataStructures/Queues/CircularQueue.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DataStructures/Queues/CircularQueue_Tests.cs))
 
 #### Priority Queue
 
@@ -275,6 +276,7 @@ All are top down solutions with memoization technique.
 - [X] Count possible binary tree from a preorder sequence ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DynamicProgramming/Count/CountBinaryTree.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DynamicProgramming/Count/CountBinaryTree_Tests.cs))
 - [X] Ways to cover a distance ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DynamicProgramming/Count/WaysToCoverDistance.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DynamicProgramming/Count/WaysToCover_Tests.cs))
 - [X] Staircase problem in Fibornacci Series ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DynamicProgramming/Count/StairCaseProblem.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DynamicProgramming/Count/StairCaseProblem_Tests.cs))
+- [X] Count digits ([Implementation](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms/DynamicProgramming/Count/DigitCounter.cs) | [Tests](https://github.com/justcoding121/Advanced-Algorithms/tree/develop/Advanced.Algorithms.Tests/DynamicProgramming/Count/DigitCounter_Tests.cs))
 
 ### Maximizing