Merge pull request #399 from amritansh22/revert-392-master

Revert "Added Unbounded Knapsack in C++"

Author: amritansh22

.DS_Store

@@ -0,0 +1,19 @@
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thanks for opening your first issue here! 
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thanks for opening this pull request! Please be sure that you have checked out our contributing guidelines.
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+
+# Comment to be posted to on pull requests merged by a first time user
+firstPRMergeComment: >
+  Congrats on merging your first pull request! We are proud of you!
+
+# It is recommend to include as many gifs and emojis as possible

.github/config.yml

@@ -0,0 +1,44 @@
+//Question: - You are given weights and values of N items,
+//put these items in a knapsack of capacity W to get the maximum total value in the knapsack. 
+//Note that we have only one quantity of each item.
+
+//Dynamic Programming - 0/1 Knapsack
+
+#include <iostream>
+#include<bits/stdc++.h>
+using namespace std;
+
+
+int main() {
+	
+	int t;
+	cin>>t;
+	while(t--)
+	{
+	    int n;
+	    cin>>n;
+	    int w;
+	    cin>>w;
+	    int val[n],wt[n],i,j;
+	    for(i=0;i<n;i++)
+	        cin>>val[i];
+	     for(i=0;i<n;i++)
+	        cin>>wt[i];
+	   int dp[n+1][w+1];
+	  
+	  for(i=0;i<=n;i++)
+	    for(j=0;j<=w;j++)
+	       { if(i==0||j==0)
+	            dp[i][j]=0;
+	       else
+	        {if(wt[i-1]>j)
+	            dp[i][j]=dp[i-1][j];
+	        else
+	            dp[i][j]=max(val[i-1]+dp[i-1][j-wt[i-1]],dp[i-1][j]);
+	        }
+	       }
+	   
+	   cout<<dp[n][w]<<endl;
+	}
+	return 0;
+}

0-1 Knapsack

@@ -0,0 +1,43 @@
+#include<bits/stdc++.h>
+#define M 1001
+using namespace std;
+
+int t[M][M];
+
+int Count_Subset_Sum(vector<int> &arr, int sum, int n)
+{
+	//Initialization
+	for(int i=0; i<M; i++)
+	{
+		t[0][i] = 0;
+		t[i][0] = 1;
+	}
+	//Choice Diagram
+	for(int i=1; i<n+1; i++)
+	{
+		for(int j=1; j<sum+1; j++)
+		{
+			if(arr[i-1]<=j)
+				t[i][j] = t[i-1][j] + t[i-1][j-arr[i-1]];
+			else
+				t[i][j] = t[i-1][j];
+		}
+	}
+	return t[n][sum];
+}
+
+int main()
+{
+	int n,diff;
+	cin>>n>>diff;
+	vector<int> arr(n);
+	for(int i=0; i<n; i++)
+		cin>>arr[i];
+	int arr_sum = 0;
+	for(int i=0; i<n; i++)
+		arr_sum += arr[i];
+	int sum = (diff+arr_sum)/2;
+	memset(t,0,sizeof(t));
+	cout<<Count_Subset_Sum(arr,sum,n);
+	return 0;
+}

494-Target_sum-Leetcode-DP.cpp

@@ -0,0 +1,60 @@
+
+#include <iostream> 
+using namespace std; 
+
+int lenghtOfLongestAP(int set[], int n) 
+{ 
+	if (n <= 2) return n; 
+
+	int L[n][n]; 
+	int llap = 2; // Initialize the result 
+
+	for (int i = 0; i < n; i++) 
+		L[i][n-1] = 2; 
+
+	for (int j=n-2; j>=1; j--) 
+	{ 
+		int i = j-1, k = j+1; 
+		while (i >= 0 && k <= n-1) 
+		{ 
+		if (set[i] + set[k] < 2*set[j]) 
+			k++; 
+
+		else if (set[i] + set[k] > 2*set[j]) 
+		{ L[i][j] = 2, i--; } 
+
+		else
+		{ 
+			L[i][j] = L[j][k] + 1; 
+
+			llap = max(llap, L[i][j]); 
+
+			i--; k++; 
+		} 
+		} 
+
+		while (i >= 0) 
+		{ 
+			L[i][j] = 2; 
+			i--; 
+		} 
+	} 
+	return llap; 
+} 
+
+int main() 
+{ 
+	int set1[] = {1, 7, 10, 13, 14, 19}; 
+	int n1 = sizeof(set1)/sizeof(set1[0]); 
+	cout << lenghtOfLongestAP(set1, n1) << endl; 
+
+	int set2[] = {1, 7, 10, 15, 27, 29}; 
+	int n2 = sizeof(set2)/sizeof(set2[0]); 
+	cout << lenghtOfLongestAP(set2, n2) << endl; 
+
+	int set3[] = {2, 4, 6, 8, 10}; 
+	int n3 = sizeof(set3)/sizeof(set3[0]); 
+	cout << lenghtOfLongestAP(set3, n3) << endl; 
+
+	return 0; 
+} 

