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

Author: Debashis08

include/0005_DynamicProgramming/0012_CountWaysToReachNthStairExcludeOrder.h

@@ -0,0 +1,44 @@
+#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 reach the top. The person can climb either 1 stair or 2 stairs at a time. Count the number of ways, the person can reach the top (order does not matter).
+
+Note: The problem is similar to Climbing Stairs - Count ways to reach Nth stair with the only difference that in this problem, we don't have to count those ways which only differ in ordering of the steps.
+
+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 climb 2 stairs: {1, 1} and {2}.
+
+Input: n = 4
+Output: 3
+Explanation: Three ways to reach 4th stair: {1, 1, 1, 1}, {1, 1, 2} and {2, 2}.
+
+Input: n = 5
+Output: 3
+Explanation: Three ways to reach 5th stair: {1, 1, 1, 1, 1}, {1, 1, 1, 2} and {1, 2, 2}.
+*/
+
+namespace CountWaysToReachNthStairExcludeOrder
+{
+	class DynamicProgramming
+	{
+	private:
+		int RecursiveCountWaysToReachNthStairExcludeOrderHelper(int n);
+	public:
+		int RecursiveCountWaysToReachNthStairExcludeOrder(int n);
+		int DpCountWaysToReachNthStairExcludeOrder(int n);
+	};
+}

source/0005_DynamicProgramming/0012_CountWaysToReachNthStairExcludeOrder.cc

@@ -0,0 +1,53 @@
+#include "../../include/0005_DynamicProgramming/0012_CountWaysToReachNthStairExcludeOrder.h"
+
+namespace CountWaysToReachNthStairExcludeOrder
+{
+	// notes:
+	/*
+	To avoid counting ways which only differ in order, we can assume that a person initially takes only steps of size 1 followed by steps of size 2.
+	In other words, once a person takes a step of size 2, he will continue taking steps of size 2 till he reaches the nth stair.
+		A person can reach nth stair from either(n - 1)th stair or from(n - 2)th stair.So, there are two cases :
+	The person has reached nth step from(n - 1)th step, this means that the last step was of size 1 and all the previous steps should also be of size 1. So, there is only 1 way.
+		The person has reached nth step from(n - 2)th step, this means that the last step was of size 2 and the previous steps can either be of size 1 or size 2.
+		Therefore the Recurrence relation will be :
+
+	nthStair(n) = 1 (last step was of size 1) + nthStair(n - 2) (last step was of size 2)
+	so f(n) = 1 + f(n - 2)
+	*/
+
+	// Dynamic Programming Private Member Methods.
+	int DynamicProgramming::RecursiveCountWaysToReachNthStairExcludeOrderHelper(int n)
+	{
+		if (n < 0)
+		{
+			return 0;
+		}
+		if (n == 0)
+		{
+			return 1;
+		}
+
+		return 1 + this->RecursiveCountWaysToReachNthStairExcludeOrderHelper(n - 2);
+	}
+
+	// Dynamic Programming Public Member Methods.
+	int DynamicProgramming::RecursiveCountWaysToReachNthStairExcludeOrder(int n)
+	{
+		return this->RecursiveCountWaysToReachNthStairExcludeOrderHelper(n);
+	}
+
+	int DynamicProgramming::DpCountWaysToReachNthStairExcludeOrder(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] = 1 + dp[i - 2];
+		}
+		return dp[n];
+	}
+}

source/0005_DynamicProgramming/CMakeLists.txt

@@ -11,6 +11,7 @@ set(0005DYNAMICPROGRAMMING_SOURCES
     0009_FriendsPairingProblem.cc
     0010_WaysToCoverDistance.cc
     0011_CountWaysToReachNthStairIncludeOrder.cc
+    0012_CountWaysToReachNthStairExcludeOrder.cc
 
 )
 

test/0005_DynamicProgramming/0012_CountWaysToReachNthStairExcludeOrderTest.cc

@@ -0,0 +1,33 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0012_CountWaysToReachNthStairExcludeOrder.h"
+
+namespace CountWaysToReachNthStairExcludeOrder
+{
+	TEST(CountWaysToReachNthStairExcludeOrderTest, RecursiveCountWaysToReachNthStairExcludeOrder1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedNumberOfWays = 3;
+
+		// Act
+		int actualNumberOfWays = dp.RecursiveCountWaysToReachNthStairExcludeOrder(n);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWays, actualNumberOfWays);
+	}
+
+	TEST(CountWaysToReachNthStairExcludeOrderTest, DpCountWaysToReachNthStairExcludeOrder1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedNumberOfWays = 3;
+
+		// Act
+		int actualNumberOfWays = dp.DpCountWaysToReachNthStairExcludeOrder(n);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWays, actualNumberOfWays);
+	}
+}

test/0005_DynamicProgramming/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(
   0009_FriendsPairingProblemTest.cc
   0010_WaysToCoverDistanceTest.cc
   0011_CountWaysToReachNthStairIncludeOrderTest.cc
+  0012_CountWaysToReachNthStairExcludeOrderTest.cc
 
 )