COMPUTER ENGINEERING M. Tech.

I SEMESTER
SYSTEM SOFTWARE LAB

List of Experiments: Q1. Write a program in C/C++/Java to develop AVL Tree for 10 elements.
/* Adelson Velseky Landis Tree */ # include <iostream> using namespace std; template <class key> class avlNode { public: int element; avlNode *left; avlNode *right; int height; avlNode(key &,avlNode *, avlNode*, int =0); }; //typedef class avlNode *avlNodeptr; template <class key> class avlTree { public: avlTree(); avlTree(avlTree &); ~avlTree(); bool empty(); int height(); void preorder(); void inorder(); void postorder(); void clear(); void insert(key &); avlTree & operator =(avlTree &); private: avlTree<key> *root; void recursive_preorder(avlNode <key> *);//bstree::/recursive_ void recursive_postorder(avlNode <key> *); void recursive_inorder(avlNode <key> *); void void void void }; rotateWithLeftChild(avlNode<key> *&); rotateWithRightChild(avlNode<key> *&); doudleWithLeftChild(avlNode<key> *&); doubleWithRightChild(avlNode<key> *&);

//

Make a tree empty

bool recursive_empty( ) { avlNode d; if (p != NULL) { makeempty(p->left); makeempty(p->right); d=p; free(d); p=NULL; } } int recursive_height( ) { int t; if (p == NULL) return -1; else { t = p->height; return t; } } // preorder void recursive_preorder( ) { if (p!=NULL) { cout<<p->element<<"-->"; preorder(p->left); preorder(p->right); } }

// Inorder Printing void recursive_inorder( ) { if (p!=NULL) { inorder(p->left); cout<<p->element<<"-->"; inorder(p->right); } } // PostOrder Printing void recursive_postorder( ) { if (p!=NULL) { postorder(p->left);

postorder(p->right); cout<<p->element<<"-->"; } }

// Deleting a node void recursive_del( ) { avlNodeptr d; if (p==NULL) cout<<"Element not found "; else if ( x < p->element) del(x,p->left); else if (x > p->element) del(x,p->right); else if ((p->left == NULL) && (p->right == NULL)) { d=p; free(d); p=NULL; cout<<"Element deleted !"; } else if (p->left == NULL) { d=p; free(d); p=p->right; cout<<"Element deleted !"; } else if (p->right == NULL) { d=p; p=p->left; free(d); cout<<"Element deleted !"; } else p->element = deletemin(p->right); } // Inserting a node void recursive_insert(key &) { if (p == NULL) { p = new node; p->element = x; p->left=NULL; p->right = NULL; p->height=0; if (p==NULL) cout<<"Out of Space"; } else { if (x<p->element) {

insert(x,p->left); if ((bsheight(p->left) - bsheight(p->right))==2) { if (x < p->left->element) p=srl(p); else p = drl(p); } } else if (x>p->element) { insert(x,p->right); if ((bsheight(p->right) - bsheight(p->left))==2) { if (x > p->right->element) p=srr(p); else p = drr(p); } } else cout<<"Element Exists"; } int m,n,d; m=bsheight(p->left); n=bsheight(p->right); d=max(m,n); p->height = d + 1; }

int main() { nodeptr root,root1,min,max;//,flag; int a,choice,findele,delele,leftele,rightele,flag; char ch='y'; bstree bst; root = NULL; root1=NULL; cout<<"AVL Tree"<<endl; cout<<" ========"<<endl; do { cout<<"1.Insertion"<<endl; cout<<"2.Delete"<<endl; cout<<"3.Preorder"<<endl; cout<<"4.Inorder"<<endl; cout<<"5.Postorder"<<endl;

cout<<"6.height"<<endl; cout<<"Enter the choice:"<<endl; cin>>choice; switch(choice) { case 1: cout<<"New node's value ?"; cin>>a; bst.insert(a,root); break; case 2: cout<<"Delete Node ?"; cin>>delele; bst.del(delele,root); bst.inorder(root); break; case 3: cout<<" Preorder Printing... :"; bst.preorder(root); break; case 4: cout<<"Inorder Printing.... :"; bst.inorder(root); break; case 5: cout<<"Postorder Printing... :"; bst.postorder(root); break; case 6: cout<<"Height and Depth is "; cout<<bst.bsheight(root); cout<<"No. of nodes:- "<<bst.nonodes(root); break;

} cout<<"Do u want to continue (y/n) ?"; cin>>ch; }while(ch=='y'); return 0; }

