𝐅𝐢𝐧𝐚𝐥 𝐏𝐫𝐨𝐣𝐞𝐜𝐭

Author: Ashish2030

BostonNumber

@@ -0,0 +1,51 @@
+// BostonNumber
+#include<iostream>
+#include<cmath>
+#include<vector>
+using namespace std;
+
+int digitKaSum(int n){
+
+	int sum=0;
+	while(n){
+
+		sum+=n%10;
+		n/=10;
+
+	}
+	return sum;
+}
+
+int sumOfFactors(int n){
+
+	int sum=0;
+
+	for(int i=2;i<=sqrt(n);i++){
+		while(n%i==0){
+			sum+=digitKaSum(i);
+			n/=i;
+		}
+	}
+
+	if(n>0){
+		sum+=digitKaSum(n);
+	}
+
+	return sum;
+
+}
+
+int main(){
+
+	int num;
+	cin>>num;
+
+	if(digitKaSum(num)==sumOfFactors(num)){
+		cout<<"1"<<endl;
+	}else{
+		cout<<"0";
+	}
+
+
+ return 0;
+}

BostonNumber.cpp

@@ -0,0 +1,111 @@
+#include<iostream>
+using namespace std;
+
+class node{
+public:
+
+	int data;
+	node*next;
+
+	node(int d){
+		data=d;
+		next=NULL;
+	}
+
+};
+
+class linkedList{
+	
+	node*head;
+	node*tail;
+
+	
+public:
+
+	// Constructor
+	linkedList(){
+		head=NULL;
+		tail=NULL;
+	}
+
+	// Copy Constructor
+	linkedList(linkedList &l){
+		cout<<"Copy Constructor Called"<<endl;
+		head=l.head;
+		tail=l.tail;
+	}
+
+
+	// Copy Assignment Operator
+	void operator = (linkedList l){
+		cout<<"Copy Assignment operator Called"<<endl;
+		head=l.head;
+		tail=l.tail;
+	}
+
+
+	void insertInLL(int d){
+		if(head==NULL){
+			node*n=new node(d);
+			head=tail=n;
+		}else{
+			node*n=new node(d);
+			tail->next=n;
+			tail=n;
+		}
+	}
+
+	void print(){
+		
+		node*temp=head;
+
+		while(temp!=NULL){
+			cout<<temp->data<<" ";
+			temp=temp->next;
+		}
+		cout<<endl;
+	}
+
+
+	// Destructor
+	~linkedList(){
+		cout<<"Destroying the LinkedList"<<endl;
+	}
+};
+
+int main(){
+
+	node a(1);
+	node b(2);
+
+	node *p=&a;
+
+	a.next=&b;
+
+	// use of arrow operator
+
+	cout<<((*a.next).data)<<endl;
+	cout<<a.next->data<<endl;
+	cout<<p->data<<endl;
+
+
+	linkedList l;
+
+	l.insertInLL(1);
+	l.insertInLL(2);
+	l.insertInLL(3);
+	l.insertInLL(4);
+	l.insertInLL(5);
+	l.insertInLL(6);
+	l.insertInLL(7);
+
+	l.print();
+
+	linkedList m;
+
+	m=l;
+
+
+ 
+ return 0;
+}

LinkedList

