Adding Company Wise Questions Folder

Algorithms/BinarySearch

@@ -0,0 +1,45 @@
+//srishti1302
+#include <stdio.h>
+#define COMPARE(x,y) ( (x)<(y)?-1:(x)==(y)? 0 :1 )
+int binsearch(int a[20],int k,int left,int right)
+{
+
+    if(left<right)
+    {
+        int middle=(left+right)/2;
+        switch(COMPARE(a[middle],k))
+        {
+            case -1: return binsearch(a,k,middle+1,right);
+                     break;
+
+            case 0: return middle;
+                    break;
+
+            case 1: return binsearch(a,k,left,middle-1);
+                    break;
+        }
+    }
+    return -1;
+}
+int main()
+{
+    int n,a[20],k,res;
+    printf("Enter size of the array: ");
+    scanf("%d",&n);
+    printf("\nEnter the array elements:\n");
+    for(int i=0;i<n;i++)
+        scanf("%d",&a[i]);
+    printf("\nEnter the number to be searched:\n");
+    scanf("%d",&k);
+
+    res=binsearch(a,k,0,n-1);
+    if(res==-1)
+        printf("Element not found!!");
+    else
+        printf("\nThe number %d is found at positon %d in the given list",k,res+1);
+
+    return 0;
+}
+
+
+

Algorithms/Brian Kernighan’s Algorithm.py

@@ -0,0 +1,12 @@
+def countSetBits(n):
+
+    count = 0
+    while (n):
+        n &= (n-1)
+        count+= 1 
+    return count
+
+
+# Program to test function countSetBits
+i = 9
+print(countSetBits(i)

Algorithms/Bubble_sort.cpp

@@ -0,0 +1,32 @@
+#include<iostream>
+using namespace std;
+
+//Bubble sort : swap two elements walaa technique
+
+int main(){
+    int n;
+    cin>>n;
+    int arr[n];
+    for(int i=0;i<n;i++){
+        cin>>arr[i];
+    }
+
+    int counter = 1;
+    while(counter<n){
+        for(int i=0;i<n-counter;i++){
+            if(arr[i]>arr[i+1]){
+                if(arr[i]>arr[i+1]){
+                    int temp=arr[i];
+                    arr[i]=arr[i+1];
+                    arr[i+1]=temp;
+                }
+
+            }
+        }
+        counter++;
+    }
+    for(int i=0;i<n;i++){
+        cout<<arr[i]<<" ";
+    }
+
+}

Algorithms/CreateHeap.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void Insert(vector<int>& vec, int key){
+    // Insert key at the end
+    auto i = vec.size();
+    vec.emplace_back(key);
+
+    // Rearrange elements: O(log n)
+    while (i > 0 && key > vec[i % 2 == 0 ? (i/2)-1 : i/2]){
+        vec[i] = vec[i % 2 == 0 ? (i/2)-1 : i/2];
+        i = i % 2 == 0 ? (i/2)-1 : i/2;
+    }
+    vec[i] = key;
+}
+
+void InsertInplace(int A[], int n){
+    int i = n;
+    int temp = A[n];
+    while (i > 0 && temp > A[i % 2 == 0 ? (i/2)-1 : i/2]){
+        A[i] = A[i % 2 == 0 ? (i/2)-1 : i/2];
+        i = i % 2 == 0 ? (i/2)-1 : i/2;
+    }
+    A[i] = temp;
+}
+
+void CreateHeap(vector<int>& vec, int A[], int n){
+    // O(n log n)
+    for (int i=0; i<n; i++){
+        Insert(vec, A[i]);
+    }
+}
+
+void createHeap(int A[], int n){
+    for (int i=0; i<n; i++){
+        InsertInplace(A, i);
+    }
+}
+
+template <class T>
+void Print(T& vec, int n, char c){
+    cout << c << ": [" << flush;
+    for (int i=0; i<n; i++){
+        cout << vec[i] << flush;
+        if (i < n-1){
+            cout << ", " << flush;
+        }
+    }
+    cout << "]" << endl;
+}
+
+
+int main() {
+
+    cout << "Create Heap" << endl;
+    int b[] = {10, 20, 30, 25, 5, 40, 35};
+    Print(b, sizeof(b)/sizeof(b[0]), 'b');
+
+    vector<int> v;
+    CreateHeap(v, b, sizeof(b)/sizeof(b[0]));
+    Print(v, v.size(), 'v');
+
+    cout << "Inplace Insert" << endl;
+    createHeap(b, sizeof(b)/sizeof(b[0]));
+    Print(b, sizeof(b)/sizeof(b[0]), 'b');
+
+
+    return 0;
+}

Algorithms/Deletion_in_Array.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+using namespace std;
+
+void display(int A[],int n){
+    for(int i=0; i<n; i++)
+        cout << A[i] << " ";
+}
+
+void arr_delete(int A[], int index, int length){
+
+    for(int i= index; i<length; i++){
+        A[i] = A[i+1];
+    }
+}
+
+int main(){
+
+    int n,m;
+    cout<<"Enter size of the array: ";
+    cin>>n;
+    cout<<"Enter length of the array: ";
+    cin>>m;
+    int A[n];
+
+    for(int i=0; i<m; i++){
+        cin>>A[i];
+    }
+
+    //Example function call to delete 2nd element
+    arr_delete(A,2,m);
+
+    display(A,m-1);
+
+    return 0;
+
+}

Algorithms/Diagnolmatrix.cpp

@@ -0,0 +1,74 @@
+#include<iostream>
+using namespace std;
+
+class Diagnol
+{
+private:
+    int *A;
+    int n;
+public:
+    Diagnol()
+    {
+        n=2;
+        A=new int[2];
+    }
+    Diagnol(int n)
+    {
+        this->n=n;
+        A=new int[n];
+    }
+    ~Diagnol()
+    {
+        delete []A;
+    }
+    void Set(int i, int j,int x);
+    int Get(int i, int j);
+    void Display();
+};
+
+void Diagnol::Set(int i, int j,int x)
+{
+    if(i==j)
+      A[i-1]=x;
+}
+
+int Diagnol::Get(int i, int j)
+{
+    if(i==j)
+      return A[i-1];
+    else 
+      return 0;
+}
+
+void Diagnol::Display()
+{
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if(i==j)
+               cout<<A[i]<<" ";
+            else
+            {
+                cout<<"0 ";
+            }
+
+        }
+        cout<<endl;
+
+    }
+
+}
+
+
+int main()
+{
+    Diagnol d(4);
+    d.Set(1,1,5);
+    d.Set(2,2,8);
+    d.Set(3,3,9);
+    d.Set(4,4,12);
+
+    d.Display();
+    return 0;
+}