Q2. Write a program in C/C++/Java to develop Red Black Tree for 10 elements.
#include <iostream> #include <time.h> #include <string> #include <stdio.h> #include <stdlib.h> using namespace std;

class tree { struct tree_object { tree_object *left; tree_object *right; tree_object *parent; int value; bool red; }; tree_object* root; int data_size; int choose; int *array; public : tree( int data_size,int choose ) { this->data_size=data_size; this->choose=choose; array=new int [data_size]; root=NULL; } bool tree_empty() const { return root==NULL;} void QS_sort(int,int); void random_data(); void start(); void Tree_insert(int); void inorder(tree_object*); void drukuj_strukture_drzewa(tree_object*); void RB_insert(tree_object*); void left_rotation(tree_object*); void right_rotation(tree_object*); }; void tree:: inorder(tree_object* pointer) { if(pointer!= NULL) { inorder(pointer->left); cout<<pointer->value<<" "; inorder(pointer->right); } } void tree::start() { random_data();

// in this function, I fill my array random numbers,it's correct to 100 %

cout<<endl<<endl; for(int i=0;i<data_size;i++) { Tree_insert(array[i]); // here I send sequence value from Array to this function cout<<endl<<endl<<" In-Order Tree "<<endl<<endl; inorder(root); } }

void tree:: RB_insert(tree_object * new_node) { tree_object * y; while( new_node != root && new_node->parent ->red == true) { if( new_node->parent == new_node->parent ->parent ->left ) { y= new_node->parent ->parent ->right; if( y->red ) { new_node ->parent ->red=false; y->red=false; new_node->parent->parent ->red = true; new_node= new_node->parent ->parent ; } else { if( new_node== new_node->parent ->right ) { new_node=new_node->parent ; left_rotation(new_node); } new_node->parent -> red = false; new_node->parent -> parent -> red = true; right_rotation( new_node->parent ->parent } } else { y= new_node->parent ->parent ->left; if( y->red ) **Segmentation fault,higher was all ok,here not** { new_node->parent ->red=false; y->red=false; new_node->parent ->parent ->red = true; new_node=new_node->parent->parent ; } else { if( new_node ==new_node->parent ->left ) { new_node=new_node->parent ; right_rotation(new_node); } new_node->parent -> red= false; new_node->parent -> parent ->red=true; left_rotation( new_node->parent ->parent } } } root->red=false;

);

);

} void tree:: left_rotation(tree_object* x) { tree_object* y=x->right; x->right=y->left; if( y->left !=NULL) { y->left->parent =x; } y->parent = x->parent ; if( x->parent ==NULL) { root = y; } else if (x == x->parent ->left) { x->parent ->left = y; } else { x->parent ->right = y; } y->left = x; x->parent = y; } void tree:: right_rotation(tree_object* y) { tree_object* x = y->left; y->left = x->right; if( x->right!= NULL) { x->right->parent = y ; } x->parent = y->parent; if( y->parent == NULL) { root = x; } else if (y == y->parent ->right) { y->parent ->right = x; } else { y->parent ->left= x; } x->right= y; y->parent = x; } void tree::Tree_insert(int valueee) { tree_object *y=NULL; tree_object *new_node=new tree_object; new_node->value=valueee; if( tree_empty() )

{ root=new_node; } else { tree_object* x=root; while( x !=NULL ) { y=x; if( new_node->value < x->value ) { x=x->left; } else if( new_node->value > x->value) { x=x->right; } } new_node->parent=y; if( new_node->value < y->value) { y->left =new_node; } else { y->right=new_node; } } new_node->left=NULL; new_node->right=NULL; new_node->red=true; RB_insert(new_node); } void tree::random_data() { if( choose ==1) // here I draw not repeated numbers { int data_size_local=0; int temp,error; for (int i=0; i<data_size; i++) { do { error=0; temp=0 + rand() % 1000; for (int j=0; j<i; j++) { if (this->array[j]==temp) { error=1; } } } while (error);

this->array[ i ]=temp; } cout<<endl<<" Array with numbers "<<endl; for( int i=0;i<data_size;i++) { cout<<array[i]<<" "; } } if( choose==2) //like higher but I send this random numbers to QS_sort function { srand(time(NULL)); int data_size_local=0; int temp,error; for (int i=0; i<data_size; i++) { do { error=0; temp=0 + rand() % 1000; for (int j=0; j<i; j++) { if (this->array[j]==temp) { error=1; } } } while (error); this->array[ i ]=temp; } data_size_local=data_size; QS_sort(0,data_size_local-1); } } void tree:: QS_sort(int left,int right) //zwyky QS { int i = left, j = right; int tmp; int pivot = this->array[(left + right) / 2]; while (i <= j) { while ( this->array[i] < pivot) { i++; } while ( this->array[j] > pivot) { j--; } if (i <= j) { tmp = this->array[i]; this->array[i] = this->array[j]; this->array[j] = tmp;

i++; j--; } } if (left < j) { QS_sort(left, j); } if (i < right) { QS_sort(i, right); } } int main() { int data_size,choose; cout<<" Give data size \n"; cin>>data_size; cout<<"How do you want enter data? \n" <<"1 - Random numbers \n" <<"2 - Sorted Random numbers \n"; cin>>choose; tree object(data_size,choose); object.start(); return 0; }

