Disjoint Set Union

3sum.cpp

@@ -0,0 +1,43 @@
+
+// 3 SUM Solution
+
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        int N = nums.size();
+        vector<vector<int>> result;
+        if (N < 2) {
+            result;
+        }
+        sort(begin(nums), end(nums));
+        for (int i = 0; i < N - 2 && nums[i] <= 0; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+            int j = i + 1;
+            int k = N - 1;
+            while (j < k) {
+                int sum = nums[i] + nums[j] + nums[k];
+                if (sum < 0) {
+                    j++;
+                }
+                else if (sum > 0) {
+                    k--;
+                }
+                else {
+                    result.push_back({nums[i], nums[j], nums[k]});
+                    k--;
+                    while (j < k && nums[k] == nums[k + 1]) {
+                        k--;
+                    }
+                    j++;
+                    while (j < k && nums[j] == nums[j - 1]) {
+                        j++;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};

AnagramOfStrings.java

@@ -0,0 +1,39 @@
+# This is the code for finding anagram of the string in java
+
+//Anagram : a word or phrase that is made by arranging the letters of another word or phrase in a different order
+//Example: "Worth" is an anagram of ‘throw’.
+//This java anagram program compares the letters of both words/strings entered and then shows
+//wheather they are anagram of each other or not
+
+import java.util.Scanner;
+public class AnagramOfStrings {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("Enter first string : ");
+		String a = sc.nextLine();
+		System.out.print("Enter second string : ");
+		String b = sc.nextLine();
+
+		boolean isAnagram = false;
+		boolean visited[] = new boolean[b.length()];
+
+		if (a.length()==b.length()) {
+			for (int i=0; i<a.length(); i++) {
+				isAnagram = false;
+				for (int j=0; j<b.length(); j++) {
+					if (a.charAt(i)==b.charAt(j) && !visited[j]) {
+						isAnagram = true;
+						visited [j] = true;
+						break;
+					}
+				}if (!isAnagram) break;
+			}
+		}
+		if (isAnagram) System.out.println("an anagram");
+		else System.out.println("not an anagram");
+	}
+
+}
+
+

Armstrong Number.cpp

@@ -0,0 +1,20 @@
+#include <iostream>  
+using namespace std;  
+int main()  
+{  
+int n,r,sum=0,temp;    
+cout<<"Enter the Number=  ";    
+cin>>n;    
+temp=n;    
+while(n>0)    
+{    
+r=n%10;    
+sum=sum+(r*r*r);    
+n=n/10;    
+}    
+if(temp==sum)    
+cout<<"Armstrong Number."<<endl;    
+else    
+cout<<"Not Armstrong Number."<<endl;   
+return 0;  
+}  

Billing systems

@@ -0,0 +1,68 @@
+#include<iostream>
+using namespace std;
+
+double getUnitprice(int itemCode);
+
+int main(){
+
+  double invoice[10][4];
+  int i=0; char more; char date[100];
+
+  cout << "\n\n********* Here are the Item prices for your information********** \n\nItem code\tUnitPrice\n\n1\t100\n2\t200\n3\t300\nInvalidCode\t0\n\n";
+  cout << "Enter the date: ";
+  cin >> date;
+
+  do {
+
+    cout << "\n\nItem code: ";
+    cin >> invoice[i][0];
+    cout << "Quantity : ";
+    cin >> invoice[i][1];
+
+    invoice[i][2] = getUnitprice(invoice[i][0]); 
+    invoice[i][3] = invoice[i][1] * invoice[i][2]; 
+
+    cout << "Do you have any other items to be entered next (y/n) ? ";
+    cin >> more;
+
+    i++;
+  } while(more == 'y');
+
+
+  cout << "\n\n-----------------------------\n\n";
+  cout << "Date : " << date << "\n\n";
+
+  cout << "ItemCode|Quantity|UnitPrice|TotalPrice\n\n";
+  int tot=0;
+  for(int k=0; k<i; k++)   
+
+	{
+		for(int l=0; l<4; l++) 
+		{
+		    cout << invoice[k][l]  << "\t";		   
+		}
+		cout << endl;
+		tot = tot + invoice[k][3];
+	}
+
+  cout << "\n\nTotal : " << tot;
+  cout << "\n\n-----------------------------\n\n\n";
+
+  return 0;
+}
+
+double getUnitprice(int itemCode){
+  double price;
+  switch (itemCode)
+  {
+    case 1: price = 100;
+      break; 
+    case 2: price = 200;
+      break;
+    case 3: price = 300;
+      break;
+    default: price = 0;
+      break;
+  }
+  return price;
+}

Binary search

@@ -0,0 +1,36 @@
+#include <iostream>
+
+using namespace std;
+int binary(int arr[],int p,int q,int x){
+    int mid;
+    mid=(p+q)/2;
+    if(p<=q){
+    if(arr[mid]==x){
+    return mid;
+}
+    else if(arr[mid]>x){ 
+    binary(arr,mid+1,q,x);
+    }
+    else{
+    binary(arr,p,mid-1,x);
+    }
+    }
+
+        return -1;
+}
+
+int main()
+{
+    int m,n,i,x,s,r;
+    cin>>r>>x;
+    m=0,n=r-1;
+    int a[r];
+    for(i=0;i<r;i++)
+    cin>>a[i];
+   s=binary(a,m,n,x);
+   cout<<"searching element is present in index "<<s;
+
+
+
+    return 0;
+}

Binomial Coefficients

@@ -0,0 +1,8 @@
+const int maxn = ...;
+int C[maxn + 1][maxn + 1];
+C[0][0] = 1;
+for (int n = 1; n <= maxn; ++n) {
+    C[n][0] = C[n][n] = 1;
+    for (int k = 1; k < n; ++k)
+        C[n][k] = C[n - 1][k - 1] + C[n - 1][k];
+}

Bitonic Sort

@@ -0,0 +1,59 @@
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void compAndSwap(int a[], int i, int j, int dir)
+{
+    if (dir==(a[i]>a[j]))
+        swap(a[i],a[j]);
+}
+
+void bitonicMerge(int a[], int low, int cnt, int dir)
+{
+    if (cnt>1)
+    {
+        int k = cnt/2;
+        for (int i=low; i<low+k; i++)
+            compAndSwap(a, i, i+k, dir);
+        bitonicMerge(a, low, k, dir);
+        bitonicMerge(a, low+k, k, dir);
+    }
+}
+
+void bitonicSort(int a[],int low, int cnt, int dir)
+{
+    if (cnt>1)
+    {
+        int k = cnt/2;
+
+        // sort in ascending order since dir here is 1
+        bitonicSort(a, low, k, 1);
+
+        // sort in descending order since dir here is 0
+        bitonicSort(a, low+k, k, 0);
+
+        // Will merge whole sequence in ascending order
+        // since dir=1.
+        bitonicMerge(a,low, cnt, dir);
+    }
+}
+
+void sort(int a[], int N, int up)
+{
+    bitonicSort(a,0, N, up);
+}
+
+// Driver code
+int main()
+{
+    int a[]= {3, 7, 4, 8, 6, 2, 1, 5};
+    int N = sizeof(a)/sizeof(a[0]);
+
+    int up = 1;   // means sort in ascending order
+    sort(a, N, up);
+
+    printf("Sorted array: \n");
+    for (int i=0; i<N; i++)
+        printf("%d ", a[i]);
+    return 0;
+}

Bubble sorting

@@ -0,0 +1,29 @@
+#include<iostream>
+using namespace std;
+int main ()
+{
+   int i, j,temp,pass=0;
+   int a[10] = {10,2,0,14,43,25,18,1,5,45};
+   cout <<"Input list ...\n";
+   for(i = 0; i<10; i++) {
+      cout <<a[i]<<"\t";
+   }
+cout<<endl;
+for(i = 0; i<10; i++) {
+   for(j = i+1; j<10; j++)
+   {
+      if(a[j] < a[i]) {
+         temp = a[i];
+         a[i] = a[j];
+         a[j] = temp;
+      }
+   }
+pass++;
+}
+cout <<"Sorted Element List ...\n";
+for(i = 0; i<10; i++) {
+   cout <<a[i]<<"\t";
+}
+cout<<"\nNumber of passes taken to sort the list:"<<pass<<endl;
+return 0;
+}

BubbleSort.java

@@ -0,0 +1,43 @@
+
+
+//WHAT IS BUBBLE SORT:
+//Bubble Sort is one of the simplest sorting techniques in Java to sort the array elements. 
+//The swapping of elements continues until the array is sorted and no more swapping is required. 
+//We can also sort the elements in the descending order in which the smallest element goes at the end of the array in each iteration.
+//THIS EXPLAINATION IS PROVIDED TO HELP BEGGINNER'S UNDERSTAND THE CODE
+
+
+
+
+package arrays;
+
+public class BubbleSort {
+
+	public static void main(String[] args) {
+		int a[] = {3, 1, -2, 7, 4, 0};
+		int n = a.length;
+
+		for (int i=0; i<n-1; i++) {
+			int minimumIndex = i;
+
+			for (int j=i; j<n; j++) {
+				if (a[j]<a[minimumIndex]) {
+					minimumIndex = j;
+
+				}
+
+			}
+			int temp = a[i];
+			a[i] = a[minimumIndex];
+			a[minimumIndex] = temp;
+
+
+
+		}
+		for (int e:a) {
+			System.out.print(e+"  ");
+		}
+
+	}
+
+}

Bucket sort

@@ -0,0 +1,40 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+using namespace std;
+void display(float *array, int size) {
+   for(int i = 0; i<size; i++)
+      cout << array[i] << " ";
+   cout << endl;
+}
+void bucketSort(float *array, int size) {
+   vector<float> bucket[size];
+   for(int i = 0; i<size; i++)  {          //put elements into different buckets
+      bucket[int(size*array[i])].push_back(array[i]);
+   }
+   for(int i = 0; i<size; i++) {
+      sort(bucket[i].begin(), bucket[i].end());       //sort individual vectors
+   }
+   int index = 0;
+   for(int i = 0; i<size; i++) {
+      while(!bucket[i].empty()) {
+         array[index++] = *(bucket[i].begin());
+         bucket[i].erase(bucket[i].begin());
+      }
+   }
+}
+int main() {
+   int n;
+   cout << "Enter the number of elements: ";
+   cin >> n;
+   float arr[n];     //create an array with given number of elements
+   cout << "Enter elements:" << endl;
+   for(int i = 0; i<n; i++) {
+      cin >> arr[i];
+   }
+   cout << "Array before Sorting: ";
+   display(arr, n);
+   bucketSort(arr, n);
+   cout << "Array after Sorting: ";
+   display(arr, n);
+}