Algorithms/Find_middle_of_a_linkedlist.cpp

@@ -0,0 +1,45 @@
+#include<iostream>
+using namespace std;
+class node{
+    public:
+int data;
+node *next;//yaha address store karvana tha toh aysy likha
+node(int data){
+    this->data=data;
+    next=NULL;
+}
+};
+node  *middlenode(node *head){
+    node *slow=head;
+    node *fast=head->next;
+    while(fast && fast->next){
+        slow=slow->next;
+        fast=fast->next->next;
+    }
+    if(fast!=NULL){
+        return slow->next;
+    }
+    return slow;
+}
+
+int main(){
+    node n1(81);
+    node n2(27);
+    node n3(56);
+    node *head=&n1;// this head is storing the address of first link list component so that we can access the whole link list through this
+    n1.next=&n2;
+    n2.next=&n3;// this is storing address jaha pehle null stored tha
+
+    cout<<"the middle element is "<<middlenode(head)->data;
+
+
+    return 0;
+
+
+}
+
+
+
+
+
+//The running time of finding the middle element this way with two pointers is O(n) because once we pass through the entire linked list of n elements, the slower pointer is at the middle node already.

Algorithms/Floyd_Warshall.cpp

@@ -0,0 +1,63 @@
+//Problem Statement
+//The Floyd Warshall Algorithm is for solving the All Pairs Shortest Path problem. 
+//The problem is to find shortest distances between every pair of vertices in a given edge weighted directed Graph. 
+//Time Complexity: O(V^3)
+
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<vector<int>> floyd_warshall(vector<vector<int>> graph) {
+	vector<vector<int>> dist(graph);
+
+	int V = graph.size();
+
+	// Iterate over all phases 1,2,....,V
+	for(int k=0;k<V;k++) {
+
+		//Iterate over the 2-D matrix
+		for(int i=0;i<V;i++) {
+			for(int j=0;j<V;j++) {
+
+				// If vertex k is on the shortest path from
+                // i to j, then update the value of dist[i][j]
+				if(dist[i][k]!=INT_MAX && dist[k][j]!=INT_MAX) {
+					if(dist[i][j] > dist[i][k] + dist[k][j]) {
+						dist[i][j] = dist[i][k] + dist[k][j];
+					}
+				} 
+			}
+		}
+	}
+
+	//Check for negative edge cycle
+	for(int i=0;i<V;i++) {
+		if(dist[i][i] < 0) {
+			cout<<"Negative edge cycle detected\n";
+			break;
+		}
+	}
+
+	return dist;
+
+}
+
+int main() {
+	vector<vector<int>> graph = {
+		{0,INT_MAX,-2,INT_MAX},
+		{4,0,3,INT_MAX},
+		{INT_MAX,INT_MAX,0,2},
+		{INT_MAX,-1,INT_MAX,0}
+	};
+
+	auto it = floyd_warshall(graph);
+
+	//The shortest path from ith node to jth node
+	for(int i=0;i<it.size();i++) {
+		for(int j=0;j<it.size();j++) {
+			cout<<it[i][j]<<" ";
+		}
+		cout<<endl;
+	}
+
+	return 0;
+}