Q3. Write a program in C/C++/Java to delete an element from Red Black Tree.

Q4. Implement Ford Fulkerson (Max- Flow Min Cut) in C/C++/Java.

#include "Graph.h" #include <iostream> #include <fstream> #include <sstream> #include <algorithm> #include <vector> #include <string> #include <iterator> #include <queue> using namespace std; /** Summary: * * * * */

A special version of BFS which returns useful information for maxFlow: path with associated weights. If minCut is set to true, BFS will instead return the set of nodes it can reach

int* BFS(Graph *g, int s, int t, bool minCut){ int nV = g->nV; queue<int> visit; bool found = false; // Initialize values to be used in the search

// keeping track of parent and whether node has // been visited or not. int* visited = new int[nV]; int* parent = new int[nV*2]; // This is a horrible hack of making a 2D array int* path = new int[nV*2]; for (int i=0; i<nV; i++) { // Visited: 0 hasn't been visited, 1 is on the frontier, 2 is done visited[i] = 0; parent[i] = 0; //Only worry about 0 - keys, if a key is set I set the weight path[i] = 0; } // Enqueue the entry node, s, and search for t visit.push(s); visited[s] = 1; while (!visit.empty()) { // Search int u = visit.front(); visit.pop(); if(u==t){ // Found it - build path array. found = true; int c = t; int p = parent[t]; do { path[c] = p; path[c+nV] = parent[c+nV]; c = p; p = parent[c]; } while (p!=0); break; } else { // Color me, enqueue my children and color them visited[u] = 2; nodeEdge* adjList = g->nodes[u]; while (adjList!=NULL) { // Get adj node, see if it's been visited and // if not it's my child int v = adjList->vertex; if(visited[v]==0){ visit.push(v); parent[v] = u; parent[v+nV] = adjList->weight; visited[v] = 1; } adjList = adjList->next; } } } !found && (path = NULL); minCut ? delete path : delete visited; delete parent; return minCut ? visited : path; } /** Summary: * This finds the minimum edge weight along * a path and returns it, since the flow cannot * exceed that. */ int bottleNeck(int *path, int t, int nV){ if(path==NULL) return 0; int m = 0, p = path[t], last=t; do { m = m==0 ? path[last+nV] : min(path[last+nV], m); last = p; p = path[last]; } while (p!=0); //cout << "Bottleneck: " << m << endl; return m; } /** Summary: * Capacity scaling implementation of Ford-

* Fulkerson algorithm. */ int maxFlow(Graph *g){ ofstream output("output.txt", ios::out); if (!output) { cout << "Error: failed create output file" << endl; return -1; } // First create the residual graph by copying the original Graph *bG, *rG = new Graph(g); // C-capacity from source, mC-max capacity from A={s}, delta-nearest power of 2, rCresidual capacity int C=0, mC=0, delta=1, rC=0, s=g->s, t=g->t, nV=g->nV; // Get an upper bound on the flow by summing the // capacity coming out of the source node nodeEdge *src = rG->nodes[s]; while (src!=NULL) { int tmp = src->weight; mC=max(tmp,mC); C+=tmp; src = src->next; } //cout << "Capacity: " << C << endl; if(mC>1){ // Technically should also check for an upper bound which // depends on architecture, 32/64 bit. while (delta<mC) { delta<<=1; } if (delta>mC) { // Shift it back one so it's less than or equal to C delta>>=1; } }else if(mC==1){ delta = 1; cout << "Edge weight is 1 so setting delta as 1 since lower power of 2 is 0" << endl; } else { cout << "There is no positive capacity, no positive flow exists" << endl; exit(1); } bG = rG->bottleneckGraph(delta); // Now find an aug path int* augPath = BFS(bG, s, t, false); while (delta>=1) { // Keep getting augPaths until down on delta output << "With DELTA=" << delta << ", "; while (augPath!=NULL) { // Get all augmenting paths for current delta int p, c, b; if (augPath==NULL) { c = b = p = 0; } else { b = bottleNeck(augPath, t, nV); c = t; p = augPath[t]; } while (p!=0){ // I have an edge. edges we sent flow // through of the form p->c. int success = rG->updateEdgeWeight(p, c, -b); if(success==0){ // Means we created an edge, shouldn't have happened throw error cout << "Error, didn't find edge in adj list" << endl; exit(1); } // Now update the residual graph by either creating a c->p edge, or // adding weight First reduce the weight on all

rG->updateEdgeWeight(c, p, b); c = p; p = augPath[c]; } // Destroy my last bottleneck graph and make a new one delete bG; bG = rG->bottleneckGraph(delta); augPath = BFS(bG, s, t, false); } // I want to see my new graph for each augmentation //rG->toString(); rC = 0; src = rG->nodes[s]; while (src!=NULL) { rC+=src->weight; src = src->next; } output << "Flow value=" << C-rC << endl; // My residual graph has been updated with my last flow, find a new // augmenting path and try it again. delta = delta/2; bG = rG->bottleneckGraph(delta); augPath = BFS(bG, s, t, false); } output << "Max-flow value=" << C-rC << endl; output << "The max-flow:" << endl; // Print the max flow by going through the edges in the original // graph and subtracting the for (int i=1; i<g->nV; i++) { nodeEdge *r, *n = g->nodes[i]; while (n!=NULL) { r = rG->nodes[i]; // Start at the beginning each time since edges could be gone while (r!=NULL && r->vertex!=n->vertex) { r = r->next; } int wt = r==NULL ? n->weight : n->weight - r->weight; if(wt>0) output << i << " " << n->vertex << " " << wt << endl; n = n->next; } } // Now find and print the min-cut output << endl << "Min-cut capacity=" << C-rC << endl; output << "The min-cut:" << endl; // This assumes a connected graph int* minCut = BFS(rG, rG->s, rG->t, true); vector<int> S, T; for (int i=1; i<rG->nV; i++) { minCut[i]>0 ? S.push_back(i) : T.push_back(i); } output << "The set S:" << endl; for (size_t i=0; i<S.size(); i++) { output << S[i] << ", "; } output << endl << "The set T:" << endl; for (size_t i=0; i<T.size(); i++) { output << T[i] << ", "; } output << endl; output.close(); delete rG; return C-rC; }; int main (int argc, char * const argv[]) { // Read in the data and construct the graph string line; ifstream myfile; myfile.open("input.txt");

if(myfile.is_open()){ int edgeCount, counter = 1; Graph* g = NULL; cout << "Successfully opened file" << endl; while (!myfile.eof()) { getline(myfile, line); vector<string> tokens; int a, b, c; if(line.empty()){ // Skip me }else { stringstream iss(line); copy(istream_iterator<string>(iss), istream_iterator<string>(), back_inserter<vector<string> >(tokens)); if(tokens.size()>3){ cout << "Input error: too many values/line" << endl; myfile.close(); return -1; } if(tokens.size()!=2 && counter<=2){ cout << "Input error: only two values allowed in first two lines: nV and nE or s and t" << endl; return -1; } // Now that we have the vector, we need to make sure // the input is integer and then create our graph // Values here would be greater than 0 a = atoi(tokens[0].c_str()); b = atoi(tokens[1].c_str()); c = tokens.size()>2 ? atoi(tokens[2].c_str()) : 0; if(a<1 || b<1 || (counter>2 && c<1)){ // I asked professor XUE and he said throw an error for 0 // edge weight as well as non integer. cout << "Input error: Non integer (or 0) input" << endl; myfile.close(); return -1; } if(counter == 1){ // Initialize graph edgeCount = b; g = new Graph(a,b); } // Other setup if (counter == 2) g->setSourceSink(a,b); if(counter > 2){ // Adding vertices and edges baby nodeEdge *n = new nodeEdge(b,c); g->addEdge(a,n); } counter++; } //cout << "Vector size: " << tokens.size() << " 1: " << a << " 2: " << b << " 3: " << c << endl; } myfile.close(); // One last check, now that // number of expected edges if (edgeCount != counter-3) cout << "Expected counter-3 << endl; return -1; } // Begin max flow algorithm! -- I should do this from a function maxFlow(g); I've gone through the file does the match with the number of actual edges given? { " << edgeCount << " edges but found " <<

//cout << "Flow value: " << flow << endl; } else { // ELSE to opening file. Major fail cout << "Error opening file" << endl; return -1; } return 0; }

Q5. Write a program in C/C++/Java to implement Round Robin Algorithm.

#include<stdio.h> #include<conio.h> main() { int st[10],bt[10],wt[10],tat[10],n,tq; int i,count=0,swt=0,stat=0,temp,sq=0; float awt=0.0,atat=0.0; clrscr(); printf("Enter number of processes:"); scanf("%d",&n); printf("Enter burst time for sequences:"); for(i=0;i<n;i++) { scanf("%d",&bt[i]); st[i]=bt[i]; } printf("Enter time quantum:"); scanf("%d",&tq); while(1) { for(i=0,count=0;i<n;i++) { temp=tq; if(st[i]==0) { count++;

continue; } if(st[i]>tq) st[i]=st[i]-tq; else if(st[i]>=0) { temp=st[i]; st[i]=0; } sq=sq+temp; tat[i]=sq; } if(n==count) break; } for(i=0;i<n;i++) { wt[i]=tat[i]-bt[i]; swt=swt+wt[i]; stat=stat+tat[i]; } awt=(float)swt/n; atat=(float)stat/n; printf("Process_no Burst time Wait time Turn around time "); for(i=0;i<n;i++) printf("%d %d %d %d ",i+1,bt[i],wt[i],tat[i]); printf("Avg wait time is %f Avg turn around time is %f",awt,atat);

getch(); }