@@ -0,0 +1,76 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+using namespace std;
+
+int max(int a,int b){
+
+	return a<b?b:a;
+}
+
+int solve(int *a,int n){
+
+	vector<int>s;
+	int m=0;
+
+	s.push_back(a[0]);
+	int flag=0;
+	int sflag=0;
+
+	for(int i=1;i<n;i++){
+		int curr=a[i];
+		
+		if(s[s.size()-1]<curr){
+			
+			if(sflag==1){
+				m=max(s.size(),m);
+				int temp=s[s.size()-1];
+				s.clear();
+				s.push_back(temp);
+				s.push_back(curr);
+				sflag=0;
+			}else{
+				s.push_back(curr);
+				flag=1;
+			}
+
+		}
+
+		else if(flag==0&&s[s.size()-1]>curr){
+			s.clear();
+			s.push_back(curr);
+		}
+
+		else if(s[s.size()-1]==curr){
+			s.clear();
+			s.push_back(curr);
+			sflag=0;
+			flag=0;
+		}
+
+		else if(flag==1&&s[s.size()-1]>curr){
+			s.push_back(curr);
+			m=max(m,s.size());
+			sflag=1;
+		}
+	}
+
+	if(m<3){
+		return 0;
+	}
+
+	return m;
+}
+
+int main(){
+
+	// int a[]={2,1,4,7,3,2,5,6,8,9,12,10,9,8,7,8,9,12,2};
+	int a[]={2,3,3,2,0,2};
+	int n=sizeof(a)/sizeof(int);
+
+	cout<<solve(a,n)<<endl;
+ 	
+
+ 
+ return 0;
+}

LinkedList.cpp

@@ -0,0 +1,56 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+#include<unordered_map>
+#include<map>
+#include<stack>
+#include<queue>
+#include<set>
+#include<cstring>
+#include<cmath>
+
+using namespace std;
+
+#define int long long int
+
+class Solution {
+public:
+    int calculate(string s) {
+        stack<int> stk;
+        char sign= '+';
+        int res= 0, tmp= 0;
+        for(int i= 0; i< s.length(); i++){
+            if(isdigit(s[i]))
+                tmp= 10*tmp+s[i]-'0';
+            if(!isdigit(s[i]) && !isspace(s[i]) || i == s.length()-1){
+                if(sign == '-')
+                    stk.push(-tmp);
+                else if(sign == '+')
+                    stk.push(tmp);
+                else{
+                    int num;
+                    if(sign == '*')
+                        num= stk.top()*tmp;
+                    else
+                        num= stk.top()/tmp;
+                    stk.pop();
+                    stk.push(num);
+                }
+                sign= s[i];
+                tmp= 0;
+            }
+        }
+        while(!stk.empty()){
+            res+= stk.top();
+            stk.pop();
+        }
+        return res;
+    }
+};
+
+int32_t main(){
+
+
+
+return 0;
+}

LongestMountain

@@ -0,0 +1,93 @@
+#include<iostream>
+#include<list>
+#include<unordered_map>
+#include<queue>
+#include<map>
+#include<climits>
+using namespace std;
+
+class graph{
+
+	unordered_map<int,list<int> >mp;
+	
+
+public:
+
+	
+
+	void addEdge(int u,int v){
+		mp[u].push_back(v);
+		mp[v].push_back(u);
+
+	}
+
+	void print(){
+
+		for(auto x:mp){
+			cout<<x.first<<"-->";
+			for(auto y:x.second){
+				cout<<y<<" ";
+			}
+			cout<<endl;
+		}
+	}
+
+	void SSSP(int src){
+
+		map<int,int>dist;
+
+		for(auto x:mp){
+			dist[x.first]=INT_MAX;
+		}
+
+		queue<int>Q;
+
+		dist[src]=0;
+		Q.push(src);
+
+		while(!Q.empty()){
+
+			int node=Q.front();
+			cout<<node<<" ";
+			Q.pop();
+
+			for(auto nbr:mp[node]){
+				if(dist[nbr]==INT_MAX){
+					dist[nbr]=1+dist[node];
+					Q.push(nbr);
+				}
+			}
+
+		}
+
+		for(auto x:dist){
+			cout<<x.first<<"-->"<<x.second<<endl;
+		}
+
+	}
+
+
+
+
+};
+
+int main(){
+
+
+	graph g;
+
+	g.addEdge(0,1);
+	g.addEdge(0,2);
+	g.addEdge(1,2);
+	g.addEdge(1,3);
+	g.addEdge(1,4);
+	g.addEdge(3,4);
+	g.addEdge(4,5);
+
+
+	// g.print();
+	g.SSSP(0);
+  
+  
+ return 0;
+}