Q4_all data type map completed

Author: darshank15

APS Assignment 2.pdf

@@ -0,0 +1,121 @@
+#include<bits/stdc++.h>
+using namespace std;
+int *finalsuffixans;
+struct suffixArray{
+    int index;
+    int tuple[2];
+};
+
+bool comfun(struct suffixArray obj1, struct suffixArray obj2)
+{
+    if(obj1.tuple[0]==obj2.tuple[0])
+    {
+        if(obj1.tuple[1]<obj2.tuple[1])
+            return true;
+        else
+            return false;
+    }
+    else if(obj1.tuple[0]<obj2.tuple[0])
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+void createsufficArray(string str)
+{
+    int size1=str.length();
+    struct suffixArray suffobj[size1];
+    int suffInd[size1];
+
+    // Intitialisation of tuple w.r.t first two character
+    for(int i=0;i<size1;i++)
+    {
+        suffobj[i].index=i;
+        suffobj[i].tuple[0]=str[i]-'0';
+        if(i<size1-1)
+        {
+            suffobj[i].tuple[1]=str[i+1]-'0';
+        }
+        else{
+             suffobj[i].tuple[1]=-1;
+        }
+
+    }
+
+    //sort according to tuple;
+    sort(suffobj,suffobj+size1, comfun);
+
+    for(int j=4;j<(2*size1);j=j*2)
+    {   
+        int curRank=0;
+        int preRank=suffobj[0].tuple[0];
+        suffobj[0].tuple[0]=curRank;
+        suffInd[suffobj[0].index]=0;
+
+        for(int k=1;k<size1;k++)
+        {
+            int curtuple1=suffobj[k].tuple[0];
+            int curtuple2=suffobj[k].tuple[1];
+            int pretuple2=suffobj[k-1].tuple[1];
+            if(curtuple1==preRank && curtuple2==pretuple2)
+            {
+                preRank=suffobj[k].tuple[0];
+                suffobj[k].tuple[0]= curRank;
+            }
+            else{
+                preRank=suffobj[k].tuple[0];
+                suffobj[k].tuple[0]=++curRank;
+            }
+            suffInd[suffobj[k].index]=k;
+        }
+
+        for (int i=0;i<size1;i++) 
+        { 
+            int nextind = suffobj[i].index + j/2; 
+            if(nextind < size1){
+                suffobj[i].tuple[1]=suffobj[suffInd[nextind]].tuple[0];
+            }
+            else{
+                 suffobj[i].tuple[1]=-1;
+            }
+        } 
+  
+        sort(suffobj, suffobj+size1, comfun); 
+
+    }
+
+     // Store indexes of all sorted suffixes in the suffix array 
+    finalsuffixans = new int[size1]; 
+    for (int i=0;i<size1;i++)
+    {
+        finalsuffixans[i] = suffobj[i].index; 
+    } 
+    
+}
+
+int main()
+{
+    string s;
+    cin>>s;
+    createsufficArray(s);
+    cout<<"Suffix Array for given string : ";
+    int len=s.length();
+    for(int i=0;i<len;i++)
+    {
+        cout<< finalsuffixans[i]<<" ";
+    }
+    int small=finalsuffixans[0];
+    string nextsub=s.substr(small);
+    //cout<<nextsub<<endl;
+    string presub=s.substr(0,small);
+    //cout<<presub<<endl;
+    string lexsmallstr=nextsub+presub;
+
+    cout<<"\nMinimum Lexicographic rotation : "<<lexsmallstr<<endl;
+
+    return 0;
+
+}

Q1a_2018201033.cpp

@@ -0,0 +1,214 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define SIZE 3
+#define X 31
+
+template <class T, class U>
+class Unordered_map
+{
+    class node
+    {
+      public:
+        T kunique;
+        U val;
+        node *next;
+    };
+
+    node *hashtable[SIZE];
+
+  public:
+    //Constructor
+    Unordered_map()
+    {
+        for (int i = 0; i < SIZE; i++)
+        {
+            hashtable[i] = NULL;
+        }
+    }
+
+    void printall()
+    {
+        cout << "\n*********************" << endl;
+        for (int i = 0; i < SIZE; i++)
+        {
+            cout << hashtable[i] << " ";
+            if (hashtable[i] != NULL)
+            {
+                node *cur = hashtable[i];
+                while (cur != NULL)
+                {
+                    cout << cur->kunique << " : ";
+                    cout << cur->val << " || ";
+                    cur = cur->next;
+                }
+            }
+            cout << endl;
+        }
+        cout << "\n*********************" << endl;
+    }
+
+    node *getnewNode(T key1, U value1)
+    {
+        node *new_node = new node;
+        new_node->kunique = key1;
+        new_node->val = value1;
+        new_node->next = NULL;
+        //cout << "\nNode created successfully";
+        return new_node;
+    }
+
+    long long getHashIndex(T key)
+    {
+        ostringstream str1;
+        str1 << key;
+        string str = str1.str();
+        //cout<<str<<endl;
+        long long result = str[0];
+        for (long long i = 1; i < str.length(); i++)
+        {
+            result = result * X + str[i];
+        }
+        long long index = result % SIZE;
+        return index;
+    }
+
+    void insertintohash(T key, U value)
+    {
+        printall();
+        long long index = getHashIndex(key);
+        cout << "Hash Index : " << index << endl;
+        if (hashtable[index] == NULL)
+        {
+            hashtable[index] = getnewNode(key, value);
+            cout << "Node inserted Succesfully" << endl;
+        }
+        else
+        {
+            node *cur = hashtable[index];
+            int flag = 0;
+            while (cur->next != NULL)
+            {
+                if (cur->kunique == key)
+                {
+                    flag = 1;
+                    break;
+                }
+                cur = cur->next;
+            }
+            if (!flag && cur->kunique!=key)
+            {
+                cur->next = getnewNode(key, value);
+                cout << "Node inserted Succesfully" << endl;
+            }
+            else
+            {
+                cout << "Key Already present in map" << endl;   
+            }
+        }
+        printall();
+    }
+    U searchvalue(T key)
+    {
+        long long index = getHashIndex(key);
+        //cout << "Hash Index : " << index << endl;
+        if (hashtable[index] == NULL)
+            return "-1";
+        else
+        {
+            node *cur = hashtable[index];
+            while (cur != NULL && cur->kunique != key)
+            {
+                cur = cur->next;
+            }
+            if (cur == NULL)
+                return "-1";
+            else
+            {
+                return cur->val;
+            }
+        }
+    }
+    void deletekey(T key)
+    {
+        printall();
+        long long index = getHashIndex(key);
+        cout<<"in delete Hash Index : "<<index<<endl;
+        if (hashtable[index] == NULL)
+        {
+            printf("\nKey not found in Map");
+            return;
+        }
+        else
+        {
+            node *head = hashtable[index];
+            node *tra = head;
+            if (head->kunique == key)
+            {
+                tra = head;
+                head = head->next;
+                free(tra);
+                hashtable[index] = head;
+                printall();
+                return;
+            }
+            else
+            {
+                node *pre;
+                while (tra->next != NULL && tra->kunique != key)
+                {
+                    pre = tra;
+                    tra = tra->next;
+                }
+                if (tra->next == NULL && tra->kunique != key)
+                {
+                    printf("\nKey not found in Map");
+                    return;
+                }
+                else //tra->data==ele
+                {
+                    pre->next = tra->next;
+                    free(tra);
+                }
+                printall();
+            }
+        }
+    }
+};
+int main()
+{
+    string key;
+    string value;
+    Unordered_map<string, string> mp;
+    int ch;
+    do
+    {
+        cout << "\n1.insert";
+        cout << "\n2.search";
+        cout << "\n3.Delete";
+        cout << "\nEnter You choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cin >> key;
+            cin >> value;
+            mp.insertintohash(key, value);
+        }
+        else if (ch == 2)
+        {
+            cin >> key;
+            cout << "Value : " << mp.searchvalue(key);
+        }
+        else if (ch == 3)
+        {
+            cin >> key;
+            mp.deletekey(key);
+        }
+        else
+        {
+            cout << "Invalid Argument";
+        }
+
+    } while (ch != 0);
+
+    return 0;
+}