Q6. Write a program in C/C++/Java to implement Priority Scheduling Algorithm.

//priority scheduling #include<stdio.h> #include<conio.h> #include<dos.h>

void main() { int n,b[10],w[10],i,j,h,t,tt; int stime[10],a[10],p[10]; float avg=0; clrscr(); printf("\n\tPRIORITY SCHEDULING ALGORITHM"); printf("\n\t*****************************************************\n"); printf("\nEnter howmany jobs:"); scanf("%d",&n); printf("\nEnter burst time & priority for corresponding job....\n"); for(i=1;i<=n;i++) { printf("\nProcess %d:",i); scanf("%d %d",&b[i],&p[i]); a[i]=i; } for(i=1;i<=n;i++) for(j=i;j<=n;j++)

if(p[i]<p[j]) { t=b[i]; tt=a[i]; b[i]=b[j]; a[i]=a[j]; b[j]=t; } a[j]=tt;

w[1]=0;

printf("\nprocess %d waiting time is 0",a[1]); for(i=2;i<=n;i++) { w[i]=b[i-1]+w[i-1]; printf("\nProcess %d waiting time: %d",a[i],w[i]); avg+=w[i]; } printf("\ntotal waiting time:%f",avg); printf("\n\nthe average waiting time is:%f\n",avg/n); printf("\nGaunt Chart\n***************************************\n\n\t"); h=22;

for(i=1;i<=n;i++) { printf("%d",b[i]);

for(j=1;j<=b[i];j++) printf("%c",h); } printf("\n\t"); for(i=1;i<=n;i++) { printf("%d",w[i]); for(j=1;j<=w[i];j++) printf("%c",h); delay(1000); }

getch(); }

