Merge branch 'main' of https://github.com/manthan0227/PyAlgo-Tree

Author: manthan0227

Dynamic Programming/Bell Numbers/Images/bell1.png

@@ -0,0 +1,87 @@
+# Bell Numbers Problem using Dynamic Programming
+Language used : **Python 3**
+
+## 🎯 Aim
+The aim of this script is to find out the nth Bell numbers using Dynamic Programming method..
+
+## 👉 Purpose
+The main purpose of this script is to show the implementation of Dynamic Programming to find out nth Bell Numbers.
+
+## 📄 Description
+- **What is Bell Number ?** -- Let `S(n, k)` be total number of partitions of n elements into k sets. The value of n’th Bell Number is sum of `S(n, k)` for `k = 1 to n`. Value of `S(n, k)` can be defined recursively as, `S(n+1, k) = k*S(n, k) + S(n, k-1)`.
+- Given a set of n elements, find number of ways of partitioning it. 
+Examples: 
+```
+Input:  n = 2
+Output: Number of ways = 2
+Explanation: Let the set be {1, 2}
+            { {1}, {2} } 
+            { {1, 2} }
+```
+## 📈 Workflow of the script
+- `bellNumber` -- This is the working function which will check and return the nth bell numbers one after another using the Dynamic Programming method.
+- `main` - This is the driver program for this script.
+
+## 📃 Explanation
+When we add a (n+1)’th element to k partitions, there are two possibilities. 
+1) It is added as a single element set to existing partitions, i.e, S(n, k-1) 
+2) It is added to all sets of every partition, i.e., k*S(n, k)
+S(n, k) is called Stirling numbers of the second kind
+First few Bell numbers are 1, 1, 2, 5, 15, 52, 203, …. 
+A Simple Method to compute n’th Bell Number is to one by one compute S(n, k) for k = 1 to n and return sum of all computed values. Refer this for computation of S(n, k).
+A Better Method is to use Bell Triangle. Below is a sample Bell Triangle for first few Bell Numbers. 
+```
+1
+1 2
+2 3 5
+5 7 10 15
+15 20 27 37 52
+```
+
+## 🧮 Algorithm
+The triangle is constructed using below formula. 
+```
+// If this is first column of current row 'i'
+If j == 0
+   // Then copy last entry of previous row
+   // Note that i'th row has i entries
+   Bell(i, j) = Bell(i-1, i-1) 
+
+// If this is not first column of current row
+Else 
+   // Then this element is sum of previous element 
+   // in current row and the element just above the
+   // previous element
+   Bell(i, j) = Bell(i-1, j-1) + Bell(i, j-1)
+```
+
+**Interpretation :**
+Then Bell(n, k) counts the number of partitions of the set {1, 2, …, n + 1} in which the element k + 1 is the largest element that can be alone in its set.
+For example, Bell(3, 2) is 3, it is count of number of partitions of {1, 2, 3, 4} in which 3 is the largest singleton element. There are three such partitions:
+```
+    {1}, {2, 4}, {3}
+    {1, 4}, {2}, {3}
+    {1, 2, 4}, {3}. 
+```
+## 💻 Input and Output 
+- **Test Case 1 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Bell%20Numbers/Images/bell1.png)
+
+- **Test Case 2 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Bell%20Numbers/Images/bell2.png)
+
+- **Test Case 3 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Bell%20Numbers/Images/bell3.png)
+
+
+## ⏰ Time and Space complexity
+- **Time Complexity:** `O(n^2)`.
+
+---------------------------------------------------------------
+## 🖋️ Author
+**Code contributed by, _Abhishek Sharma_, 2021 [@abhisheks008](github.com/abhisheks008)**
+
+[![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

Dynamic Programming/Bell Numbers/Images/bell2.png

@@ -0,0 +1,65 @@
+# A Python program to find n'th Bell number
+# Approach : Dynamic Programming
+# Abhishek S, 2021
+
+# ----------------------------------------------------------
+
+# Problem statement : Given a set of n elements, find the 
+#                     number of ways of partitioning it.
+
+# ----------------------------------------------------------
+
+# Solution : Used the Dynamic Approach to solve the problem.
+
+# This is the working function which will check and return the
+# nth bell numbers one after another using the Dynamic Programming
+# method
+
+def bellNumber(n):
+ 
+    bell = [[0 for i in range(n+1)] for j in range(n+1)]
+    bell[0][0] = 1
+    for i in range(1, n+1):
+ 
+        # Explicitly fill for j = 0
+        bell[i][0] = bell[i-1][i-1]
+ 
+        # Fill for remaining values of j
+        for j in range(1, i+1):
+            bell[i][j] = bell[i-1][j-1] + bell[i][j-1]
+ 
+    return bell[n][0]
+ 
+# Driver program
+print ("- Bell Numbers using Dynamic Programming Approach -")
+print ("---------------------------------------------------")
+print ()
+z = int(input("Enter the number of numbers you wanna print : "))
+print ()
+print ("---------------------------------------------------")
+print ()
+print ("Output : ")
+print ()
+for n in range(z):
+    print('Bell Number', n, 'is', bellNumber(n))
+    
+    
+
+# ----------------------------------------------------------
+
+# Enter the number of numbers you wanna print : 6
+
+# ----------------------------------------------------------
+
+# Output : 
+
+# Bell Number 0 is 1
+# Bell Number 1 is 1
+# Bell Number 2 is 2
+# Bell Number 3 is 5
+# Bell Number 4 is 15
+# Bell Number 5 is 52
+
+# ----------------------------------------------------------
+
+# Code contributed by, Abhishek Sharma, 2021

Dynamic Programming/Bell Numbers/Images/bell3.png

@@ -0,0 +1,86 @@
+# Friends Pairing Problem using Dynamic Programming
+Language used : **Python 3**
+
+## 🎯 Aim
+The aim of this script is to find out the the total number of ways in which friends can remain single or can be paired up..
+
+## 👉 Purpose
+The main purpose of this script is to show the implementation of Dynamic Programming to find the total number of ways in which friends can remain single or can be paired up.
+
+## 📄 Description
+Given n friends, each one can remain single or can be paired up with some other friend. Each friend can be paired only once. **Find out the total number of ways in which friends can remain single or can be paired up.** 
+
+Examples: 
+```
+Input  : n = 3
+Output : 4
+
+Input : n = 4
+Output : 10
+
+Input : n = 6
+Output : 76
+```
+
+## 📈 Workflow of the script
+- `countFriendsPairing` - This is the main function which provides the number of ways friends can e single.
+- `main` - This is the driver code for this code/script.
+
+## 📃 Explanation
+```
+{1}, {2}, {3} : all single
+{1}, {2, 3} : 2 and 3 paired but 1 is single.
+{1, 2}, {3} : 1 and 2 are paired but 3 is single.
+{1, 3}, {2} : 1 and 3 are paired but 2 is single.
+Note that {1, 2} and {2, 1} are considered same.
+```
+- **Mathematical Explanation**
+```
+The problem is simplified version of how many ways we can divide n elements into multiple groups.
+(here group size will be max of 2 elements).
+In case of n = 3, we have only 2 ways to make a group: 
+    1) all elements are individual(1,1,1)
+    2) a pair and individual (2,1)
+In case of n = 4, we have 3 ways to form a group:
+    1) all elements are individual (1,1,1,1)
+    2) 2 individuals and one pair (2,1,1)
+    3) 2 separate pairs (2,2)
+```
+
+## 🧮 Algorithm
+```
+f(n) = ways n people can remain single 
+       or pair up.
+
+For n-th person there are two choices:
+1) n-th person remains single, we recur 
+   for f(n - 1)
+2) n-th person pairs up with any of the 
+   remaining n - 1 persons. We get (n - 1) * f(n - 2)
+
+Therefore we can recursively write f(n) as:
+f(n) = f(n - 1) + (n - 1) * f(n - 2)
+```
+
+## 💻 Input and Output 
+- **Test Case 1 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Friends%20Pairing%20Problem/Images/friend2.PNG)
+
+- **Test Case 2 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Friends%20Pairing%20Problem/Images/friend1.PNG)
+
+- **Test Case 3 :**
+
+![](https://github.com/abhisheks008/PyAlgo-Tree/blob/main/Dynamic%20Programming/Friends%20Pairing%20Problem/Images/friend3.PNG)
+
+## ⏰ Time and Space complexity
+- **Time Complexity:** `O(n)`. 
+- **Space Complexity:** `O(n)`. 
+
+---------------------------------------------------------------
+## 🖋️ Author
+**Code contributed by, _Abhishek Sharma_, 2021 [@abhisheks008](github.com/abhisheks008)**
+
+[![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

Dynamic Programming/Bell Numbers/README.md

@@ -0,0 +1,63 @@
+# Problem Statement : Given n friends, each one can 
+#                     remain single or can be paired up
+#                     with some other friend. Each friend
+#                     can be paired only once. Find out the
+#                     total number of ways in which friends
+#                     can remain single or can be paired up.
+
+# -----------------------------------------------------------------
+
+# Method : Dynamic Programming
+# Abhishek Sharma. 2021
+
+# -----------------------------------------------------------------
+
+# Python program solution of friends pairing problem
+ 
+# Returns count of ways n people can remain single or paired up.
+
+# -----------------------------------------------------------------
+
+# This is the main function which provides the number of ways
+# friends can e single.
+
+def countFriendsPairings(n):
+ 
+    dp = [0 for i in range(n + 1)]
+ 
+    # Filling dp[] in bottom-up manner using
+    # recursive formula explained above.
+    
+    for i in range(n + 1):
+ 
+        if(i <= 2):
+            dp[i] = i
+        else:
+            dp[i] = dp[i - 1] + (i - 1) * dp[i - 2]
+ 
+    return dp[n]
+ 
+# Driver code
+
+print ("- Friends Pairing Problem using Dynamic Programming - ")
+print ("------------------------------------------------------")
+n = int(input("Enter the number : "))
+print ("------------------------------------------------------")
+print ()
+print ("Output :")
+print("Number of ways people can remain single or, paired up : ",countFriendsPairings(n))
+
+
+# -----------------------------------------------------------------   
+# Input given :
+# - Friends Pairing Problem using Dynamic Programming - 
+# ------------------------------------------------------
+# Enter the number : 3
+# ------------------------------------------------------
+
+# Output :
+# Number of ways people can remain single or, paired up :  4
+
+# ------------------------------------------------------
+
+# Code contributed by, Abhishek Sharma, 2021