feature: ways to cover sol added

Author: Debashis08

include/0005_DynamicProgramming/0010_WaysToCoverDistance.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+Given a distance 'dist', count total number of ways to cover the distance with 1, 2 and 3 steps.
+
+Examples:
+
+Input: n = 3
+Output: 4
+Explanation: Below are the four ways
+=> 1 step + 1 step + 1 step
+=> 1 step + 2 step
+=> 2 step + 1 step
+=> 3 step
+
+
+
+Input: n = 4
+Output: 7
+Explanation: Below are the four ways
+=> 1 step + 1 step + 1 step + 1 step
+=> 1 step + 2 step + 1 step
+=>  2 step + 1 step + 1 step
+=>  1 step + 1 step + 2 step
+=>  2 step + 2 step
+=>  3 step + 1 step
+=>  1 step + 3 step
+*/
+
+namespace WaysToCoverDistance
+{
+	class DynamicProgramming
+	{
+	private:
+		int WaysToCoverDistanceRecursiveHelper(int dist);
+	public:
+		int RecursiveWaysToCoverDistance(int dist);
+		int DpWaysToCoverDistance(int dist);
+	};
+}

source/0005_DynamicProgramming/0010_WaysToCoverDistance.cc

@@ -0,0 +1,52 @@
+#include "../../include/0005_DynamicProgramming/0010_WaysToCoverDistance.h"
+
+namespace WaysToCoverDistance
+{
+	// Dynamic Programming Private Member Methods.
+	int DynamicProgramming::WaysToCoverDistanceRecursiveHelper(int dist)
+	{
+		if (dist < 0)
+		{
+			return 0;
+		}
+
+		if (dist == 0)
+		{
+			return 1;
+		}
+		
+		int result = 0;
+		result += this->WaysToCoverDistanceRecursiveHelper(dist - 1);
+		result += this->WaysToCoverDistanceRecursiveHelper(dist - 2);
+		result += this->WaysToCoverDistanceRecursiveHelper(dist - 3);
+		
+		return result;
+	}
+
+	// Dynamic Programming Public Member Methods.
+	int DynamicProgramming::RecursiveWaysToCoverDistance(int dist)
+	{
+		return this->WaysToCoverDistanceRecursiveHelper(dist);
+	}
+
+	int DynamicProgramming::DpWaysToCoverDistance(int dist)
+	{
+		vector<int> dp(dist + 1, 0);
+		dp[0] = 1;
+		if (dist >= 1)
+		{
+			dp[1] = 1;
+		}
+		if (dist >= 2)
+		{
+			dp[2] = 2;
+		}
+
+		for(int i = 3; i <= dist; i++)
+		{
+			dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
+		}
+
+		return dp[dist];
+	}
+}

source/0005_DynamicProgramming/CMakeLists.txt

@@ -9,6 +9,8 @@ set(0005DYNAMICPROGRAMMING_SOURCES
     0007_DecodeWays.cc
     0008_TilingProblem.cc
     0009_FriendsPairingProblem.cc
+    0010_WaysToCoverDistance.cc
+
 )
 
 # Create a library target

test/0005_DynamicProgramming/0010_WaysToCoverDistanceTest.cc

@@ -0,0 +1,117 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0010_WaysToCoverDistance.h"
+
+namespace WaysToCoverDistance
+{
+	TEST(WaysToCoverDistanceTest, RecursiveWaysToCoverDistance1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 3;
+		int expectedNumberOfWaysToCoverDistance = 4;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.RecursiveWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, RecursiveWaysToCoverDistance2)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 4;
+		int expectedNumberOfWaysToCoverDistance = 7;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.RecursiveWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, RecursiveWaysToCoverDistanc3)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 5;
+		int expectedNumberOfWaysToCoverDistance = 13;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.RecursiveWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, RecursiveWaysToCoverDistanc4)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 6;
+		int expectedNumberOfWaysToCoverDistance = 24;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.RecursiveWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, DpWaysToCoverDistance1)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 3;
+		int expectedNumberOfWaysToCoverDistance = 4;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.DpWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, DpWaysToCoverDistance2)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 4;
+		int expectedNumberOfWaysToCoverDistance = 7;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.DpWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, DpWaysToCoverDistance3)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 5;
+		int expectedNumberOfWaysToCoverDistance = 13;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.DpWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+
+	TEST(WaysToCoverDistanceTest, DpWaysToCoverDistance4)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int distance = 6;
+		int expectedNumberOfWaysToCoverDistance = 24;
+
+		// Act
+		int actualNumberOfWaysToCoverDistance = dp.DpWaysToCoverDistance(distance);
+
+		// Assert
+		ASSERT_EQ(expectedNumberOfWaysToCoverDistance, actualNumberOfWaysToCoverDistance);
+	}
+}

test/0005_DynamicProgramming/CMakeLists.txt

@@ -23,6 +23,7 @@ add_executable(
   0007_DecodeWaysTest.cc
   0008_TilingProblemTest.cc
   0009_FriendsPairingProblemTest.cc
+  0010_WaysToCoverDistanceTest.cc
 
 )