Abhinav_LongestAP.cpp

@@ -0,0 +1,219 @@
+#include <iostream>
+#include <iomanip>
+using namespace std;
+
+const int size = 10;
+
+template <class T>
+class stacktype{
+	T s[size];
+	int top;
+public :
+	void push(T);
+	T pop();
+	int isempty();
+	int isfull();
+	void display();
+	T topmost();
+	void clear();
+	
+	stacktype()
+	{
+		top = -1;
+	}
+};
+
+template <class T>
+void stacktype<T>::push(T p)
+{
+	top++;
+	s[top] = p;
+}
+
+template <class T>
+T stacktype<T>::pop()
+{
+	int d;
+	d = s[top];
+	top--;
+	return d;
+}
+
+template <class T>
+int stacktype<T>::isempty()
+{
+	int e;
+	if(top == -1)
+	{
+		cout<<"\nStack is empty"<<endl;
+		return 1;
+	}
+	else
+	{
+		cout<<"\nStack is not empty"<<endl;
+		return 0;
+	}
+}
+
+template <class T>
+int stacktype<T>::isfull()
+{
+	int f;
+	if(top == size-1)
+	{
+		cout<<"\nStack is full"<<endl;
+		return 1;
+	}
+	else
+	{
+		cout<<"\nStack is not full"<<endl;
+		return 0;
+	}
+}
+
+template <class T>
+T stacktype<T>::topmost()
+{
+	return s[top];                   
+}
+
+template <class T>
+void stacktype<T>::clear()
+{
+	top = -1;          
+	display();
+}
+
+template <class T>
+void stacktype<T>::display()
+{
+	if(top == -1)
+	{
+		cout<<"\nStack is empty"<<endl;
+	}
+	else
+	{
+		cout<<"\nStack elements starting from top are - ";
+		for(int i=top;i>=0;i--)
+		{
+			cout<<setw(3)<<s[i];
+		}
+		cout<<endl;
+	}
+	
+}
+
+int main()
+{
+	stacktype<int> st;
+	char c = 'y';
+	int choice,f,p,d,e;
+	
+	while(c=='y'||c=='Y')
+	{
+		cout<<"MAIN MENU :"<<endl;
+		cout<<"From the following options which operation you want to perform on stack :"<<endl;
+		cout<<"1. PUSH onto the stack "<<endl;
+		cout<<"2. POP from the stack "<<endl;
+		cout<<"3. Check if stack is EMPTY "<<endl;
+		cout<<"4. Check if stack is FULL "<<endl;
+		cout<<"5. CLEAR the stack "<<endl;
+		cout<<"6. TOPMOST element of stack "<<endl;
+		cout<<"7. DISPLAY the stack "<<endl;
+		cout<<"Enter your Choice: ";
+		cin>>choice;
+		
+		switch(choice)
+		{
+			case 1:
+				f = st.isfull();
+			    if(f==1)              //f==1 implies stack is full        
+			    {
+			    	cout<<endl;
+			        cout<<"Insertion of a new element is not possible"<<endl;      //overflow condition
+			    }
+			    else
+			    {
+				    cout<<"Enter the element you want to push- ";
+				    cin>>p;
+				    st.push(p);
+				    st.display();
+			    }
+			    break;
+			
+			
+			case 2:
+				e = st.isempty();
+				if(e==1)              //e==1 implies stack is empty
+				{
+					cout<<endl;
+					cout<<"Deletion not possible"<<endl;             //Underflow condition
+				}
+				else
+				{
+					d = st.pop();
+					cout<<"\n"<<d<<" has been deleted";
+					st.display();
+				}
+				break;
+				
+			case 3:
+				e = st.isempty();
+				if(e==1)
+				{
+					cout<<endl;
+				}
+				else
+				{
+					cout<<endl;
+					st.display();
+				}
+				break;
+				
+			case 4:
+				f = st.isfull();
+				if(f==1)
+				{
+					cout<<endl;
+					st.display();
+				}
+				else
+				{
+					cout<<endl;
+				}
+				break;
+				
+			case 5:
+				st.clear();
+				cout<<"\nStack is cleared!!"<<endl;
+				break;
+				
+			case 6:
+				e = st.isempty();
+				if(e == 1)
+				{
+					cout<<endl;
+				}
+				else
+				{
+					cout<<"The topmost element of the stack is - ";
+				    cout<<st.topmost()<<endl;
+				}
+				/*cout<<"The topmost element of the stack is - ";
+				cout<<st.topmost()<<endl;*/
+				break;
+				
+			case 7:
+				st.display();
+				break;
+				
+		    default:
+		    	cout<<"Invalid Choice!!"<<endl;
+		    	break;
+		}
+		
+		cout<<"\nDo you want to continue ??(Y/N): ";
+		cin>>c;
+	}
+	return 0;
+}