Q7. Write a program in C/C++/Java to implement FCFS algorithm.

#include<stdio.h> main() { int n,a[10],b[10],t[10],w[10],g[10],i,m;

float att=0,awt=0; for(i=0;i<10;i++) { a[i]=0; b[i]=0; w[i]=0; g[i]=0; } printf("enter the number of process"); scanf("%d",&n); printf("enter the burst times"); for(i=0;i<n;i++) scanf("%d",&b[i]); printf("\nenter the arrival times"); for(i=0;i<n;i++) scanf("%d",&a[i]); g[0]=0; for(i=0;i<10;i++) g[i+1]=g[i]+b[i]; for(i=0;i<n;i++) { w[i]=g[i]-a[i]; t[i]=g[i+1]-a[i]; awt=awt+w[i]; att=att+t[i]; } awt =awt/n; att=att/n; printf("\n\tprocess\twaiting time\tturn arround time\n"); for(i=0;i<n;i++) { printf("\tp%d\t\t%d\t\t%d\n",i,w[i],t[i]); } printf("the average waiting time is %f\n",awt); printf("the average turn around time is %f\n",att); }

Q8. Write a program in C/C++/Java to implement Diffi Hillmen Key Exchange Algorithm.
#include <stdio.h> #include <math.h> void main() { int q,alpha,xa,xb,ya,yb,ka,kb, x,y,z,count,ai[20][20]; printf("Enter a Prime Number \"q\":"); scanf("%d",&q); printf("Enter a No \"xa\" which is lessthan value of q:");

