feature: count ways to reach nth stair include order sol added

Author: Debashis08

include/0005_DynamicProgramming/0011_CountWaysToReachNthStairIncludeOrder.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+There are n stairs, and a person standing at the bottom wants to climb stairs to reach the top. 
+The person can climb either 1 stair or 2 stairs at a time, the task is to count the number of ways that a person can reach at the top.
+
+Note: This problem is similar to Count ways to reach Nth stair (Order does not matter) with the only difference that in this problem, 
+we count all distinct ways where different orderings of the steps are considered unique.
+
+Examples:
+
+Input: n = 1
+Output: 1
+Explanation: There is only one way to climb 1 stair.
+
+Input: n = 2
+Output: 2
+Explanation: There are two ways to reach 2th stair: {1, 1} and {2}.
+
+Input: n = 4
+Output: 5
+Explanation: There are five ways to reach 4th stair: {1, 1, 1, 1}, {1, 1, 2}, {2, 1, 1}, {1, 2, 1} and {2, 2}.
+*/
+
+namespace CountWaysToReachNthStairIncludeOrder
+{
+	class DynamicProgramming
+	{
+	private:
+		int RecursiveCountWaysToReachNthStairIncludeOrderHelper(int n);
+	public:
+		int RecursiveCountWaysToReachNthStairIncludeOrder(int n);
+		int DpCountWaysToReachNthStairIncludeOrder(int n);
+	};
+}

source/0005_DynamicProgramming/0011_CountWaysToReachNthStairIncludeOrder.cc

@@ -0,0 +1,44 @@
+#include "../../include/0005_DynamicProgramming/0011_CountWaysToReachNthStairIncludeOrder.h"
+
+namespace CountWaysToReachNthStairIncludeOrder
+{
+	// Dynamic Programming Private Member Methods.
+	int DynamicProgramming::RecursiveCountWaysToReachNthStairIncludeOrderHelper(int n)
+	{
+		if (n < 0)
+		{
+			return 0;
+		}
+		if (n == 0 || n == 1)
+		{
+			return 1;
+		}
+
+		int result = 0;
+		result += this->RecursiveCountWaysToReachNthStairIncludeOrderHelper(n - 1);
+		result += this->RecursiveCountWaysToReachNthStairIncludeOrderHelper(n - 2);
+
+		return result;
+	}
+
+	// Dynamic Programming Public Member Methods.
+	int DynamicProgramming::RecursiveCountWaysToReachNthStairIncludeOrder(int n)
+	{
+		return this->RecursiveCountWaysToReachNthStairIncludeOrderHelper(n);
+	}
+
+	int DynamicProgramming::DpCountWaysToReachNthStairIncludeOrder(int n)
+	{
+		vector<int> dp(n + 1, 0);
+		dp[0] = 1;
+		if (n >= 1)
+		{
+			dp[1] = 1;
+		}
+		for(int i = 2; i <= n; i++)
+		{
+			dp[i] = dp[i - 1] + dp[i - 2];
+		}
+		return dp[n];
+	}
+}

source/0005_DynamicProgramming/CMakeLists.txt

@@ -10,6 +10,7 @@ set(0005DYNAMICPROGRAMMING_SOURCES
     0008_TilingProblem.cc
     0009_FriendsPairingProblem.cc
     0010_WaysToCoverDistance.cc
+    0011_CountWaysToReachNthStairIncludeOrder.cc
 
 )
 

test/0005_DynamicProgramming/0011_CountWaysToReachNthStairIncludeOrderTest.cc

@@ -0,0 +1,33 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0011_CountWaysToReachNthStairIncludeOrder.h"
+
+namespace CountWaysToReachNthStairIncludeOrder
+{
+	TEST(CountWaysToReachNthStairIncludeOrderTest, RecursiveCountWaysToReachNthStairIncludeOrder1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedNumberOfWays = 5;
+
+		// Act
+		int actualNumberOfWays = dp.RecursiveCountWaysToReachNthStairIncludeOrder(n);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWays, actualNumberOfWays);
+	}
+
+	TEST(CountWaysToReachNthStairIncludeOrderTest, DpCountWaysToReachNthStairIncludeOrder1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedNumberOfWays = 5;
+
+		// Act
+		int actualNumberOfWays = dp.DpCountWaysToReachNthStairIncludeOrder(n);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWays, actualNumberOfWays);
+	}
+}

test/0005_DynamicProgramming/CMakeLists.txt

@@ -24,6 +24,7 @@ add_executable(
   0008_TilingProblemTest.cc
   0009_FriendsPairingProblemTest.cc
   0010_WaysToCoverDistanceTest.cc
+  0011_CountWaysToReachNthStairIncludeOrderTest.cc
 
 )