scanf("%d",&xa); printf("Enter a No \"xb\" which is lessthan value of q:"); scanf("%d",&xb); for(x=0;x<q-1;x++) //Primitive Root Calculation for(y=0;y<q-1;y++) ai[x][y] = ((int)pow(x+1,y+1))%q; for(x=0;x<q-1;x++) { count = 0; for(y=0;y<q-2;y++) { for(z=y+1;z<q-1;z++) if(ai[x][y] == ai[x][z]) { count = 1; break; } if(count == 1) break; } if (count == 0 ) { alpha = x+1; break; } } printf("alpha = %d\n",alpha); ya = ((int)pow(alpha,xa))%q; yb = ((int)pow(alpha,xb))%q; ka = ((int)pow(yb,xa))%q; kb = ((int)pow(yb,xb))%q; printf("ya = %d\nyb = %d\nka = %d\nkb = %d\n",ya,yb,ka,kb); if(ka == kb) printf("The keys exchanged are same"); else printf("The keys exchanged are not same"); }

Q9. Write a program in C/C++/Java to implement RSA key exchange algorithm.

#include <stdio.h>

int ex_gcd(int a,int b,int n) //computes the GCD using the Extended Euclid method { int x=0,y=1,lastx=1,lasty=0; int temp,q; while(b!=0) { temp =b; q = a/b; b = a%b; a = temp;

temp=x; x = lastx - q*x; lastx = temp;

temp =y; y = lasty - q*y; lasty = temp; } if(n==1) return a; else return lasty; }

long en_de(int base, int exp,int n) { int b[30],i,c=0; long d=1; for(i=0;exp!=0;exp/=2,i++) b[i]=exp%2;

i--; for(;i>=0;i--)

{ c = 2*c; d = (d*d) %n; if(b[i]==1) { c = c+1; d = (d*base)%n; } } return d; }

void main() {

int p,q,i; int pt,ct; int e,d,et,n,temp;

printf("Enter prime No.s p,q :"); scanf("%d %d",&p,&q);

n = p*q; et=(p-1)*(q-1);

for(i=2;i<et;i++) if(ex_gcd(et,i,1) == 1) printf("%d\t",i);

printf("\nSelect e value:"); scanf("%d",&e);

temp = ex_gcd(et,e,2); d = et+temp;

printf("\nPublic Key KU = {%d,%d}\n",e,n); printf("Private Key KR = {%d,%d}\n",d,n);

printf("Enter Plain text M Integer (0<M<%d):",n); scanf("%d",&pt);

ct = en_de(pt,e,n);

printf("\nCipher Text = %d",ct); printf("\n\nPlan Text After decrtion :%d",en_de(ct,d,n)); }

Q10. Write a program in C/C++/Java that will decrypt the following string with monoalphabetic substitution cipher with key = 4 DFGTNBVGJKGHIUYJHUHJLVFGYT Q11. Draw a sequential diagram of UML for Railway Reservation System.

Q12. Draw collaboration Diagram of UML for Payroll Management System. Q13. Draw a Use-Case Diagram of UML for Safe Home Security System. Q14. Draw Collaboration Diagram of UML for Inventory Management System.

NOTE: ATTEMPT ANY TEN QUESTIONS IN THE FILE.