diff --git "a/#include <stdio.h>  int main() {     int i, j, n;      printf(\"Enter value of n : \");     scanf(\"%d\", &n);      for(i=n/heart star pattern" "b/#include <stdio.h>  int main() {     int i, j, n;      printf(\"Enter value of n : \");     scanf(\"%d\", &n);      for(i=n/heart star pattern"
new file mode 100644
index 00000000..0e5890fc
--- /dev/null
+++ "b/#include <stdio.h>  int main() {     int i, j, n;      printf(\"Enter value of n : \");     scanf(\"%d\", &n);      for(i=n/heart star pattern"	
@@ -0,0 +1,51 @@
+#include <stdio.h>
+
+int main()
+{
+    int i, j, n;
+
+    printf("Enter value of n : ");
+    scanf("%d", &n);
+
+    for(i=n/2; i<=n; i+=2)
+    {
+        for(j=1; j<n-i; j+=2)
+        {
+            printf(" ");
+        }
+
+        for(j=1; j<=i; j++)
+        {
+            printf("*");
+        }
+
+        for(j=1; j<=n-i; j++)
+        {
+            printf(" ");
+        }
+
+        for(j=1; j<=i; j++)
+        {
+            printf("*");
+        }
+
+        printf("\n");
+    }
+
+    for(i=n; i>=1; i--)
+    {
+        for(j=i; j<n; j++)
+        {
+            printf(" ");
+        }
+
+        for(j=1; j<=(i*2)-1; j++)
+        {
+            printf("*");
+        }
+
+        printf("\n");
+    }
+
+    return 0;
+}
diff --git a/02 rotated_search.cpp b/02 rotated_search.cpp
new file mode 100644
index 00000000..2dd01da4
--- /dev/null
+++ b/02 rotated_search.cpp	
@@ -0,0 +1,57 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+int rotated_search(vector<int> a,int key) {
+	int n = a.size();
+
+	//Logic
+	int s = 0;
+	int e = n - 1;
+
+	while(s<=e){
+		int mid = (s+e)/2;
+
+		if(a[mid]==key){
+			return mid;
+		}
+
+		//2 cases
+		if(a[s]<=a[mid]){
+			//left
+			if(key>=a[s] and key<=a[mid]){
+				e = mid - 1;
+			}
+			else{
+				s = mid + 1;
+			}
+
+		}
+		else{
+			//right
+
+			if(key>=a[mid] and key<=a[e]){
+				s = mid + 1;
+			}
+			else{
+				e = mid - 1;
+			}
+
+		}
+
+	}
+	return -1;
+
+}
+
+
+
+int main() {
+
+	
+	vector<int> a{4,5,6,7,0,1,2,3};
+	int key;
+	cin>>key;
+	cout<< rotated_search(a,key) <<endl;
+	return 0;
+}
\ No newline at end of file
diff --git a/3.1 Jumpsinloops.pdf b/3.1 Jumpsinloops.pdf
new file mode 100644
index 00000000..f3e1c8b3
Binary files /dev/null and b/3.1 Jumpsinloops.pdf differ
diff --git a/3.2 Switch-Case statement.pdf b/3.2 Switch-Case statement.pdf
new file mode 100644
index 00000000..08edcf89
Binary files /dev/null and b/3.2 Switch-Case statement.pdf differ
diff --git a/3sum.cpp b/3sum.cpp
new file mode 100644
index 00000000..899d65e9
--- /dev/null
+++ b/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;
+    }
+};
diff --git a/AGGRCOW.cpp b/AGGRCOW.cpp
new file mode 100644
index 00000000..bb333aa6
--- /dev/null
+++ b/AGGRCOW.cpp
@@ -0,0 +1,72 @@
+
+#include <bits/stdc++.h>
+using namespace std;
+#define endl '\n'
+#define vi vector<int>
+#define pii pair<int, int>
+#define all(c) c.begin(), c.end()
+#define pb push_back
+#define f first
+#define s second
+#define int long long
+#define fo(i, n) for (int i = 0; i < n; i++)
+#define IOS ios::sync_with_stdio(0);
+vector<int> arr(100100);
+int n,c;
+
+bool check(int x){
+    int sum =0;int count = 1;
+    int left =0;
+    for(int i =1; i<n;i++){
+        sum += arr[i]-arr[i-1];
+        if(sum >= x)
+        {
+            count++;
+            sum=0;
+        }
+    }
+    return (count >=   c);
+}
+void solve();
+signed main()
+{
+
+    IOS
+    cin.tie(0);
+    cout.tie(0);
+
+    int _t;cin >> _t;while (_t--) solve();
+    
+    }
+
+
+void solve(){
+    cin>>n>>c;
+    arr.resize(n);
+
+    for(int i = 0; i<n;i++){
+        cin>>arr[i];
+    }
+    sort(arr.begin(),arr.end());
+    
+    int hi=0; int lo =0 ;
+    for(int i =1; i<n;i++){
+        hi =max(arr[i]-arr[i-1],hi);
+        lo = min(arr[i]-arr[i-1],lo);
+    }
+    int ans =lo;
+    while(hi>= lo){
+        int mid =lo + (hi-lo)/2;
+
+        if(check(mid)){
+            lo =mid+1;
+            ans  = mid;
+        }
+        else{
+           
+           hi = mid-1;
+        }
+    }
+    cout<<ans<<endl;
+    
+}
\ No newline at end of file
diff --git a/Abstract data types b/Abstract data types
new file mode 100644
index 00000000..abfa4598
--- /dev/null
+++ b/Abstract data types	
@@ -0,0 +1,66 @@
+#include<iostream>
+#include<stdlib.h>
+using namespace std;
+struct stocked{
+	int stcks[5];
+	int topq;};
+stocked stonks;
+int main(){
+	int pili,takbo,numstock; bool runner=true;stonks.topq=-1;
+		while(runner){
+cout << "      #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" <<"\n";	
+cout << "      #- - -  Abstract Data Types  - - -#" <<"\n";
+cout << "      # - - -   STACK OPERATION   - - - #" <<"\n";
+cout << "      #  - -    [1] PUSH           - -  #" <<"\n";
+cout << "      # - - -   [2] POP           - - - #" <<"\n"; 
+cout << "      #  - -    [3] DISPLAY        - -  #" <<"\n";
+cout << "      #-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#" <<"\n";	
+cout << "      #Choose [1-3]: ";	
+		cin >> pili;
+	switch(pili){
+	case 1: {
+ 				if(stonks.topq == (5-1)){
+ 				cout <<"\n" <<"\n";
+cout << "      ! ! ! ! ! -STACK IS FULL- ! ! ! ! !" <<"\n";
+} else{  system("cls");
+cout << "      - - - - - - - - - - - - - - - - - -" <<"\n";
+cout << "      -Element to Push: ";
+	cin >> numstock;
+cout << "      - - - - - - - - - - - - - - - - - -" <<"\n";
+	stonks.topq=stonks.topq +1;
+stonks.stcks[stonks.topq]=numstock;
+cout <<"\n";
+cout << "      - - - - - - - - - - - - - - - - - -" <<"\n";	
+cout << "       - - - - - - PUSH ADDED- - - - - -" <<"\n";
+cout << "      - - - - - - - - - - - - - - - - - -" <<"\n";	} break;}
+case 2: { 
+if(stonks.topq == -1){
+cout <<"\n" <<"\n";
+cout << "      ! ! ! ! ! -STACK IS EMPTY- ! ! ! ! !" <<"\n";		}
+else{	system("cls");
+numstock = stonks.stcks[stonks.topq];
+cout << "      + + + + + + + + + + + + + + + + + + +" <<"\n";		
+cout << "      +         POP Element: " << stonks.stcks[stonks.topq] << "            +";
+stonks.topq = stonks.topq-1;		}
+cout << "\n";
+cout << "      + + + + + + + + + + + + + + + + + + +" <<"\n" <<"\n"; break; }
+case 3: {system("cls");
+if(stonks.topq == -1){
+cout << "     / / / / / / / / / / / / / / / / / / /" <<"\n";
+cout << "      ! ! ! ! ! -STACK IS EMPTY- ! ! ! ! !" <<"\n";
+cout << "     / / / / / / / / / / / / / / / / / / /" <<"\n";}	
+else{cout <<"\n"; 
+cout << "     - - - - - - - - - - - - - - - - - - - - - -" <<"\n";	
+for(numstock=stonks.topq; numstock>=0; numstock--){
+cout <<"    "; cout << " ["<< stonks.stcks[numstock] <<"] " << " " ;} }cout <<"\n"; 
+cout << "     - - - - - - - - - - - - - - - - - - - - - -" <<"\n";	break;}
+default:{cout << "\n";
+cout <<"     ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" <<"\n"; 
+cout <<"    | | | | | | |ERROR: ONLY [1-3]| | | | | | | |" <<"\n"; 
+cout <<"     ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" <<"\n" << "\n";break; }}
+cout<<"\n" <<"\n";
+cout<<  "      -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-" << "\n";		
+cout<<  "      #    Back to MAIN MENU [0 | 1]?   #" <<"\n";
+cout<<  "                       "; cin>>takbo;   if(takbo==1){  }else{ runner=false; } system("cls");
+}
+system(“pause”);
diff --git a/Add 3 numbers b/Add 3 numbers
new file mode 100644
index 00000000..2853a4e1
--- /dev/null
+++ b/Add 3 numbers	
@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+  double num1, num2,num3, Sum;
+  cout << "Enter three numbers: ";
+
+  // stores two floating point numbers in num1 and num2 respectively
+  cin >> num1 >> num2>>num3;
+ 
+  // performs multiplication and stores the result in product variable
+  product = num1 + num2 + num3;  
+
+  cout << "Sum = " << Sum;    
+    
+  return 0;
+}
diff --git a/AllocateMinNoOfPages b/AllocateMinNoOfPages
new file mode 100644
index 00000000..a97df794
--- /dev/null
+++ b/AllocateMinNoOfPages
@@ -0,0 +1,42 @@
+class AllocateMinNoOfPages 
+{
+    public static int findPages(int[]A,int N,int M)
+    {
+        int sum = 0;
+        int maxNum = 0;
+        for(int i = 0;i<N;i++){
+            sum+=A[i];
+            maxNum = Math.max(maxNum,A[i]);
+        }
+        
+        int low = maxNum;
+        int high = sum;
+        int res = -1;
+        while(low<=high){
+            int mid = low+(high-low)/2;
+            if(isValid(A,N,M,mid)){
+                res = mid;
+                high = mid-1;
+            }else{
+                low = mid+1;
+            }
+        }
+        return res;
+        
+    }
+    public static boolean isValid(int[] A,int N,int M,int max){
+        int student = 1;
+        int s = 0;
+        for(int i = 0;i<N;i++){
+            s+=A[i];
+            if(s>max){
+                student++;
+                s = A[i];
+            }
+            if(student>M){
+                return false;
+            }
+            }
+            return true;
+        }
+    };
diff --git a/AnagramOfStrings.java b/AnagramOfStrings.java
new file mode 100644
index 00000000..6875c13b
--- /dev/null
+++ b/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");
+	}
+		
+}
+
+
diff --git a/AntonsLetters b/AntonsLetters
new file mode 100644
index 00000000..b7224718
--- /dev/null
+++ b/AntonsLetters
@@ -0,0 +1,16 @@
+#include <iostream>
+#include <set>
+using namespace std;
+int main(){
+    set<int> ss;
+    string s;
+    getline (cin, s);
+    for (int i=0; s[i]!='\0';i++){
+        if (s[i]!='{' && s[i]!=',' && s[i]!=' ' && s[i]!='}'){
+            int x = int (s[i]);
+            ss.insert(x);
+        }
+    }
+    int size=int(ss.size());
+    cout <<size;
+}
diff --git a/Armstrong Number.cpp b/Armstrong Number.cpp
new file mode 100644
index 00000000..9426ee80
--- /dev/null
+++ b/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;  
+}  
\ No newline at end of file
diff --git a/Arrival of general codeforces b/Arrival of general codeforces
new file mode 100644
index 00000000..6482819d
--- /dev/null
+++ b/Arrival of general codeforces	
@@ -0,0 +1,64 @@
+#include <iostream>
+using namespace std;
+
+int main(){
+        int n,max=0,min=0,count=0,temp,i;
+        cin >>n;
+        int arr[n];
+
+        //cout <<n;
+        cin >>arr[0];
+        min=arr[0];
+        max=arr[0];
+       // cout <<arr[0];
+        for ( i=1;i<n;i++){
+           // cout <<i<<endl;
+           //cout <<n<<" ";
+            cin >>arr[i];
+         //   cout <<endl<<arr[i];
+
+        }
+        //cout <<n;
+        //cout <<arr[n-1];
+
+        /*for (int i=0;i<n;i++){
+            cout <<arr[i]<<" ";
+        }*/
+
+         for (int i=1;i<n;i++){
+
+            if (arr[i]>max){
+                max=arr[i];
+            }
+            if (arr[i]<min){
+                min=arr[i];
+            }
+
+            }
+
+
+        for (int i=0;i<n;i++){
+            if (arr[0]!=max){
+                for (int j=0;arr[j]!=max;j++){
+                    temp=arr[j-1];
+                    arr[j-1]=arr[j];
+                    arr[j]=temp;
+                    count++;
+                }
+            }
+        }
+        for (int i=0;i<n;i++){
+            if(arr[n-1]!=min){
+                for (int j=0;arr[j]!=min;j++){
+                    temp=arr[j+1];
+                    arr[j+1]=arr[j];
+                    arr[j]=temp;
+                    count++;
+                }
+            }
+        }
+
+        //cout <<count;
+
+ return 0;
+}
diff --git a/Billing systems b/Billing systems
new file mode 100644
index 00000000..1610e2bf
--- /dev/null
+++ b/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;
+}
diff --git a/Binary search b/Binary search
new file mode 100644
index 00000000..05ba7527
--- /dev/null
+++ b/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;
+}
diff --git a/Binary_search.py b/Binary_search.py
new file mode 100644
index 00000000..41a46943
--- /dev/null
+++ b/Binary_search.py
@@ -0,0 +1,38 @@
+# Python 3 program for recursive binary search.
+
+# Returns index of x in arr if present, else -1
+def binary_search(arr, low, high, x):
+
+	# Check base case
+	if high >= low:
+
+		mid = (high + low) // 2
+
+		# If element is present at the middle itself
+		if arr[mid] == x:
+			return mid
+
+		# If element is smaller than mid, then it can only
+		# be present in left subarray
+		elif arr[mid] > x:
+			return binary_search(arr, low, mid - 1, x)
+
+		# Else the element can only be present in right subarray
+		else:
+			return binary_search(arr, mid + 1, high, x)
+
+	else:
+		# Element is not present in the array
+		return -1
+
+# Test array
+arr = [ 2, 3, 4, 10, 40 ]
+x = 10
+
+# Function call
+result = binary_search(arr, 0, len(arr)-1, x)
+
+if result != -1:
+	print("Element is present at index", str(result))
+else:
+	print("Element is not present in array")
diff --git a/Binomial Coefficients b/Binomial Coefficients
new file mode 100644
index 00000000..99b96297
--- /dev/null
+++ b/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];
+}
diff --git a/Birthday Cake Hackerrank b/Birthday Cake Hackerrank
new file mode 100644
index 00000000..0c7a5759
--- /dev/null
+++ b/Birthday Cake Hackerrank	
@@ -0,0 +1,19 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{   long i,count=0,max=0;
+    long arr[100000];
+    cin >> i;
+    for (int j=0; j<i;j++){
+        cin >>arr[j];
+    }
+    for (int k=0; k<i;k++){
+        if (arr[k]>max || arr[k]==max){
+            max=arr[k];
+            count++;
+        }
+    }
+    cout <<count;
+
+}
diff --git a/Bitonic Sort b/Bitonic Sort
new file mode 100644
index 00000000..58a3e3d3
--- /dev/null
+++ b/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;
+}
diff --git a/Bubble sort.py b/Bubble sort.py
new file mode 100644
index 00000000..785c8304
--- /dev/null
+++ b/Bubble sort.py	
@@ -0,0 +1,24 @@
+def bubbleSort(arr):
+    n = len(arr)
+  
+    # Traverse through all array elements
+    for i in range(n-1):
+    # range(n) also work but outer loop will repeat one time more than needed.
+ 
+        # Last i elements are already in place
+        for j in range(0, n-i-1):
+ 
+            # traverse the array from 0 to n-i-1
+            # Swap if the element found is greater
+            # than the next element
+            if arr[j] > arr[j + 1] :
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+ 
+# Driver code to test above
+arr = [64, 34, 25, 12, 22, 11, 90]
+ 
+bubbleSort(arr)
+ 
+print ("Sorted array is:")
+for i in range(len(arr)):
+    print ("% d" % arr[i])
diff --git a/Bubble sorting b/Bubble sorting
new file mode 100644
index 00000000..483dc185
--- /dev/null
+++ b/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;
+}
diff --git a/BubbleSort b/BubbleSort
new file mode 100644
index 00000000..eb6f8111
--- /dev/null
+++ b/BubbleSort
@@ -0,0 +1,29 @@
+#include <studio.h>
+
+
+int main()
+{
+    bool swap;
+    int n=5,j;
+    int arr[5]={58,89,71,35,6};
+    
+    
+    do{
+        swap=false;
+        for(j=0;j<n;j++)
+        {
+            if (arr[j]>arr[j-1]);
+            {
+                temp=arr[j];
+                arr[j]=arr[j+1];
+                arr[j+1]=temp
+                swap=false;
+            }
+        }
+    }while(swap);
+    
+    for(m=0;m<n;m--)
+        {
+            printf("%s ",arr[l]);
+        }
+}
diff --git a/BubbleSort.java b/BubbleSort.java
new file mode 100644
index 00000000..68f5c9ee
--- /dev/null
+++ b/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+"  ");
+		}
+			
+	}
+
+}
diff --git a/Bucker-sort b/Bucker-sort
new file mode 100644
index 00000000..90190486
--- /dev/null
+++ b/Bucker-sort
@@ -0,0 +1,44 @@
+# Python3 program to sort an array
+# using bucket sort
+def insertionSort(b):
+	for i in range(1, len(b)):
+		up = b[i]
+		j = i - 1
+		while j >= 0 and b[j] > up:
+			b[j + 1] = b[j]
+			j -= 1
+		b[j + 1] = up	
+	return b	
+			
+def bucketSort(x):
+	arr = []
+	slot_num = 10 # 10 means 10 slots, each
+				# slot's size is 0.1
+	for i in range(slot_num):
+		arr.append([])
+		
+	# Put array elements in different buckets
+	for j in x:
+		index_b = int(slot_num * j)
+		arr[index_b].append(j)
+	
+	# Sort individual buckets
+	for i in range(slot_num):
+		arr[i] = insertionSort(arr[i])
+		
+	# concatenate the result
+	k = 0
+	for i in range(slot_num):
+		for j in range(len(arr[i])):
+			x[k] = arr[i][j]
+			k += 1
+	return x
+
+# Driver Code
+x = [0.897, 0.565, 0.656,
+	0.1234, 0.665, 0.3434]
+print("Sorted Array is")
+print(bucketSort(x))
+
+# This code is contributed by
+# Oneil Hsiao
diff --git a/Bucket sort b/Bucket sort
new file mode 100644
index 00000000..8d8b255a
--- /dev/null
+++ b/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);
+}
diff --git a/CS-450 Find median in row wise sorted matrix.cpp b/CS-450 Find median in row wise sorted matrix.cpp
new file mode 100644
index 00000000..02e7f94e
--- /dev/null
+++ b/CS-450 Find median in row wise sorted matrix.cpp	
@@ -0,0 +1,70 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// 1 3 5
+// 2 6 9
+// 3 6 9
+
+1 2 3 3 5 6 6 9 9
+        |
+//O(32*r*logc) O(1)
+
+//as median is in middle, there will always be (r*c)/2 number of elements less than the median in value... see above 
+
+int main()
+{
+    int r,c;
+    cin>>r>>c;
+
+    int a[r][c];
+    for(int i=0;i<r;i++)
+    {
+        for(int j=0;j<c;j++)
+        {
+            cin>>a[i][j];
+        }
+    }
+
+    int min = INT_MAX, max = INT_MIN;
+    //as rows are sorted... all the minimums will be at start of row and maximums at end of row... so compare them to get min and 
+    //max of matrix in O(n)
+    for(int i=0;i<r;i++)
+    {
+        if(min>a[i][0])
+        {
+            min=a[i][0];
+        }
+
+        if(max<a[i][c-1])
+        {
+            max=a[i][c-1];
+        }
+    }
+
+    int desired=(r*c+1)/2; //desired position of median has to be (r*c+1)/2 as it is in middle of odd number of elements 
+    while(min<max) //as rows are sorted... we can do binary search
+    {
+        int mid = min + (max-min)/2; //we take expected mid... no need for it to be in the matrix
+        int count=0; //stores number of elememts less than expected mid.... so if it is less than desired we can search bigger
+                    //elements than expected mid ...or if greater than desired... we can check smaller elements than mid
+
+        for(int i=0;i<r;i++) //this loop counts the number of elements less than mid in each row of matric
+        {
+            count+=upper_bound(a[i],a[i]+c,mid)-a[i]; //a[i] is address of ith rows beginning... a[i]+c is address of last element of 
+                                                      //ith row... we check between them for mid...and subtract a[i] to get its count.. 
+        }
+
+        if(count<desired) //doing what is explained in 48th line comment
+        {
+            min = mid+1;
+        }
+        else
+        {
+            max=mid;
+        }
+    }
+
+    cout<<min; //at the end min stores the answer
+
+    //DO A DRY RUN TO GET BETTER UNDERSTANDING
+}
\ No newline at end of file
diff --git a/Calculator.cpp b/Calculator.cpp
new file mode 100644
index 00000000..6287cb57
--- /dev/null
+++ b/Calculator.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+    char op;
+    float num1, num2;
+
+    cout << "Enter operator: +, -, *, /: ";
+    cin >> op;
+
+    cout << "Enter two operands: ";
+    cin >> num1 >> num2;
+
+    switch(op) {
+        case '+':
+            cout << num1 << " + " << num2 << " = " << num1 + num2;
+            break;
+
+        case '-':
+            cout << num1 << " - " << num2 << " = " << num1 - num2;
+            break;
+
+        case '*':
+            cout << num1 << " * " << num2 << " = " << num1 * num2;
+            break;
+
+        case '/':
+            cout << num1 << " / " << num2 << " = " << num1 / num2;
+            break;
+
+        default:
+            cout << "Error! operator is not correct";
+            break;
+    }
+
+    return 0;
+}
+
diff --git a/Calculator.html b/Calculator.html
new file mode 100644
index 00000000..28a073ca
--- /dev/null
+++ b/Calculator.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="en" dir="ltr">
+<head>
+ <meta charset="utf-8">
+ <title> Simple Calculator using HTML, CSS and JavaScript </title>
+ <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+<table class = "calculator" >
+ <tr>
+ <td colspan = "3"> <input class = "display-box" type = "text" id = "result" disabled /> </td>
+ <!-- clearScreen() function clear all the values -->
+ <td> <input class = "button" type = "button" value = "C" onclick = "clearScreen()" style = "background-color: #fb0066;" /> </td>
+ </tr>
+ <tr>
+ <!-- display() function display the value of clicked button -->
+ <td> <input class = "button" type = "button" value = "1" onclick = "display('1')" /> </td>
+ <td> <input class = "button" type = "button" value = "2" onclick = "display('2')" /> </td>
+ <td> <input class = "button" type = "button" value = "3" onclick = "display('3')" /> </td>
+ <td> <input class = "button" type = "button" value = "/" onclick = "display('/')" /> </td>
+ </tr>
+ <tr>
+ <td> <input class = "button" type = "button" value = "4" onclick = "display('4')" /> </td>
+ <td> <input class = "button" type = "button" value = "5" onclick = "display('5')" /> </td>
+ <td> <input class = "button" type = "button" value = "6" onclick = "display('6')" /> </td>
+ <td> <input class = "button" type = "button" value = "-" onclick = "display('-')" /> </td>
+ </tr>
+ <tr>
+ <td> <input class = "button" type = "button" value = "7" onclick = "display('7')" /> </td>
+ <td> <input class = "button" type = "button" value = "8" onclick = "display('8')" /> </td>
+ <td> <input class = "button" type = "button" value = "9" onclick = "display('9')" /> </td>
+ <td> <input class = "button" type = "button" value = "+" onclick = "display('+')" /> </td>
+ </tr>
+ <tr>
+ <td> <input class = "button" type = "button" value = "." onclick = "display('.')" /> </td>
+ <td> <input class = "button" type = "button" value = "0" onclick = "display('0')" /> </td>
+ <!-- calculate() function evaluate the mathematical expression -->
+ <td> <input class = "button" type = "button" value = "=" onclick = "calculate()" style = "background-color: #fb0066;" /> </td>
+ <td> <input class = "button" type = "button" value = "*" onclick = "display('*')" /> </td>
+ </tr>
+ </table>
+<script type="text/javascript" src="script.js"></script>
+</body>
+</html>
diff --git a/Calculator.java b/Calculator.java
new file mode 100644
index 00000000..eff2ef0e
--- /dev/null
+++ b/Calculator.java
@@ -0,0 +1,60 @@
+import java.awt.*;
+import java.awt.event.*;
+class calc implements ActionListener
+{
+Frame f=new Frame();
+Label l1=new Label("enter number ");
+Label l2=new Label("enter number ");
+Label l3=new Label("result");
+TextField t1=new TextField();
+TextField t2=new TextField();
+TextField t3=new TextField();
+Button b1=new Button("ADD");
+Button b2=new Button("SUB");
+Button b3=new Button("MUL");
+Button b4=new Button("DIV");
+calc() {
+l1.setBounds(50,100,100,20);
+l2.setBounds(50,150,100,20);
+l3.setBounds(50,200,100,20);
+t1.setBounds(200,100,100,20);
+t2.setBounds(200,150,100,20);
+t3.setBounds(200,200,100,20);
+b1.setBounds(50,250,50,20);
+b2.setBounds(110,250,50,20);
+b3.setBounds(170,250,50,20);
+b4.setBounds(230,250,50,20);
+f.add(l1);
+f.add(l2);
+f.add(t1);
+f.add(t2);
+f.add(t3);
+f.add(b1);
+f.add(b2);
+f.add(b3);
+f.add(b4);
+b1.addActionListener(this);
+b2.addActionListener(this);
+b3.addActionListener(this);
+b4.addActionListener(this);
+f.setLayout(null);
+f.setVisible(true);
+f.setSize(500,500); }
+public void actionPerformed(ActionEvent e){
+int i=Integer.parseInt(t1.getText());
+int j=Integer.parseInt(t2.getText());
+if(e.getSource()==b1) {
+t3.setText(String.valueOf(i+j)); }
+if(e.getSource()==b2) {
+t3.setText(String.valueOf(i-j)); }
+if(e.getSource()==b3)
+{
+t3.setText(String.valueOf(i*j));
+}
+if(e.getSource()==b4)
+{
+t3.setText(String.valueOf(i/j)); }
+}
+public static void main(String args[]) {
+new calc();
+}}
diff --git a/Ceiling sum.cpp b/Ceiling sum.cpp
new file mode 100644
index 00000000..f7ea5d9c
--- /dev/null
+++ b/Ceiling sum.cpp	
@@ -0,0 +1,36 @@
+#include<bits/stdc++.h>
+using namespace std ;
+
+#define  ff      first 
+#define  ss      second
+#define  ull     unsigned long long 
+#define  mod     1000000007
+#define  inf     1e18
+#define  w(x)    int x;cin>>x;while(x--)
+#define  f(x,y)  for( x=0;x<y;x++) 
+
+int main(){
+    w(t){
+        double a,b, s1,s2;
+        long long x;
+        cin>>a>>b;
+            s1=ceil((b-(a-1))/2)+ceil(((a-1)-a)/2);
+            s2=ceil((b-(a+1))/2)+ceil(((a+1)-a)/2);
+            // cout<<"i is "<<i<<" ";
+            // cout<<"s1 is"<<s1<<"s2 is"<<s2<<endl;
+            // maximum=ceil(s1)+ceil(s2);
+            if(a==b){
+                x=0;
+            }
+            else if(a>b){
+                x=s1;
+            }
+            else{
+                x=s2;
+            }        cout<<x<<endl;
+        }
+
+
+
+ 	return 0;
+}
diff --git a/Chaining b/Chaining
new file mode 100644
index 00000000..f1dfc416
--- /dev/null
+++ b/Chaining
@@ -0,0 +1,79 @@
+#include <iostream>
+using namespace std;
+struct node
+{
+	node *next;
+	int data;
+};
+node* create(int data)
+{
+	node* newnode = new node;
+	newnode->next = NULL;
+	newnode->data = data;
+	return newnode;
+}
+
+
+void display(node* current, int index) {
+	cout << "Data of Index: " << index << endl;
+	while (current != NULL) {
+		cout << current->data << " ";
+		current = current->next;
+	}
+	cout << endl;
+}
+int hashfun(int y, int size)
+{
+	int m = y % size;
+	return m;
+}
+
+node **head;
+
+int main()
+{
+	int size, size1, index;
+	int data;
+	cout << "Enter size of array:" << endl;
+	cin >> size;
+	head = new node *[size];
+	for (int i = 0; i < size; i++)
+	{
+		head[i] = nullptr;
+	}
+	cout << "How Much Data You Want to Enter\n";
+	cin >> size1;
+
+
+	for (int i = 0; i < size1; i++)
+	{
+		cout << "Enter Data to Store: ";
+		cin >> data;
+		index = hashfun(data, size);
+		cout << index;
+		if (head[index] == NULL)
+		{
+			head[index] = create(data);
+
+		}
+		else 
+		{
+			node *temp = head[index];
+			while (temp->next != NULL)
+			{
+				temp = temp->next;
+			}
+			temp->next = create(data);
+		}
+
+	}
+
+	for (int i = 0; i < size; i++)
+	{
+		display(head[i], i);
+
+	}
+
+	system("pause");
+}
+
diff --git a/CodeChef-Youtube-Practice-Problem-Contest-Solution b/CodeChef-Youtube-Practice-Problem-Contest-Solution
new file mode 160000
index 00000000..246be171
--- /dev/null
+++ b/CodeChef-Youtube-Practice-Problem-Contest-Solution
@@ -0,0 +1 @@
+Subproject commit 246be1711ffecb01114e5e986e25ba17a0bb0b00
diff --git a/Compare strings lexicographically b/Compare strings lexicographically
new file mode 100644
index 00000000..261ea9e0
--- /dev/null
+++ b/Compare strings lexicographically	
@@ -0,0 +1,43 @@
+// Java program to Compare two strings lexicographically
+class Compare {
+	public static int stringCompare(String str1,
+									String str2)
+	{
+		for (int i = 0; i < str1.length() &&
+					i < str2.length(); i++) {
+			if ((int)str1.charAt(i) ==
+				(int)str2.charAt(i)) {
+				continue;
+			}
+			else {
+				return (int)str1.charAt(i) -
+					(int)str2.charAt(i);
+			}
+		}
+		if (str1.length() < str2.length()) {
+			return (str1.length()-str2.length());
+		}
+		else if (str1.length() > str2.length()) {
+			return (str1.length()-str2.length());
+		}
+
+		else {
+			return 0;
+		}
+	}
+
+	// Driver function 
+	public static void main(String args[])
+	{
+		String string1 = new String("Heyyy");
+		String string2 = new String("Coders");
+		String string3 = new String("practice coding");
+		String string4 = new String("coding");
+
+		System.out.println(stringCompare(string1,	string2));
+		System.out.println(stringCompare(string1,	string3));
+		System.out.println(stringCompare(string2, string1));
+		System.out.println(stringCompare(string1,	string4));
+		System.out.println(stringCompare(string4,	string1));
+	}
+}
diff --git a/Container with Most Water b/Container with Most Water
new file mode 100644
index 00000000..9f07b82f
--- /dev/null
+++ b/Container with Most Water	
@@ -0,0 +1,34 @@
+//Container with Most Water
+
+// C++ code for Max
+// Water Container
+#include <iostream>
+using namespace std;
+ 
+int maxArea(int A[], int len)
+{
+    int area = 0;
+    for (int i = 0; i < len; i++) {
+        for (int j = i + 1; j < len; j++) {
+            // Calculating the max area
+            area = max(area, min(A[j], A[i]) * (j - i));
+        }
+    }
+    return area;
+}
+ 
+// Driver code
+int main()
+{
+    int a[] = { 1, 5, 4, 3 };
+    int b[] = { 3, 1, 2, 4, 5 };
+ 
+    int len1 = sizeof(a) / sizeof(a[0]);
+    cout << maxArea(a, len1);
+ 
+    int len2 = sizeof(b) / sizeof(b[0]);
+    cout << endl << maxArea(b, len2);
+}
+Output: 
+6
+12
diff --git a/Count_Primes.cpp b/Count_Primes.cpp
new file mode 100644
index 00000000..411a2444
--- /dev/null
+++ b/Count_Primes.cpp
@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int countPrimes(int n){
+    bool p[n+1] = {false};
+        //p[0] = false, p[1] = false;
+        for(int i=2;i<n;i++){
+            p[i] = true;
+        }
+        
+    if(n<2){
+        return 0;
+    }    
+    else{
+        int cnt = 0;
+        for(int i=2;i*i<=n;i++){
+            if(p[i] == true){
+                for(int j=i*i;j<=n; j += i){
+                    p[j] = false;
+                }
+            }    
+        }
+        for(int i=0;i<n;i++){
+            if(p[i]==true){
+                cnt++;
+            }
+        }
+        return cnt;
+    }    
+}
+    
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+    int n;
+    cin>>n;
+    cout<<countPrimes(n);
+    }
+    return 0; 
+}    
diff --git a/Count_inversion.cpp b/Count_inversion.cpp
new file mode 100644
index 00000000..98d2badd
--- /dev/null
+++ b/Count_inversion.cpp
@@ -0,0 +1,35 @@
+//The number of switches required to make an array sorted is termed as inversion count
+#include<iostream>
+ 
+using namespace std;
+ 
+int CountInversion(int a[], int n)
+{
+	int i, j, count = 0;
+	for(i = 0; i < n; i++)
+	{
+		for(j = i+1; j < n; j++)
+			if(a[i] > a[j])
+				count++;
+	}
+	return count;
+}
+ 
+int main()
+{
+	int n, i;
+	cout<<"\nEnter the number of data element: ";
+	cin>>n;
+ 
+	int arr[n];
+	for(i = 0; i < n; i++)
+	{
+		cout<<"Enter element "<<i+1<<": ";
+		cin>>arr[i];
+	}
+ 
+	// Printing the number of  inversion in the array.
+	cout<<"\nThe number of  inversion in the array: "<<CountInversion(arr, n);
+ 
+	return 0;
+}
\ No newline at end of file
diff --git a/Count_of_Set_Bits.cpp b/Count_of_Set_Bits.cpp
new file mode 100644
index 00000000..64b4b256
--- /dev/null
+++ b/Count_of_Set_Bits.cpp
@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int countbit(uint32_t n) {
+        int cnt = 0,f = 1;
+        // Method - 1
+        // while(n>0){
+        //     if(n & f == 1){
+        //         cnt++;
+        //     }
+        //     n = n>>1;
+        // }
+        // Method - 2
+        while(n>0){
+            cnt++;
+            n = n & (n-1);
+        }
+        return cnt;
+  } 
+
+
+int main()   
+{    
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int n,cnt=0;
+        cin >>n;
+        cout<<countbit(n)<<endl;
+        
+    }
+    return 0;
+}    
diff --git a/DPknpSk.py b/DPknpSk.py
new file mode 100644
index 00000000..1c02f197
--- /dev/null
+++ b/DPknpSk.py
@@ -0,0 +1,30 @@
+# A Dynamic Programming based Python
+# Program for 0-1 Knapsack problem
+# Returns the maximum value that can
+# be put in a knapsack of capacity W
+
+
+def knapSack(W, wt, val, n):
+	K = [[0 for x in range(W + 1)] for x in range(n + 1)]
+
+	# Build table K[][] in bottom up manner
+	for i in range(n + 1):
+		for w in range(W + 1):
+			if i == 0 or w == 0:
+				K[i][w] = 0
+			elif wt[i-1] <= w:
+				K[i][w] = max(val[i-1]
+						+ K[i-1][w-wt[i-1]],
+							K[i-1][w])
+			else:
+				K[i][w] = K[i-1][w]
+
+	return K[n][W]
+
+
+# Driver code
+val = [60, 100, 120]
+wt = [10, 20, 30]
+W = 50
+n = len(val)
+print(knapSack(W, wt, val, n))
diff --git a/Difference using without - operator b/Difference using without - operator
new file mode 100644
index 00000000..c5e4a733
--- /dev/null
+++ b/Difference using without - operator	
@@ -0,0 +1,12 @@
+#include<stdio.h>
+ 
+int main() {
+   int a, b;
+ 
+   printf("\nEnter two no: ");
+   scanf("%d %d", &a, &b);
+ 
+   printf("Difference is  : %d", (a + ~b + 1));
+ 
+   return 0;
+}
diff --git a/Divide and Conquer DP b/Divide and Conquer DP
new file mode 100644
index 00000000..7beec22e
--- /dev/null
+++ b/Divide and Conquer DP	
@@ -0,0 +1,35 @@
+int m, n;
+vector<long long> dp_before(n), dp_cur(n);
+
+long long C(int i, int j);
+
+// compute dp_cur[l], ... dp_cur[r] (inclusive)
+void compute(int l, int r, int optl, int optr) {
+    if (l > r)
+        return;
+
+    int mid = (l + r) >> 1;
+    pair<long long, int> best = {LLONG_MAX, -1};
+
+    for (int k = optl; k <= min(mid, optr); k++) {
+        best = min(best, {(k ? dp_before[k - 1] : 0) + C(k, mid), k});
+    }
+
+    dp_cur[mid] = best.first;
+    int opt = best.second;
+
+    compute(l, mid - 1, optl, opt);
+    compute(mid + 1, r, opt, optr);
+}
+
+int solve() {
+    for (int i = 0; i < n; i++)
+        dp_before[i] = C(0, i);
+
+    for (int i = 1; i < m; i++) {
+        compute(0, n - 1, 0, n - 1);
+        dp_before = dp_cur;
+    }
+
+    return dp_before[n - 1];
+}
diff --git a/Easy shopping code in C b/Easy shopping code in C
new file mode 100644
index 00000000..1486f67b
--- /dev/null
+++ b/Easy shopping code in C	
@@ -0,0 +1,29 @@
+#include<stdio.h>
+long long int reverse (long long int number)
+{
+    long long int reversed = 0;
+    while(number > 0)
+    {
+        reversed =10;
+        reversed += number%10;
+        number/=10;
+    }
+    return reversed;
+}
+int main()
+{
+    long long int number; 
+    int sign_flag = 1; 
+    scanf("%11d",&number);
+    if(number < 0)
+    {
+        sign_flag -1;
+        number * = -1;
+    }
+    long long int reverse_number number = reverse(number); 
+    number *=sign_flag;
+    reverse_number *=sign_flag;
+    long long int score = number reverse (number); 
+    printf("%lld\n", score);
+    return 0;
+}
diff --git a/Figchoice.java b/Figchoice.java
new file mode 100644
index 00000000..2b24b8e1
--- /dev/null
+++ b/Figchoice.java
@@ -0,0 +1,48 @@
+import java.applet.*;
+import java.awt.*;
+import java.awt.Graphics;
+import java.awt.event.*;
+public class figchoice extends Applet implements ItemListener {
+Choice ch;
+int x1[]= {50,120,220,20};
+int y1[]= {50,120,20,20};
+int n=4;
+int Selection; 
+public void init()
+{
+ch = new Choice();
+ch.addItem("Select a Shape");
+ch.addItem("Rectangle");
+ch.addItem("Triangle");
+ch.addItem("Square");
+ch.addItem("Circle");
+add(ch);
+ch.addItemListener(this);
+}
+public void itemStateChanged (ItemEvent e)
+{
+Selection = ch.getSelectedIndex();
+repaint();
+}
+public void paint(Graphics g)
+{
+super.paint(g);
+if (Selection == 1)
+{ g.drawRect(50,50,100,150); }
+if (Selection == 2)
+{ g.drawPolygon(x1,y1,n); }
+if (Selection == 3)
+{ g.drawRect(50,50,100,100); }
+if (Selection == 4)
+{
+g.drawOval(70,30,100,100);
+} } }
+<html><head>
+</head>
+<body>
+<div align="center">
+<applet code="figchoice.class"width="800"height="500">
+</applet>
+</div>
+</body>
+</html>
diff --git a/Find Missing Element.cpp b/Find Missing Element.cpp
new file mode 100644
index 00000000..ca0caa83
--- /dev/null
+++ b/Find Missing Element.cpp	
@@ -0,0 +1,25 @@
+void sort(int arr[],int n){
+   for (int i = 0; i < n; ++i)
+    {
+        for (int j = i + 1; j < n; ++j)
+        {
+            if (arr[i] > arr[j])
+            {
+                int temp =  arr[i];
+                arr[i] = arr[j];        
+                arr[j] = temp;
+            }
+        }
+    }
+}
+int getMissingElement(int* a,int a_size,int* b ,int b_size){
+  	sort(a,a_size);
+    sort(b,b_size);
+    for (int i = 0; i < b_size; i++)
+    {
+        if(a[i] != b[i]){
+            return a[i];
+        }
+    }
+    return a[a_size-1];
+}
diff --git a/Find Permutation.cpp b/Find Permutation.cpp
new file mode 100644
index 00000000..76706bba
--- /dev/null
+++ b/Find Permutation.cpp	
@@ -0,0 +1,21 @@
+vector<int> Solution::findPerm(const string A, int B) {
+
+    vector<int> res;
+    int max = B;
+    int min =1;
+    for(int i=B-2 ; i>=0  ; i--){
+        if(A[i] == 'I'){
+            res.push_back(max);
+            max--;
+        }
+        else{
+            res.push_back(min);
+            min++;
+        }
+    }
+    res.push_back(max);
+    reverse(res.begin(),res.end());
+    return res;
+
+     
+}
diff --git a/FloydWarshall.cpp b/FloydWarshall.cpp
new file mode 100644
index 00000000..cbe2dcde
--- /dev/null
+++ b/FloydWarshall.cpp
@@ -0,0 +1,47 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
+#define int long long
+#define endl "\n"
+
+const int INF = 1e18;
+const int MAXN = 1005;
+int dist[MAXN][MAXN];
+
+int n, m;
+
+int32_t main()
+{
+    cin>>n>>m;
+    for(int i = 1; i<=m; i++)
+    {
+        int u, v, d;
+        cin>>u>>v>>d;
+
+        dist[u][v] = d;
+        dist[v][u] = d;
+    }
+
+    for(int i = 1; i<=n; i++)
+    {
+      for(int j = 1; j<=n; j++)
+      {
+        if(i == j) dist[i][j] = 0;
+        else if(dist[i][j] == 0) dist[i][j] = INF;
+      }
+    }
+
+    for(int k = 1; k<=n; k++)
+    {
+      for(int i = 1; i<=n; i++)
+      {
+        for(int j = 1; j<=n; j++)
+        {
+          dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
+        }
+      }
+    }
+
+    // dist matrix will give you all pair shortest path possible in graph
+}
diff --git a/Function Overloading b/Function Overloading
new file mode 100644
index 00000000..213433d9
--- /dev/null
+++ b/Function Overloading	
@@ -0,0 +1,27 @@
+#include <iostream>
+using namespace std;
+class Addition {
+public:
+    int ADD(int X,int Y)   // Function with parameter 
+	{
+        return X+Y;     // this function is performing addition of  two Integer value
+    }
+    int ADD() {              // Function with same name but without parameter
+    	string a= "HELLO";
+    	string b="SAM";   // in this function concatenation is performed
+       string c= a+b;
+       cout<<c<<endl;
+       
+    }
+};
+int main(void) {
+    Addition obj;   // Object is created  
+    cout<<obj.ADD(128, 15)<<endl; //first method is called
+    obj.ADD();  // second method is called
+    return 0;
+}
+
+//Output
+//143
+
+//HELLOSAM
diff --git a/Gradient Descent b/Gradient Descent
new file mode 100644
index 00000000..f3b82848
--- /dev/null
+++ b/Gradient Descent	
@@ -0,0 +1,33 @@
+import numpy as np
+def step_gradient(points,learning_rate,m,c):
+    m_slope,c_slope=0,0
+    M=len(points)
+    for i in range(M):
+        x=points[i,0]
+        y=points[i,1]
+        m_slope+=(-2/M)*(y-m*x-c)*x            #To calculate slope. 
+        c_slope+=(-2/M)*(y-m*x-c)
+    new_m=m-learning_rate*m_slope
+    new_c=c-learning_rate*c_slope
+    return new_m,new_c          
+def gd(points,learning_rate,num_iterations):
+    m,c=0,0
+    for i in range(num_iterations):
+        m,c=step_gradient(points,learning_rate,m,c)
+        print(i,"CostL",cost(points,m,c))
+    return m,c
+def cost(points,m,c):
+    total_cost=0
+    M=len(points)
+    for i in range(M):
+        x=points[i,0]
+        y=points[i,1]
+        total_cost+=(1/M)*((y-m*x-c)**2)
+    return total_cost
+def run():
+    data=np.loadtxt("D:\Machine Learning\data.csv",delimiter=",")
+    learning_rate=0.0001
+    num_iterations=100
+    m,c=gd(data,learning_rate,num_iterations)
+    print(m,c)
+run()
diff --git a/Gradient-Descent b/Gradient-Descent
new file mode 100644
index 00000000..f3b82848
--- /dev/null
+++ b/Gradient-Descent
@@ -0,0 +1,33 @@
+import numpy as np
+def step_gradient(points,learning_rate,m,c):
+    m_slope,c_slope=0,0
+    M=len(points)
+    for i in range(M):
+        x=points[i,0]
+        y=points[i,1]
+        m_slope+=(-2/M)*(y-m*x-c)*x            #To calculate slope. 
+        c_slope+=(-2/M)*(y-m*x-c)
+    new_m=m-learning_rate*m_slope
+    new_c=c-learning_rate*c_slope
+    return new_m,new_c          
+def gd(points,learning_rate,num_iterations):
+    m,c=0,0
+    for i in range(num_iterations):
+        m,c=step_gradient(points,learning_rate,m,c)
+        print(i,"CostL",cost(points,m,c))
+    return m,c
+def cost(points,m,c):
+    total_cost=0
+    M=len(points)
+    for i in range(M):
+        x=points[i,0]
+        y=points[i,1]
+        total_cost+=(1/M)*((y-m*x-c)**2)
+    return total_cost
+def run():
+    data=np.loadtxt("D:\Machine Learning\data.csv",delimiter=",")
+    learning_rate=0.0001
+    num_iterations=100
+    m,c=gd(data,learning_rate,num_iterations)
+    print(m,c)
+run()
diff --git a/Graph_BFS b/Graph_BFS
new file mode 100644
index 00000000..dc28950e
--- /dev/null
+++ b/Graph_BFS
@@ -0,0 +1,105 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define ll long long
+#define pb push_back
+#define mp make_pair
+#define pr pair<int,int>
+#define vt vector<int>
+#define mii map<int,int>
+#define pqb priority_queue<int>
+#define pqs priority_queue<int,vi,greater<int> >
+#define mod 1000000007
+#define inf 1e18
+#define w(x) int x; cin>>x; while(x--)
+
+void print(int** edges, int n, int sv, bool* visited) {
+	cout << sv << "\n";
+	visited[sv] = true;
+	for (int i = 0; i < n; ++i)
+	{
+		if (i == sv) {
+			continue;
+		}
+		if (edges[sv][i] == 1) 
+{			if (visited[i]) {
+				continue;
+			}
+			print(edges, n, i, visited);
+		}
+	}
+}
+
+
+void printBFS(int** edges, int n, int sv) {
+	queue<int> pendingVertices;
+	bool * visited = new bool[n];
+	for (int i = 0; i < n; ++i)
+	{
+		visited[i] = false;
+	}
+	pendingVertices.push(sv);
+	visited[sv] = true;
+	while (!pendingVertices.empty()) {
+		int currvertex = pendingVertices.front();
+		pendingVertices.pop();
+		cout << currvertex << "\n";
+		for (int i = 0; i < n; ++i)
+		{
+			if (i == currvertex) {
+				continue;
+			}
+			if (edges[currvertex][i] == 1 && !visited[i]) {
+				pendingVertices.push(i);
+				visited[i] = true;
+			}
+		}
+	}
+}
+
+void solve()
+{
+	ios_base::sync_with_stdio(0); cin.tie(0);
+#ifndef ONLINE_JUDGE
+	freopen("input.txt", "r", stdin);
+	freopen("output.txt", "w", stdout);
+#endif
+	int n, e; cin >> n >> e;
+	int** edges = new int*[n];
+	for (int i = 0; i < n; ++i)
+	{
+		edges[i] = new int[n];
+		for (int j = 0; j < n; ++j)
+		{
+			edges[i][j] = 0;
+		}
+	}
+	for (int i = 0; i < e; ++i)
+	{
+		int f, s; cin >> f >> s;
+		edges[f][s] = 1;
+		edges[s][f] = 1;
+	}
+	bool* visited = new bool[n];
+	for (int i = 0; i < n; ++i)
+	{
+		visited[i] = false;
+	}
+	//print(edges, n, 0, visited);
+	printBFS(edges, n, 0);
+	delete [] visited;
+	for (int i = 0; i < n; ++i)
+	{
+		delete [] edges[i];
+	}
+	delete [] edges;
+
+
+
+}
+
+int main()
+{
+	solve();
+	return 0;
+}
diff --git a/Gym Management System UI java b/Gym Management System UI java
new file mode 100644
index 00000000..c11b5188
--- /dev/null
+++ b/Gym Management System UI java	
@@ -0,0 +1,162 @@
+import java.util.*;
+import java.lang.*;
+class gym1
+{
+ double height,weight,option;
+ String gender,contact,a,month,amount,name,name2,name3,address;
+ Scanner s=new Scanner(System.in);
+}
+class gym2 extends gym1
+{
+	 public void get()
+ {
+  System.out.println("\n\t\t\t\tJOKER'S GYM");
+  System.out.println("\n\t\t*********************************************");
+  System.out.println("\n\t\t\tPress 1 for Gym Info");
+  System.out.println("\n\t\t\tPress 2 for Registration");
+  System.out.println("\n\t\t\tPress 3 for Attendance Portal");
+  System.out.println("\n\t\t\tPress 4 for Fee Portal");
+  System.out.println("\n\t\t\tPress 5 for View Gym data");
+  System.out.println("\n\t\t\tPress 6 for Exercise Schedule");
+  System.out.println("\n\t\t\tPress 7 for Calculate your BMI");
+  System.out.println("\n\t\t\tPress 8 for Exit\n\n\n\n\n\n\t\t\t");
+ }
+ 
+	public void get1()
+	{
+	int input1;
+   input1=s.nextInt();  	
+    switch(input1)
+    {
+	    case 1:
+        System.out.println("\n\tJOKER'S GYM");
+       	System.out.println("\n******************************");
+		System.out.println("\nGYM RATINGS : 8/10");
+		System.out.println("\nGYM INFRASTRUCTURE : 7/10");
+		System.out.println("\nGYM STAFF ATTITUDE : 9/10");
+        System.out.println("\nPUBLIC RATINGS : 9/10");
+		System.out.println("\nGYM ADDRESSS : 703A,Holy Cross Apt,FY rd. ,Andheri-[E],MUM-59");
+		System.out.println("\nCONTACT : 9769557266");
+		System.out.println("\nEMAIL : joker73@gmail.com");
+		System.out.println("\n\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+		break;
+	    case 2:
+	    System.out.println("\n\tREGISTER NEW USER :\n");
+		System.out.println("************************************\n");
+		System.out.println("\nENTER NAME :");
+		name=s.next();
+		System.out.println("\nGENDER (M / F) :");
+		gender=s.next();
+		System.out.println("\nCONTACT :");
+		contact=s.next();
+		System.out.println("\nADDRESS :");
+		address=s.next();
+		System.out.println("\n\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+	    case 3:
+        System.out.println("\n\tATTENDANCE FOR TODAY :");	
+        System.out.println("\n**************************************\n");
+		System.out.println("NAME OF TRAINEE :");
+		name2=s.next();
+		System.out.println("\n\n"+name2+" has marked attendance successfully !!");
+		System.out.println("\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+	    case 4:
+	    System.out.println("\n\tFEE PORTAL");
+		System.out.println("\n****************************\n");
+		System.out.println("PRESS 1 TO SUBMIT FEE :");
+		System.out.println("\nPRESS 2 TO VIEW PENDING FEE :\n\n");
+		option=s.nextInt();
+		if(option==1)
+		{
+			System.out.println("\nNAME OF TRAINEE :");
+			name3=s.next();
+			System.out.println("\nFEE OF MONTH :");
+			month=s.next();
+			System.out.println("\nAMOUNT :");
+			amount=s.next();
+			System.out.println("\n\n**********PAYMENT SUCCESSFUL !! ***********:");
+		}
+		else
+		{
+			System.out.println("\n\tAll Trainees have done their payments !!");
+		
+		}
+		System.out.println("\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+	    case 5:
+	    System.out.println("\n\tGYM DATA ");
+		System.out.println("\n****************************\n");
+		System.out.println("NAME OF TRAINEE :" +name);
+		System.out.println("\nGENDER :" +gender);
+		System.out.println("\nCONTACT :" +contact);
+		System.out.println("\nADDRESS :" +address);
+		System.out.println("\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+	    case 6:
+	    System.out.println("\n\tEXERCISE SCHEDULE \n");
+		System.out.println("***********************************\n");
+		System.out.println("MONDAY : CHEST");
+		System.out.println("\nTUESDAY : BICEPS");
+		System.out.println("\nWEDNESDAY : TRICEPS");
+		System.out.println("\nTHRUSDAY : BACK");
+		System.out.println("\nFRIDAY : LEGS");
+		System.out.println("\nSATURDAY : SHOULDER");
+		System.out.println("\n\n\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();	
+	    case 7:
+	    double bmi;
+		System.out.println("\n\tBMI CALCULATOR");
+		System.out.println("\n************************************\n");
+		System.out.println("ENTER YOUR HEIGHT [in CM] =");
+		height=s.nextDouble();
+		System.out.println("\nENTER YOUR WEIGHT [in KG] =");
+		weight=s.nextDouble();
+		bmi=weight/((height/100)*(height/100));
+		System.out.println("\n\nyour BODY MASS INDEX is = "+bmi);
+		if(bmi<=18.5)
+		{
+			System.out.println("\n******YOU ARE THIN******");
+		}
+		else if( bmi>=18.6 && bmi<=24.9 )
+		{
+			System.out.println("\n******YOU ARE HEALTHY******");
+		}
+		else if(bmi==25 && bmi>=29.9)
+		{
+			System.out.println("\n******YOU ARE OVER WEIGHT******");
+		}
+		else
+		{
+			System.out.println("\n******YOU ARE OBESED******");
+		}
+		System.out.println("\n\n\n\t\t\t\tPress Any Key to return to Main Screen");
+		get();
+		get1();
+        case 8:
+	    System.out.println("\n\n\t\t\t***THANK YOU***");
+		System.exit(0);
+	    default :
+        System.out.println("\n\t\tPlease press key from 1 - 7");	
+        }
+
+	}
+}
+
+class javaproject
+{
+  public static void main(String args[])
+{
+  gym2 g = new gym2();
+  g.get();
+  g.get1();
+}
+} 
+
diff --git a/Hangman game.cpp b/Hangman game.cpp
new file mode 100644
index 00000000..ab68345f
--- /dev/null
+++ b/Hangman game.cpp	
@@ -0,0 +1,131 @@
+#include <iostream>
+#include <cstdlib>
+#include<ctime>
+#include <string>
+using namespace std;
+ 
+int NUM_TRY=3;
+int checkGuess (char, string, string&);
+void main_menu();
+string message = "Play!";
+ 
+ 
+int main(int argc, char *argv[])
+{
+	string name;
+	char letter;
+	string month;
+	
+ 
+    string months[] =
+	{
+		"january",
+		"february",
+		"march",
+		"april",
+		"may",
+		"june",
+		"july",
+		"august",
+		"september",
+		"october",
+		"november",
+		"december"
+	};
+	
+	srand(time(NULL));
+	int n=rand()% 12;
+	month=months[n];
+    
+	
+	string hide_m(month.length(),'X');
+ 
+	
+    
+	
+	while (NUM_TRY!=0)
+	{
+		main_menu();
+		cout << "\n\n\t\t\t\t" << hide_m;
+		cout << "\n\n\t\t\t\tGuess a letter: ";
+		cin >> letter;
+		
+		if (checkGuess(letter, month, hide_m)==0)
+		{
+			message = "Incorrect letter.";
+			NUM_TRY = NUM_TRY - 1;
+		}
+		else
+		{
+			message = "NICE! You guess a letter";
+		}
+ 
+ 
+		
+		if (month==hide_m)
+		{
+			message = "Congratulations! You got it!";
+			main_menu();
+			cout << "\n\t\t\t\tThe month is : " << month << endl;
+			break;
+		}
+	}
+	if(NUM_TRY == 0)
+	{
+		message = "NOOOOOOO!...you've been hanged.";
+		main_menu();
+		cout << "\n\t\t\t\tThe month was : " << month << endl;
+	}
+	cin.ignore();
+	cin.get();
+	return 0;
+}
+ 
+ 
+int checkGuess (char guess, string secretmonth, string &guessmonth)
+{
+	int i;
+	int matches=0;
+	int len=secretmonth.length();
+	for (i = 0; i< len; i++)
+	{
+		
+		if (guess == guessmonth[i])
+			return 0;
+		
+		if (guess == secretmonth[i])
+		{
+			guessmonth[i] = guess;
+			matches++;
+		}
+	}
+	return matches;
+}
+ 
+void main_menu()
+{
+	 system("color 05");
+                system("cls");
+                 cout<<"\t\t\t\t*\t*";
+ 
+  cout<<"\t\t\t\t**\t**";
+   cout<<"\t\t\t\t***\t***";
+   cout<<"\t\t\t\t****\t****";
+   cout<<"\t\t\t\t*****\t*****";
+    cout<<"\t\t\t\t******\t******";
+   cout<<"\t\t\t\t*******\t*******";
+   cout<<"\t\t\t\t*******\t*******";
+   cout<<"\t\t\t\t******\t******";
+   cout<<"\t\t\t\t*****\t*****";
+   cout<<"\t\t\t\t****\t****";
+   cout<<"\t\t\t\t***\t***";
+   cout<<"\t\t\t\t**\t**";
+   cout<<"\t\t\t\t*\t*";
+ 
+ cout<<"\t\t@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@";
+                cout<<"\n\t\t\t\tHangman Game!";
+				cout << "\n\t\tYou have " << NUM_TRY << " tries to try and guess the month.";
+				cout<<"\n\n\t\t\t\t"+message;
+ cout<<"\n\t\t@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
+ 
+}
diff --git a/Harshad Number in C b/Harshad Number in C
new file mode 100644
index 00000000..1e9b59ec
--- /dev/null
+++ b/Harshad Number in C	
@@ -0,0 +1,25 @@
+#include <stdio.h>    
+     
+int main()    
+{    
+    int num = 156;    
+    int rem = 0, sum = 0, n;    
+        
+    //Make a copy of num and store it in variable n    
+    n = num;    
+        
+    //Calculates sum of digits    
+    while(num > 0){    
+        rem = num%10;    
+        sum = sum + rem;    
+        num = num/10;    
+    }    
+        
+    //Checks whether number is divisible by sum of digits    
+    if(n%sum == 0)    
+        printf("%d is a harshad number", n);    
+    else    
+        printf("%d is not a harshad number", n);    
+     
+    return 0;    
+}    
diff --git a/Heap sort.cpp b/Heap sort.cpp
new file mode 100644
index 00000000..a9f4336e
--- /dev/null
+++ b/Heap sort.cpp	
@@ -0,0 +1,60 @@
+
+#include <iostream>
+using namespace std;
+  
+void heapify(int arr[], int n, int i)
+{
+    int largest = i; 
+    int l = 2 * i + 1; 
+    int r = 2 * i + 2; 
+  
+   
+    if (l < n && arr[l] > arr[largest])
+        largest = l;
+  
+   
+    if (r < n && arr[r] > arr[largest])
+        largest = r;
+  
+    
+    if (largest != i) {
+        swap(arr[i], arr[largest]);
+  
+        heapify(arr, n, largest);
+    }
+}
+void heapSort(int arr[], int n)
+{
+    
+    for (int i = n / 2 - 1; i >= 0; i--)
+        heapify(arr, n, i);
+  
+    
+    for (int i = n - 1; i >= 0; i--) {
+       
+        swap(arr[0], arr[i]);
+  
+       
+        heapify(arr, i, 0);
+    }
+}
+  
+
+void printArray(int arr[], int n)
+{
+    for (int i = 0; i < n; ++i)
+        cout << arr[i] << " ";
+    cout << "\n";
+}
+  
+
+int main()
+{
+    int arr[] = { 12, 11, 13, 5, 6, 7 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+  
+    heapSort(arr, n);
+  
+    cout << "Sorted array is \n";
+    printArray(arr, n);
+}
\ No newline at end of file
diff --git a/Heap sort.py b/Heap sort.py
new file mode 100644
index 00000000..a8c806b7
--- /dev/null
+++ b/Heap sort.py	
@@ -0,0 +1,52 @@
+# Python program for implementation of heap Sort
+
+# To heapify subtree rooted at index i.
+# n is size of heap
+
+
+def heapify(arr, n, i):
+	largest = i # Initialize largest as root
+	l = 2 * i + 1	 # left = 2*i + 1
+	r = 2 * i + 2	 # right = 2*i + 2
+
+	# See if left child of root exists and is
+	# greater than root
+	if l < n and arr[largest] < arr[l]:
+		largest = l
+
+	# See if right child of root exists and is
+	# greater than root
+	if r < n and arr[largest] < arr[r]:
+		largest = r
+
+	# Change root, if needed
+	if largest != i:
+		arr[i], arr[largest] = arr[largest], arr[i] # swap
+
+		# Heapify the root.
+		heapify(arr, n, largest)
+
+# The main function to sort an array of given size
+
+
+def heapSort(arr):
+	n = len(arr)
+
+	# Build a maxheap.
+	for i in range(n//2 - 1, -1, -1):
+		heapify(arr, n, i)
+
+	# One by one extract elements
+	for i in range(n-1, 0, -1):
+		arr[i], arr[0] = arr[0], arr[i] # swap
+		heapify(arr, i, 0)
+
+
+# Driver code
+arr = [12, 11, 13, 5, 6, 7]
+heapSort(arr)
+n = len(arr)
+print("Sorted array is")
+for i in range(n):
+	print("%d" % arr[i]),
+# This code is contributed by Mohit Kumra
diff --git a/Heap_Sort.cpp b/Heap_Sort.cpp
new file mode 100644
index 00000000..a017dae3
--- /dev/null
+++ b/Heap_Sort.cpp
@@ -0,0 +1,51 @@
+#include<iostream>
+using namespace std;
+
+void display(int *array, int size) {
+   for(int i = 1; i<=size; i++)
+      cout << array[i] << " ";
+   cout << endl;
+}
+
+void heapify(int *array, int n) {
+   int i, par, l, r, node;
+   // create max heap
+
+   for(i = 1; i<= n; i++) {
+      node = i; par = (int)node/2;
+      while(par >= 1) {
+         //if new node bigger than parent, then swap
+         if(array[par] < array[node])
+            swap(array[par], array[node]);
+         node = par;
+         par = (int)node/2;//update parent to check
+      }
+   }
+}
+
+void heapSort(int *array, int n) {
+   int i;
+
+   for(i = n; i>= 1; i--) {
+      heapify(array, i);//heapify each time
+      swap(array[1], array[i]);//swap last element with first
+   }
+}
+
+int main() {
+   int n;
+   cout << "Enter the number of elements: ";
+   cin >> n;
+   int arr[n+1]; //effective index starts from i = 1.
+   cout << "Enter elements:" << endl;
+
+   for(int i = 1; i<=n; i++) {
+      cin >> arr[i];
+   }
+
+   cout << "Array before Sorting: ";
+   display(arr, n);
+   heapSort(arr, n);
+   cout << "Array after Sorting: ";
+   display(arr, n);
+}
\ No newline at end of file
diff --git a/HttpReaquestInC.cpp b/HttpReaquestInC.cpp
new file mode 100644
index 00000000..b7cfaacd
--- /dev/null
+++ b/HttpReaquestInC.cpp
@@ -0,0 +1,87 @@
+#include <stdio.h> /* printf, sprintf */
+#include <stdlib.h> /* exit */
+#include <unistd.h> /* read, write, close */
+#include <string.h> /* memcpy, memset */
+#include <sys/socket.h> /* socket, connect */
+#include <netinet/in.h> /* struct sockaddr_in, struct sockaddr */
+#include <netdb.h> /* struct hostent, gethostbyname */
+
+void error(const char *msg) { perror(msg); exit(0); }
+
+int main(int argc,char *argv[])
+{
+    /* first what are we going to send and where are we going to send it? */
+    int portno =        80;
+    char *host =        "api.somesite.com";
+    char *message_fmt = "POST /apikey=%s&command=%s HTTP/1.0\r\n\r\n";
+
+    struct hostent *server;
+    struct sockaddr_in serv_addr;
+    int sockfd, bytes, sent, received, total;
+    char message[1024],response[4096];
+
+    if (argc < 3) { puts("Parameters: <apikey> <command>"); exit(0); }
+
+    /* fill in the parameters */
+    sprintf(message,message_fmt,argv[1],argv[2]);
+    printf("Request:\n%s\n",message);
+
+    /* create the socket */
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0) error("ERROR opening socket");
+
+    /* lookup the ip address */
+    server = gethostbyname(host);
+    if (server == NULL) error("ERROR, no such host");
+
+    /* fill in the structure */
+    memset(&serv_addr,0,sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_port = htons(portno);
+    memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
+
+    /* connect the socket */
+    if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
+        error("ERROR connecting");
+
+    /* send the request */
+    total = strlen(message);
+    sent = 0;
+    do {
+        bytes = write(sockfd,message+sent,total-sent);
+        if (bytes < 0)
+            error("ERROR writing message to socket");
+        if (bytes == 0)
+            break;
+        sent+=bytes;
+    } while (sent < total);
+
+    /* receive the response */
+    memset(response,0,sizeof(response));
+    total = sizeof(response)-1;
+    received = 0;
+    do {
+        bytes = read(sockfd,response+received,total-received);
+        if (bytes < 0)
+            error("ERROR reading response from socket");
+        if (bytes == 0)
+            break;
+        received+=bytes;
+    } while (received < total);
+
+    /*
+     * if the number of received bytes is the total size of the
+     * array then we have run out of space to store the response
+     * and it hasn't all arrived yet - so that's a bad thing
+     */
+    if (received == total)
+        error("ERROR storing complete response from socket");
+
+    /* close the socket */
+    close(sockfd);
+
+    /* process response */
+    printf("Response:\n%s\n",response);
+
+    return 0;
+}
diff --git a/Hybrid Inheritence.cpp b/Hybrid Inheritence.cpp
new file mode 100644
index 00000000..7f4b2f0e
--- /dev/null
+++ b/Hybrid Inheritence.cpp	
@@ -0,0 +1,97 @@
+#include<iostream>
+#include<conio.h>
+// student class which is base class
+class student
+{
+// Body of student class which contain declaration and definition of all members of student class
+protected:
+int rollnum; // rollnum is protected member of student class
+public:
+// set_rollnum is function which is used to set the value to protected member rollnum through public member function
+void set_rollnum(int num)
+{
+rollnum=num; // protected member of class is assigned value using public member function
+}
+// print_rollnum is function to print the value of rollnum
+void print_rollnum(void)
+{
+std::cout<<"Roll number is : "<<rollnum<<"\n"; // print the value of rollnum
+}
+}; // end of class student
+// class subject which inherits property from class student
+class subject:public student
+{
+// Body of class subject
+// protected member variables of subject class
+protected:
+float subject1, subject2, subject3; // subject1, subject2 and subject3 are protected float members of class subject
+// public member functions of class subject
+public:
+//set_subjectmark is public member function to assign the values to the protected member variables of subject class
+void set_subjectmark(float a,float b,float c)
+{
+// assigning values to the all protected member variables of the subject class
+subject1 = a; // assign value a to the subject1
+subject2 = b; // assign value b to the subject2
+subject3 = c; // assign value c to the subject3
+}
+// print_subjectmarks is public member function of the class subject to print values of protected member variables subject1,subject2 and subject3
+void print_subjectmarks()
+{
+std::cout<<"subject marks in each subject is : "<<"subject1="<<subject1<<"\n"<<"subject2="<<subject2<<"\n"<<"subject3="<<subject3<<"\n";
+}
+}; // end of class subject
+// class sports which inherits property from class student
+class sports
+{
+// Body of class sports
+// protected member variable of class sports
+protected:
+float sport_marks; //sport_marks is protected member variable of class sports
+// public member functions of class sports
+public:
+// public member function set_sports_marks of class sports which is used to set value to protected member variable sport_marks
+void set_sports_marks(float marks)
+{
+sport_marks=marks; // assign value to protected member variable sport_marks
+}
+// print_sports_marks function to print value of protected member variable sport_marks
+void print_sports_marks(void)
+{
+std::cout<<"marks in sports is : "<< sport_marks <<"\n";
+}
+}; // end of class sports
+// class overall_result which inherits property of both class subject and class sports
+class overall_result: public subject , public sports
+{
+// Body of class overall_result
+private:
+float total_marks; // total_marks is private member variable of class overall_result
+public:
+void display_total(void);// display_total is public member function of class overall_result
+};// end of class overall_result
+void overall_result::display_total(void)
+{
+// Body of function display_total
+// This function calculated and display total
+total_marks=subject1+subject2+subject3+sport_marks; // calculating total of subject marks and sport marks
+print_rollnum();
+print_subjectmarks();
+print_sports_marks();
+std::cout<<"Total marks including subject marks and sports marks is : = "<<total_marks<<"\n";
+}
+int main()
+{
+overall_result stu; // object of class overall_result
+stu.set_rollnum(40); // assign value to rollnum which is member variable of class student
+stu.set_subjectmark(19.8,34.6,89.7); // assign value to subject1, subject2 and subject3 which are member variables of clss subject
+stu.set_sports_marks(64.3); // assign value to sport_marks which is member variable of class sports
+stu.display_total(); // this function calculate and display total
+std::cout << "---------------------------------------------------------"<<"\n";
+overall_result stu2; // another object of class overall_result
+stu2.set_rollnum(50); // assign value to rollnum which is member variable of class student
+stu2.set_subjectmark(10.8,54.6,59.7); // assign value to subject1, subject2 and subject3 which are member variables of clss subject
+stu2.set_sports_marks(94.3); // assign value to sport_marks which is member variable of class sports
+stu2.display_total(); // this function calculate and display total
+return 0;
+}
\ No newline at end of file
diff --git a/Ilya And Bank Account Codeforces b/Ilya And Bank Account Codeforces
new file mode 100644
index 00000000..3c199c99
--- /dev/null
+++ b/Ilya And Bank Account Codeforces	
@@ -0,0 +1,25 @@
+#include <iostream>
+using namespace std;
+int main(){
+   long long int state,max=0;
+    
+    cin >>state;
+    long copy=state;
+    int s=state%10;
+    state/=10;
+    state/=10;
+    state=state*10+s;
+    //cout <<state;
+     if (copy/10>copy && (copy/10 >state || copy/10==state)){
+        max=copy/10;
+    }
+
+    else if (state>copy && state > copy/10){
+        max=state;
+    }
+    else if (copy>state && copy>copy/10){
+        max=copy;
+
+    }
+    cout <<max;
+}
diff --git a/Implementation of AVL Tree b/Implementation of AVL Tree
new file mode 100644
index 00000000..acd879c5
--- /dev/null
+++ b/Implementation of AVL Tree	
@@ -0,0 +1,190 @@
+#include<iostream>
+#include<cstdio>
+#include<sstream>
+#include<algorithm>
+#define pow2(n) (1 << (n))
+using namespace std;
+struct avl {
+   int d;
+   struct avl *l;
+   struct avl *r;
+}*r;
+class avl_tree {
+   public:
+      int height(avl *);
+      int difference(avl *);
+      avl *rr_rotat(avl *);
+      avl *ll_rotat(avl *);
+      avl *lr_rotat(avl*);
+      avl *rl_rotat(avl *);
+      avl * balance(avl *);
+      avl * insert(avl*, int);
+      void show(avl*, int);
+      void inorder(avl *);
+      void preorder(avl *);
+      void postorder(avl*);
+      avl_tree() {
+         r = NULL;
+      }
+};
+int avl_tree::height(avl *t) {
+   int h = 0;
+   if (t != NULL) {
+      int l_height = height(t->l);
+      int r_height = height(t->r);
+      int max_height = max(l_height, r_height);
+      h = max_height + 1;
+   }
+   return h;
+}
+int avl_tree::difference(avl *t) {
+   int l_height = height(t->l);
+   int r_height = height(t->r);
+   int b_factor = l_height - r_height;
+   return b_factor;
+}
+avl *avl_tree::rr_rotat(avl *parent) {
+   avl *t;
+   t = parent->r;
+   parent->r = t->l;
+   t->l = parent;
+   cout<<"Right-Right Rotation";
+   return t;
+}
+avl *avl_tree::ll_rotat(avl *parent) {
+   avl *t;
+   t = parent->l;
+   parent->l = t->r;
+   t->r = parent;
+   cout<<"Left-Left Rotation";
+   return t;
+}
+avl *avl_tree::lr_rotat(avl *parent) {
+   avl *t;
+   t = parent->l;
+   parent->l = rr_rotat(t);
+   cout<<"Left-Right Rotation";
+   return ll_rotat(parent);
+}
+avl *avl_tree::rl_rotat(avl *parent) {
+   avl *t;
+   t = parent->r;
+   parent->r = ll_rotat(t);
+   cout<<"Right-Left Rotation";
+   return rr_rotat(parent);
+}
+avl *avl_tree::balance(avl *t) {
+   int bal_factor = difference(t);
+   if (bal_factor > 1) {
+      if (difference(t->l) > 0)
+         t = ll_rotat(t);
+      else
+         t = lr_rotat(t);
+   } else if (bal_factor < -1) {
+      if (difference(t->r) > 0)
+         t = rl_rotat(t);
+      else
+         t = rr_rotat(t);
+   }
+   return t;
+}
+avl *avl_tree::insert(avl *r, int v) {
+   if (r == NULL) {
+      r = new avl;
+      r->d = v;
+      r->l = NULL;
+      r->r = NULL;
+      return r;
+   } else if (v< r->d) {
+      r->l = insert(r->l, v);
+      r = balance(r);
+   } else if (v >= r->d) {
+      r->r = insert(r->r, v);
+      r = balance(r);
+   } return r;
+}
+void avl_tree::show(avl *p, int l) {
+   int i;
+   if (p != NULL) {
+      show(p->r, l+ 1);
+      cout<<" ";
+      if (p == r)
+         cout << "Root -> ";
+      for (i = 0; i < l&& p != r; i++)
+         cout << " ";
+         cout << p->d;
+         show(p->l, l + 1);
+   }
+}
+void avl_tree::inorder(avl *t) {
+   if (t == NULL)
+      return;
+      inorder(t->l);
+      cout << t->d << " ";
+      inorder(t->r);
+}
+void avl_tree::preorder(avl *t) {
+   if (t == NULL)
+      return;
+      cout << t->d << " ";
+      preorder(t->l);
+      preorder(t->r);
+}
+void avl_tree::postorder(avl *t) {
+   if (t == NULL)
+      return;
+      postorder(t ->l);
+      postorder(t ->r);
+      cout << t->d << " ";
+}
+int main() {
+   int c, i;
+   avl_tree avl;
+   while (1) {
+      cout << "1.Insert Element into the tree" << endl;
+      cout << "2.show Balanced AVL Tree" << endl;
+      cout << "3.InOrder traversal" << endl;
+      cout << "4.PreOrder traversal" << endl;
+      cout << "5.PostOrder traversal" << endl;
+      cout << "6.Exit" << endl;
+      cout << "Enter your Choice: ";
+      cin >> c;
+      switch (c) {
+         case 1:
+            cout << "Enter value to be inserted: ";
+            cin >> i;
+            r = avl.insert(r, i);
+         break;
+         case 2:
+            if (r == NULL) {
+               cout << "Tree is Empty" << endl;
+               continue;
+            }
+            cout << "Balanced AVL Tree:" << endl;
+            avl.show(r, 1);
+            cout<<endl;
+         break;
+         case 3:
+            cout << "Inorder Traversal:" << endl;
+            avl.inorder(r);
+            cout << endl;
+         break;
+         case 4:
+            cout << "Preorder Traversal:" << endl;
+            avl.preorder(r);
+            cout << endl;
+         break;
+         case 5:
+            cout << "Postorder Traversal:" << endl;
+            avl.postorder(r);
+            cout << endl;
+         break;
+         case 6:
+            exit(1);
+         break;
+         default:
+            cout << "Wrong Choice" << endl;
+      }
+   }
+   return 0;
+}
diff --git a/Infix_2_postfix b/Infix_2_postfix
new file mode 100644
index 00000000..e9711dd9
--- /dev/null
+++ b/Infix_2_postfix
@@ -0,0 +1,96 @@
+#include<iostream>
+#include<stack>                                                          // in-build stack data structure
+
+using namespace std;
+
+bool is_operator(char c){                                               //to check if the parameter is an operator
+	if((c=='+') || (c=='-') || (c=='*') || (c=='/'))
+	 return true;
+	else 
+	  return false;
+}
+
+int check_pre(char c){                                                  //precedence function in which precedence of the ( and ) is not considered
+	
+	if(c=='^')  return 3;
+	
+	else if((c=='*') || (c=='/')) return 2;
+	
+	else if((c=='+') || (c=='-')) return 1;
+	 
+	else return -1; 
+}
+
+string in_post(stack<char> s,string infix){
+	
+	string postfix;
+	
+	for( int i=0 ; i<infix.length() ; i++){
+		
+		if(( infix[i] >= 'a' && infix[i]<='z') || ( infix[i] >= 'A' && infix[i] <= 'Z'))         //If it is an alpha then we will directly add in postfix
+		
+		postfix+=infix[i];
+		
+		else if( infix[i] == '(' )                                                               //If '(' then simply push in stack
+		        s.push(infix[i]);
+		        
+		else if( infix[i] == ')' ){
+			while ((!s.empty()) && (s.top() != '(')){                                           //If ')' then pop till '(' 
+				
+				postfix+=s.top();
+				s.pop();
+				
+			}
+			if(s.top() == '('){
+				s.pop();
+			}
+		}
+		else if(is_operator(infix[i])){                                                         //check if it is an operator
+			
+			if(s.empty()){                                                                     //If stack is empty then simply push
+				s.push(infix[i]);
+			}
+			
+			else{
+				if(check_pre(infix[i]) > check_pre(s.top()))                                 //If precedence is higher then simply push           
+				    s.push(infix[i]);
+				    
+				else if(check_pre(infix[i])==check_pre(s.top()) && infix[i]=='^')            //Associtivity of exponential is right to left 
+				    s.push(infix[i]);
+				    
+				else{
+					while((!s.empty() && check_pre(infix[i]) <= check_pre(s.top()))){       //pop out till th top has lower precedence
+						postfix+=s.top();
+						s.pop();
+					}
+					s.push(infix[i]);
+				}
+			}
+		}
+	}
+	while(!s.empty()){                                                                          //pop everything out till the stack is empty
+		postfix+=s.top();
+		s.pop();
+	}
+	
+	
+	return postfix;
+}
+
+
+int main(){
+    
+    string infix,postfix;
+    
+    cout<<"-----INFIX_to_POSTFIX-------"<<endl;
+    cout<<"Enter an INFIX expression:";
+    cin>>infix;
+    stack <char> s;
+    cout<<endl;
+    cout<<"INFIX expression: "<<infix<<endl;
+    postfix = in_post(s,infix);
+    cout<<"POSTFIX expression:"<<postfix<<endl;
+    
+	
+	return 0;
+}
diff --git a/Insertion Sort.c b/Insertion Sort.c
new file mode 100644
index 00000000..5af107b9
--- /dev/null
+++ b/Insertion Sort.c	
@@ -0,0 +1,42 @@
+// C program for insertion sort
+#include <math.h>
+#include <stdio.h>
+
+/* Function to sort an array using insertion sort*/
+void insertionSort(int arr[], int n)
+{
+    int i, key, j;
+    for (i = 1; i < n; i++) {
+        key = arr[i];
+        j = i - 1;
+
+        /* Move elements of arr[0..i-1], that are
+          greater than key, to one position ahead
+          of their current position */
+        while (j >= 0 && arr[j] > key) {
+            arr[j + 1] = arr[j];
+            j = j - 1;
+        }
+        arr[j + 1] = key;
+    }
+}
+
+// A utility function to print an array of size n
+void printArray(int arr[], int n)
+{
+    int i;
+    for (i = 0; i < n; i++)
+        printf("%d ", arr[i]);
+    printf("\n");
+}
+
+/* Driver program to test insertion sort */
+int main()
+{
+    int arr[] = { 12, 11, 13, 5, 6 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+
+    insertionSort(arr, n);
+    printArray(arr, n);
+
+    return 0;
diff --git a/Jump_game.cpp b/Jump_game.cpp
new file mode 100644
index 00000000..530ea4bd
--- /dev/null
+++ b/Jump_game.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int jump(vector<int>& nums) {
+        int cur = 0, prev = 0, count = 0;
+        for(int i = 0; i < nums.size()-1; ++i)
+        {
+			//find the current max step
+            cur = max(cur, i+nums[i]);
+			//check if reach the top
+            if(cur >= nums.size()-1)
+                return count+1;
+			//if pass the previous step, then jump
+            if(i == prev)
+            {
+                prev = cur;
+                ++count;
+            }
+        }
+        return count;
+    }
+};
diff --git a/KMP algorithm b/KMP algorithm
new file mode 100644
index 00000000..de32d673
--- /dev/null
+++ b/KMP algorithm	
@@ -0,0 +1,88 @@
+// C++ program for implementation of KMP pattern searching
+// algorithm
+#include <bits/stdc++.h>
+
+void computeLPSArray(char* pat, int M, int* lps);
+
+// Prints occurrences of txt[] in pat[]
+void KMPSearch(char* pat, char* txt)
+{
+	int M = strlen(pat);
+	int N = strlen(txt);
+
+	// create lps[] that will hold the longest prefix suffix
+	// values for pattern
+	int lps[M];
+
+	// Preprocess the pattern (calculate lps[] array)
+	computeLPSArray(pat, M, lps);
+
+	int i = 0; // index for txt[]
+	int j = 0; // index for pat[]
+	while (i < N) {
+		if (pat[j] == txt[i]) {
+			j++;
+			i++;
+		}
+
+		if (j == M) {
+			printf("Found pattern at index %d ", i - j);
+			j = lps[j - 1];
+		}
+
+		// mismatch after j matches
+		else if (i < N && pat[j] != txt[i]) {
+			// Do not match lps[0..lps[j-1]] characters,
+			// they will match anyway
+			if (j != 0)
+				j = lps[j - 1];
+			else
+				i = i + 1;
+		}
+	}
+}
+
+// Fills lps[] for given patttern pat[0..M-1]
+void computeLPSArray(char* pat, int M, int* lps)
+{
+	// length of the previous longest prefix suffix
+	int len = 0;
+
+	lps[0] = 0; // lps[0] is always 0
+
+	// the loop calculates lps[i] for i = 1 to M-1
+	int i = 1;
+	while (i < M) {
+		if (pat[i] == pat[len]) {
+			len++;
+			lps[i] = len;
+			i++;
+		}
+		else // (pat[i] != pat[len])
+		{
+			// This is tricky. Consider the example.
+			// AAACAAAA and i = 7. The idea is similar
+			// to search step.
+			if (len != 0) {
+				len = lps[len - 1];
+
+				// Also, note that we do not increment
+				// i here
+			}
+			else // if (len == 0)
+			{
+				lps[i] = 0;
+				i++;
+			}
+		}
+	}
+}
+
+// Driver program to test above function
+int main()
+{
+	char txt[] = "ABABDABACDABABCABAB";
+	char pat[] = "ABABCABAB";
+	KMPSearch(pat, txt);
+	return 0;
+}
diff --git a/KMP_search_algorithm.cpp b/KMP_search_algorithm.cpp
new file mode 100644
index 00000000..f109d733
--- /dev/null
+++ b/KMP_search_algorithm.cpp
@@ -0,0 +1,82 @@
+// C++ program for implementation of KMP pattern searching algorithm
+#include <bits/stdc++.h>
+  
+void computeLPSArray(char* pat, int M, int* lps);
+  
+void KMPSearch(char* pat, char* txt)
+{
+    int M = strlen(pat);
+    int N = strlen(txt);
+  
+    // create lps[] that will hold the longest prefix suffix
+    // values for pattern
+    int lps[M];
+  
+    computeLPSArray(pat, M, lps);
+  
+    int i = 0; // index for txt[]
+    int j = 0; // index for pat[]
+    while (i < N) {
+        if (pat[j] == txt[i]) {
+            j++;
+            i++;
+        }
+  
+        if (j == M) {
+            printf("Found pattern at index %d ", i - j);
+            j = lps[j - 1];
+        }
+  
+        else if (i < N && pat[j] != txt[i]) {
+            if (j != 0)
+                j = lps[j - 1];
+            else
+                i = i + 1;
+        }
+    }
+}
+  
+void computeLPSArray(char* pat, int M, int* lps)
+{
+    // length of the previous longest prefix suffix
+    int len = 0;
+  
+    lps[0] = 0; // lps[0] is always 0
+  
+    // the loop calculates lps[i] for i = 1 to M-1
+    int i = 1;
+    while (i < M) {
+        if (pat[i] == pat[len]) {
+            len++;
+            lps[i] = len;
+            i++;
+        }
+        else
+        {
+            // This is tricky. Consider the example.
+            // AAACAAAA and i = 7. The idea is similar
+            // to search step.
+            if (len != 0) {
+                len = lps[len - 1];
+  
+                // Also, note that we do not increment i here
+            }
+            else // if (len == 0)
+            {
+                lps[i] = 0;
+                i++;
+            }
+        }
+    }
+}
+  
+int main()
+{
+    char txt[] = "ABABDABACDABABCABAB";
+    char pat[] = "ABABCABAB";
+    KMPSearch(pat, txt);
+    return 0;
+}
+
+//Output:
+//Found pattern at index 10
diff --git "a/Kadane\342\200\231s Algorithm" "b/Kadane\342\200\231s Algorithm"
new file mode 100644
index 00000000..c8ec10fd
--- /dev/null
+++ "b/Kadane\342\200\231s Algorithm"	
@@ -0,0 +1,36 @@
+//problem on Kadane’s Algorithm:
+
+// C++ program to print largest contiguous array sum
+#include<iostream>
+#include<climits>
+using namespace std;
+ 
+int maxSubArraySum(int a[], int size)
+{
+    int max_so_far = INT_MIN, max_ending_here = 0;
+ 
+    for (int i = 0; i < size; i++)
+    {
+        max_ending_here = max_ending_here + a[i];
+        if (max_so_far < max_ending_here)
+            max_so_far = max_ending_here;
+ 
+        if (max_ending_here < 0)
+            max_ending_here = 0;
+    }
+    return max_so_far;
+}
+ 
+/*Driver program to test maxSubArraySum*/
+int main()
+{
+    int a[] = {-2, -3, 4, -1, -2, 1, 5, -3};
+    int n = sizeof(a)/sizeof(a[0]);
+    int max_sum = maxSubArraySum(a, n);
+    cout << "Maximum contiguous sum is " << max_sum;
+    return 0;
+}
+
+Output:
+
+Maximum contiguous sum is 7
diff --git a/Knapsack01 b/Knapsack01
new file mode 100644
index 00000000..0e8cebb2
--- /dev/null
+++ b/Knapsack01
@@ -0,0 +1,34 @@
+/* 0-1 Knapsack problem */
+#include <bits/stdc++.h>
+using namespace std;
+
+int max(int a, int b) { return (a > b) ? a : b; }
+
+int knapSack(int W, int wt[], int val[], int n)
+{
+
+
+	if (n == 0 || W == 0)
+		return 0;
+	if (wt[n - 1] > W)
+		return knapSack(W, wt, val, n - 1);
+
+	else
+		return max(
+			val[n - 1]
+				+ knapSack(W - wt[n - 1],
+						wt, val, n - 1),
+			knapSack(W, wt, val, n - 1));
+}
+
+int main()
+{
+	int val[] = { 60, 100, 120 };
+	int wt[] = { 10, 20, 30 };
+	int W = 50;
+	int n = sizeof(val) / sizeof(val[0]);
+	cout << knapSack(W, wt, val, n);
+	return 0;
+}
+
+
diff --git a/KnapsackRec.cpp b/KnapsackRec.cpp
new file mode 100644
index 00000000..0c39871c
--- /dev/null
+++ b/KnapsackRec.cpp
@@ -0,0 +1,48 @@
+/* A Naive recursive implementation of
+0-1 Knapsack problem */
+#include <bits/stdc++.h>
+using namespace std;
+
+// A utility function that returns
+// maximum of two integers
+int max(int a, int b) { return (a > b) ? a : b; }
+
+// Returns the maximum value that
+// can be put in a knapsack of capacity W
+int knapSack(int W, int wt[], int val[], int n)
+{
+
+	// Base Case
+	if (n == 0 || W == 0)
+		return 0;
+
+	// If weight of the nth item is more
+	// than Knapsack capacity W, then
+	// this item cannot be included
+	// in the optimal solution
+	if (wt[n - 1] > W)
+		return knapSack(W, wt, val, n - 1);
+
+	// Return the maximum of two cases:
+	// (1) nth item included
+	// (2) not included
+	else
+		return max(
+			val[n - 1]
+				+ knapSack(W - wt[n - 1],
+						wt, val, n - 1),
+			knapSack(W, wt, val, n - 1));
+}
+
+// Driver code
+int main()
+{
+	int val[] = { 60, 100, 120 };
+	int wt[] = { 10, 20, 30 };
+	int W = 50;
+	int n = sizeof(val) / sizeof(val[0]);
+	cout << knapSack(W, wt, val, n);
+	return 0;
+}
+
+// This code is contributed by rathbhupendra
diff --git a/KnapsackRecursive.cpp b/KnapsackRecursive.cpp
new file mode 100644
index 00000000..0c39871c
--- /dev/null
+++ b/KnapsackRecursive.cpp
@@ -0,0 +1,48 @@
+/* A Naive recursive implementation of
+0-1 Knapsack problem */
+#include <bits/stdc++.h>
+using namespace std;
+
+// A utility function that returns
+// maximum of two integers
+int max(int a, int b) { return (a > b) ? a : b; }
+
+// Returns the maximum value that
+// can be put in a knapsack of capacity W
+int knapSack(int W, int wt[], int val[], int n)
+{
+
+	// Base Case
+	if (n == 0 || W == 0)
+		return 0;
+
+	// If weight of the nth item is more
+	// than Knapsack capacity W, then
+	// this item cannot be included
+	// in the optimal solution
+	if (wt[n - 1] > W)
+		return knapSack(W, wt, val, n - 1);
+
+	// Return the maximum of two cases:
+	// (1) nth item included
+	// (2) not included
+	else
+		return max(
+			val[n - 1]
+				+ knapSack(W - wt[n - 1],
+						wt, val, n - 1),
+			knapSack(W, wt, val, n - 1));
+}
+
+// Driver code
+int main()
+{
+	int val[] = { 60, 100, 120 };
+	int wt[] = { 10, 20, 30 };
+	int W = 50;
+	int n = sizeof(val) / sizeof(val[0]);
+	cout << knapSack(W, wt, val, n);
+	return 0;
+}
+
+// This code is contributed by rathbhupendra
diff --git a/Kruskals Algorithm - DSU b/Kruskals Algorithm - DSU
new file mode 100644
index 00000000..1428afeb
--- /dev/null
+++ b/Kruskals Algorithm - DSU	
@@ -0,0 +1,61 @@
+#include<bits/stdc++. h> 
+using namespace std; 
+const int N = 1e5+6; 
+vector<int> parent(N); 
+vector<int> sz(N); 
+
+void make_set(int v){
+    parent[v] = v; 
+    sz[v] = 1; 
+}
+
+int find_set(int v){
+    if(v == parent[v]){
+        return v; 
+    }
+    return parent[v] = find_set(parent[v]); 
+}
+void union_sets(int a, int b){
+    a = find_set(a); 
+    b = find_set(b); 
+    if(a != b){
+        if(sz[a] < sz[b]){
+            swap(a,b); 
+        }
+        parent[b] = a; 
+        sz[a] += sz[b]; 
+    }
+}
+
+int main(){
+    for(int i=0; i<N; i++){
+        make_set(i); 
+    }
+    int n, m; 
+    cin>>n>>m; 
+    vector<vector<int> > edges; 
+    for(int i=0; i<m; i++){
+        int u,v,w; 
+        cin>>u>>v>>w; 
+        edges.push_back({w,u,v}); 
+    }
+    sort(edges.begin(), edges.end()); 
+    int cost = 0; 
+    for(auto i : edges){
+        int u = i[1]; 
+        int v = i[2]; 
+        int w = i[0]; 
+        int x = find_set(u); 
+        int y = find_set(v); 
+        if(x == y){
+            //makes a cycle
+            continue; 
+        }
+        else{
+            cost += w; 
+            union_sets(u, v); 
+        }
+    }
+    cout<<cost<<"\n"; 
+    return 0; 
+}
diff --git a/KthGrammar.cpp b/KthGrammar.cpp
new file mode 100644
index 00000000..5011fe6a
--- /dev/null
+++ b/KthGrammar.cpp
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <math.h>
+using namespace std;
+
+int kgrammar(int n, int k)
+{
+    int i;
+    if (k > pow(2, n - 1) || k<1)
+        return -1;
+    else
+    {
+        if (n == 1)
+            return 1;
+
+        int l = (k / 2) + (k % 2);
+        i = kgrammar(n - 1, l);
+        bool num;
+        if (k % 2 == 0)
+            num = 0;
+        else
+            num = 0;
+        if (i == 0)
+            return num;
+        else
+            return !num;
+    }
+}
+int main()
+{
+    int n,k;
+    cin>>n>>k;
+    cout << kgrammar(n,k);
+    return 0;
+}
\ No newline at end of file
diff --git a/LCS.c b/LCS.c
new file mode 100644
index 00000000..2c8889b9
--- /dev/null
+++ b/LCS.c
@@ -0,0 +1,34 @@
+#include<stdio.h>
+#include<string.h>
+ 
+int max(int a, int b);
+ 
+
+int lcs( char *X, char *Y, int m, int n )
+{
+if (m == 0 || n == 0)
+    return 0;
+if (X[m-1] == Y[n-1])
+    return 1 + lcs(X, Y, m-1, n-1);
+else
+    return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));
+}
+ 
+int max(int a, int b)
+{
+    return (a > b)? a : b;
+}
+ 
+// Driver program
+int main()
+{
+char X[] = "AGGTAB";
+char Y[] = "GXTXAYB";
+ 
+int m = strlen(X);
+int n = strlen(Y);
+ 
+printf("Length of LCS is %d", lcs( X, Y, m, n ) );
+ 
+return 0;
+}
\ No newline at end of file
diff --git a/Leap Year in C b/Leap Year in C
new file mode 100644
index 00000000..68c20da8
--- /dev/null
+++ b/Leap Year in C	
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main() {
+   int year;
+   year = 2016;
+
+   if (((year % 4 == 0) && (year % 100!= 0)) || (year%400 == 0))
+      printf("%d is a leap year", year);
+   else
+      printf("%d is not a leap year", year);
+
+   return 0;
+}
diff --git a/Leap.cpp b/Leap.cpp
new file mode 100644
index 00000000..5c9b310c
--- /dev/null
+++ b/Leap.cpp
@@ -0,0 +1,27 @@
+#include <stdio.h>
+int main() {
+   int year;
+   printf("Enter a year: ");
+   scanf("%d", &year);
+
+   // leap year if perfectly divisible by 400
+   if (year % 400 == 0) {
+      printf("%d is a leap year.", year);
+   }
+   // not a leap year if divisible by 100
+   // but not divisible by 400
+   else if (year % 100 == 0) {
+      printf("%d is not a leap year.", year);
+   }
+   // leap year if not divisible by 100
+   // but divisible by 4
+   else if (year % 4 == 0) {
+      printf("%d is a leap year.", year);
+   }
+   // all other years are not leap years
+   else {
+      printf("%d is not a leap year.", year);
+   }
+
+   return 0;
+}
diff --git a/Linear_search.cpp b/Linear_search.cpp
new file mode 100644
index 00000000..c70a3393
--- /dev/null
+++ b/Linear_search.cpp
@@ -0,0 +1,22 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+    int arr[10], i, num, index;
+    cout<<"Enter 10 Numbers: ";
+    for(i=0; i<10; i++)
+        cin>>arr[i];
+    cout<<"\nEnter a Number to Search: ";
+    cin>>num;
+    for(i=0; i<10; i++)
+    {
+        if(arr[i]==num)
+        {
+            index = i;
+            break;
+        }
+    }
+    cout<<"\nFound at Index No."<<index;
+    cout<<endl;
+    return 0;
+}
diff --git a/Longest Common Subsequence b/Longest Common Subsequence
new file mode 100644
index 00000000..e8d900ae
--- /dev/null
+++ b/Longest Common Subsequence	
@@ -0,0 +1,23 @@
+def lcs(s1 , s2):
+m, n = len(s1), len(s2)
+prev, cur = [0]*(n+1), [0]*(n+1)
+for i in range(1, m+1):
+	for j in range(1, n+1):
+		if s1[i-1] == s2[j-1]:
+			cur[j] = 1 + prev[j-1]
+		else:
+			if cur[j-1] > prev[j]:
+				cur[j] = cur[j-1]
+			else:
+				cur[j] = prev[j]
+	cur, prev = prev, cur
+return prev[n]
+
+#end of function lcs
+
+
+# Driver program to test the above function
+s1 = "AGGTAB"
+s2 = "GXTXAYB"
+print("Length of LCS is ", lcs(s1, s2))
+# BY ujjwal-shukla
diff --git a/Longest Increasing Subsequence b/Longest Increasing Subsequence
new file mode 100644
index 00000000..ce6beaa2
--- /dev/null
+++ b/Longest Increasing Subsequence	
@@ -0,0 +1,67 @@
+/* A Naive C++ recursive implementation
+of LIS problem */
+#include <iostream>
+using namespace std;
+
+/* To make use of recursive calls, this
+function must return two things:
+1) Length of LIS ending with element arr[n-1].
+	We use max_ending_here for this purpose
+2) Overall maximum as the LIS may end with
+	an element before arr[n-1] max_ref is
+	used this purpose.
+The value of LIS of full array of size n
+is stored in *max_ref which is our final result
+*/
+int _lis(int arr[], int n, int* max_ref)
+{
+	/* Base case */
+	if (n == 1)
+		return 1;
+
+	// 'max_ending_here' is length of LIS
+	// ending with arr[n-1]
+	int res, max_ending_here = 1;
+
+	/* Recursively get all LIS ending with arr[0],
+	arr[1] ... arr[n-2]. If arr[i-1] is smaller
+	than arr[n-1], and max ending with arr[n-1]
+	needs to be updated, then update it */
+	for (int i = 1; i < n; i++) {
+		res = _lis(arr, i, max_ref);
+		if (arr[i - 1] < arr[n - 1]
+			&& res + 1 > max_ending_here)
+			max_ending_here = res + 1;
+	}
+
+	// Compare max_ending_here with the overall
+	// max. And update the overall max if needed
+	if (*max_ref < max_ending_here)
+		*max_ref = max_ending_here;
+
+	// Return length of LIS ending with arr[n-1]
+	return max_ending_here;
+}
+
+// The wrapper function for _lis()
+int lis(int arr[], int n)
+{
+	// The max variable holds the result
+	int max = 1;
+
+	// The function _lis() stores its result in max
+	_lis(arr, n, &max);
+
+	// returns max
+	return max;
+}
+
+/* Driver program to test above function */
+int main()
+{
+	int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };
+	int n = sizeof(arr) / sizeof(arr[0]);
+	cout <<"Length of lis is "<< lis(arr, n);
+	return 0;
+}
+// This code is contributed by ujjwal-shukla
diff --git a/Longest Path in a Matrix b/Longest Path in a Matrix
new file mode 100644
index 00000000..1f86119b
--- /dev/null
+++ b/Longest Path in a Matrix	
@@ -0,0 +1,72 @@
+// C++ program to find the longest path in a matrix
+// with given constraints
+#include <bits/stdc++.h>
+#define n 3
+using namespace std;
+
+// Returns length of the longest path beginning with mat[i][j].
+// This function mainly uses lookup table dp[n][n]
+int findLongestFromACell(int i, int j, int mat[n][n], int dp[n][n])
+{
+    if (i < 0 || i >= n || j < 0 || j >= n)
+        return 0;
+
+    // If this subproblem is already solved
+    if (dp[i][j] != -1)
+        return dp[i][j];
+
+    // To store the path lengths in all the four directions
+    int x = INT_MIN, y = INT_MIN, z = INT_MIN, w = INT_MIN;
+
+    // Since all numbers are unique and in range from 1 to n*n,
+    // there is atmost one possible direction from any cell
+    if (j < n - 1 && ((mat[i][j] + 1) == mat[i][j + 1]))
+        x = 1 + findLongestFromACell(i, j + 1, mat, dp);
+
+    if (j > 0 && (mat[i][j] + 1 == mat[i][j - 1]))
+        y = 1 + findLongestFromACell(i, j - 1, mat, dp);
+
+    if (i > 0 && (mat[i][j] + 1 == mat[i - 1][j]))
+        z = 1 + findLongestFromACell(i - 1, j, mat, dp);
+
+    if (i < n - 1 && (mat[i][j] + 1 == mat[i + 1][j]))
+        w = 1 + findLongestFromACell(i + 1, j, mat, dp);
+
+    // If none of the adjacent fours is one greater we will take 1
+    // otherwise we will pick maximum from all the four directions
+    return dp[i][j] = max(x, max(y, max(z, max(w, 1))));
+}
+
+// Returns length of the longest path beginning with any cell
+int finLongestOverAll(int mat[n][n])
+{
+    int result = 1; // Initialize result
+
+    // Create a lookup table and fill all entries in it as -1
+    int dp[n][n];
+    memset(dp, -1, sizeof dp);
+
+    // Compute longest path beginning from all cells
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            if (dp[i][j] == -1)
+                findLongestFromACell(i, j, mat, dp);
+
+            // Update result if needed
+            result = max(result, dp[i][j]);
+        }
+    }
+
+    return result;
+}
+
+// Driver program
+int main()
+{
+    int mat[n][n] = { { 1, 2, 9 },
+                      { 5, 3, 8 },
+                      { 4, 6, 7 } };
+    cout << "Length of the longest path is "
+         << finLongestOverAll(mat);
+    return 0;
+}
diff --git a/LongestCommonSubsequence.cpp b/LongestCommonSubsequence.cpp
new file mode 100644
index 00000000..e523a8e6
--- /dev/null
+++ b/LongestCommonSubsequence.cpp
@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+//Longest Common SubSequence
+#define f(i, a, b) for (int i = a; i < b; i++)
+#define vi vector<int>
+
+int solve(string s1, string s2, vector<vector<int>> &dp)
+{
+    int n = s1.size() + 1, m = s2.size() + 1;
+    f(i, 1, n)
+    {
+        f(j, 1, m)
+        {
+            if (s1[i - 1] == s2[j - 1])
+                dp[i][j] = 1 + dp[i - 1][j - 1];
+            else
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+
+    return dp[n - 1][m - 1];
+}
+int main()
+{
+
+    string s1, s2;
+    cin >> s1 >> s2;
+    int n = s1.size() + 1, m = s2.size() + 1;
+    vector<vector<int>> dp(n, vector<int>(m, 0));
+    cout <<"Longest Common SubSequence: "<< solve(s1, s2, dp) << endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Longest_common_substring.cpp b/Longest_common_substring.cpp
new file mode 100644
index 00000000..c1ffe85a
--- /dev/null
+++ b/Longest_common_substring.cpp
@@ -0,0 +1,57 @@
+#include <iostream>
+#include <string.h>
+using namespace std;
+ 
+/* Returns length of longest
+   common substring of X[0..m-1]
+   and Y[0..n-1] */
+int LCSubStr(char* X, char* Y, int m, int n)
+{
+    // Create a table to store
+    // lengths of longest
+    // common suffixes of substrings.  
+    // Note that LCSuff[i][j] contains
+    // length of longest common suffix
+    // of X[0..i-1] and Y[0..j-1].
+ 
+    int LCSuff[m + 1][n + 1];
+    int result = 0; // To store length of the
+                    // longest common substring
+ 
+    /* Following steps build LCSuff[m+1][n+1] in
+        bottom up fashion. */
+    for (int i = 0; i <= m; i++)
+    {
+        for (int j = 0; j <= n; j++)
+        {
+            // The first row and first column
+            // entries have no logical meaning,
+            // they are used only for simplicity
+            // of program
+            if (i == 0 || j == 0)
+                LCSuff[i][j] = 0;
+ 
+            else if (X[i - 1] == Y[j - 1]) {
+                LCSuff[i][j] = LCSuff[i - 1][j - 1] + 1;
+                result = max(result, LCSuff[i][j]);
+            }
+            else
+                LCSuff[i][j] = 0;
+        }
+    }
+    return result;
+}
+ 
+// Driver code
+int main()
+{
+    char X[] = "OldSite:GeeksforGeeks.org";
+    char Y[] = "NewSite:GeeksQuiz.com";
+ 
+    int m = strlen(X);
+    int n = strlen(Y);
+ 
+    cout << "Length of Longest Common Substring is "
+         << LCSubStr(X, Y, m, n);
+    return 0;
+}
\ No newline at end of file
diff --git a/Map-using-JavaScript-main.zip b/Map-using-JavaScript-main.zip
new file mode 100644
index 00000000..ebb1b0ad
Binary files /dev/null and b/Map-using-JavaScript-main.zip differ
diff --git a/Matrix Rotation.py b/Matrix Rotation.py
new file mode 100644
index 00000000..2dba41cc
--- /dev/null
+++ b/Matrix Rotation.py	
@@ -0,0 +1,84 @@
+def rotateMatrix(mat):
+ 
+    if not len(mat):
+        return
+     
+    """
+        top : starting row index
+        bottom : ending row index
+        left : starting column index
+        right : ending column index
+    """
+ 
+    top = 0
+    bottom = len(mat)-1
+ 
+    left = 0
+    right = len(mat[0])-1
+ 
+    while left < right and top < bottom:
+ 
+        # Store the first element of next row,
+        # this element will replace first element of
+        # current row
+        prev = mat[top+1][left]
+ 
+        # Move elements of top row one step right
+        for i in range(left, right+1):
+            curr = mat[top][i]
+            mat[top][i] = prev
+            prev = curr
+ 
+        top += 1
+ 
+        # Move elements of rightmost column one step downwards
+        for i in range(top, bottom+1):
+            curr = mat[i][right]
+            mat[i][right] = prev
+            prev = curr
+ 
+        right -= 1
+ 
+        # Move elements of bottom row one step left
+        for i in range(right, left-1, -1):
+            curr = mat[bottom][i]
+            mat[bottom][i] = prev
+            prev = curr
+ 
+        bottom -= 1
+ 
+        # Move elements of leftmost column one step upwards
+        for i in range(bottom, top-1, -1):
+            curr = mat[i][left]
+            mat[i][left] = prev
+            prev = curr
+ 
+        left += 1
+ 
+    return mat
+ 
+# Utility Function
+def printMatrix(mat):
+    for row in mat:
+        print row
+ 
+ 
+# Test case 1
+matrix =[
+            [1,  2,  3,  4 ],
+            [5,  6,  7,  8 ],
+            [9,  10, 11, 12 ],
+            [13, 14, 15, 16 ] 
+        ]
+# Test case 2
+"""
+matrix =[
+            [1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9]
+        ]
+"""
+ 
+matrix = rotateMatrix(matrix)
+# Print modified matrix
+printMatrix(matrix)
diff --git a/MatrixAddition.java b/MatrixAddition.java
new file mode 100644
index 00000000..b65b699b
--- /dev/null
+++ b/MatrixAddition.java
@@ -0,0 +1,33 @@
+#include<iostream>
+using namespace std; 
+int main ()
+{
+    int m, n, p, q, i, j, A[5][5], B[5][5], C[5][5];
+    cout << "Enter rows and column of matrix A : ";
+    cin >> m >> n;
+    cout << "Enter rows and column of matrix B : ";
+    cin >> p >> q; 
+    if ((m != p) && (n != q))
+    {
+        cout << "Matrices cannot be added!";
+        exit(0);
+    }	
+    cout << "Enter elements of matrix A : ";
+    for (i = 0; i < m; i++)
+        for (j = 0; j < n; j++)
+            cin >> A[i][j];
+	cout << "Enter elements of matrix B : ";
+    for (i = 0; i < p; i++)
+        for (j = 0; j < q; j++)
+            cin >> B[i][j];		
+    for (i = 0; i < m; i++)
+        for (j = 0; j < n; j++)
+            C[i][j] = A[i][j] + B[i][j];
+    cout << "Sum of matrices\n";
+    for (i = 0; i < m; i++)
+    {    for (j = 0; j < n; j++)
+            cout << C[i][j] << "  ";	
+        cout << "\n";
+    }
+    return 0;
+}
diff --git a/Max Sub Array.py b/Max Sub Array.py
new file mode 100644
index 00000000..b7ba0ada
--- /dev/null
+++ b/Max Sub Array.py	
@@ -0,0 +1,16 @@
+def maxSubArraySum(a,size):
+     
+    max_so_far = a[0]
+    max_ending_here = 0
+     
+    for i in range(0, size):
+        max_ending_here = max_ending_here + a[i]
+        if max_ending_here < 0:
+            max_ending_here = 0
+         
+        # Do not compare for all elements. Compare only  
+        # when  max_ending_here > 0
+        elif (max_so_far < max_ending_here):
+            max_so_far = max_ending_here
+             
+    return max_so_far
diff --git a/Maximum_Subarray.java b/Maximum_Subarray.java
new file mode 100644
index 00000000..43e80ffd
--- /dev/null
+++ b/Maximum_Subarray.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int sum = 0;
+        int max = nums[0];
+        
+        for(int i = 0;i<nums.length;i++){
+            if((sum < 0) && (nums[i] > sum)){
+                sum = nums[i];
+            }
+            else{
+                sum += nums[i];
+            }
+            if(max < sum ){
+                max = sum;
+            } 
+        }
+        return max;
+    }
+}
diff --git a/Merge K sorted Linked Lists b/Merge K sorted Linked Lists
new file mode 100644
index 00000000..70c9896d
--- /dev/null
+++ b/Merge K sorted Linked Lists	
@@ -0,0 +1,117 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node
+{
+	int data;
+	Node* next;
+	
+	Node(int x){
+	    data = x;
+	    next = NULL;
+	}
+	
+};
+
+void printList(Node* node)
+{
+	while (node != NULL)
+	{
+		printf("%d ", node->data);
+		node = node->next;
+	}
+	cout<<endl;
+}
+
+/*Linked list Node structure
+
+struct Node
+{
+	int data;
+	Node* next;
+	
+	Node(int x){
+	    data = x;
+	    next = NULL;
+	}
+	
+};
+*/ 
+
+class Solution{
+  public:
+    //Function to merge K sorted linked list.
+    struct comparator{
+        bool operator()(Node* h1, Node* h2){
+            return h1->data > h2->data; 
+        }
+    };
+    
+    Node * mergeKLists(Node *arr[], int K)
+    {
+           // Your code here
+           priority_queue<Node*, vector<Node*>, comparator> pq; 
+           
+           int idx =0; 
+           while(idx < K){
+               if(arr[idx]!=NULL){
+                   pq.push(arr[idx]);
+                   idx++;
+               }
+                
+           }
+           Node* dummyNode= new Node(-1); 
+           Node* temp= dummyNode; 
+           while(!pq.empty()){
+               
+               Node* topEl= pq.top(); 
+               pq.pop();
+               temp->next= topEl; 
+               temp=temp->next; 
+               
+               if(topEl->next != NULL){
+                   pq.push(topEl->next); 
+               }
+           }
+           Node* head= dummyNode->next; 
+           return head; 
+    }
+};
+
+
+int main()
+{
+   int t;
+   cin>>t;
+   while(t--)
+   {
+	   int N;
+	   cin>>N;
+       struct Node *arr[N];
+       for(int j=0;j<N;j++)
+        {
+           int n;
+           cin>>n;
+
+           int x;
+           cin>>x;
+           arr[j]=new Node(x);
+           Node *curr = arr[j];
+           n--;
+
+           for(int i=0;i<n;i++)
+           {
+               cin>>x;
+               Node *temp = new Node(x);
+               curr->next =temp;
+               curr=temp;
+           }
+   		}
+   		Solution obj;
+   		Node *res = obj.mergeKLists(arr,N);
+		printList(res);
+
+   }
+
+	return 0;
+}
diff --git a/Merge-sort.c b/Merge-sort.c
new file mode 100644
index 00000000..b5cae63e
--- /dev/null
+++ b/Merge-sort.c
@@ -0,0 +1,74 @@
+#include<stdlib.h>
+#include<stdio.h>
+
+void merge(int arr[], int l, int m, int r)
+{
+int i, j, k;
+int n1 = m - l + 1;
+int n2 = r - m;
+int L[n1], R[n2];
+for (i = 0; i < n1; i++)
+L[i] = arr[l + i];
+for (j = 0; j < n2; j++)
+R[j] = arr[m + 1+ j];
+i = 0;
+j = 0;
+k = l;
+while (i < n1 && j < n2)
+{
+if (L[i] <= R[j])
+{
+arr[k] = L[i];
+i++;
+}
+else
+{
+arr[k] = R[j];
+j++;
+}
+k++;
+}
+while (i < n1)
+{
+arr[k] = L[i];
+i++;
+k++;
+}
+while (j < n2)
+{
+arr[k] = R[j];
+j++;
+k++;
+}
+}
+void mergeSort(int arr[], int l, int r)
+{
+if (l < r)
+{
+int m = l+(r-l)/2;
+mergeSort(arr, l, m);
+mergeSort(arr, m+1, r);
+merge(arr, l, m, r);
+}
+}
+void printArray(int A[], int n)
+{
+int i;
+for (i=0; i < n; i++)
+printf("%d ", A[i]);
+}
+int main()
+{
+int n;
+printf("Enter number of elements");
+scanf("%d",&n);
+int arr[n];
+printf("Enter elements");
+for(int i=0;i<n;i++){
+    scanf("%d",&arr[i]);
+}
+mergeSort(arr, 0, n - 1);
+printf("Sorted array is:");
+printArray(arr,n);
+return 0;
+}
diff --git a/Merge.c b/Merge.c
new file mode 100644
index 00000000..ab578c5e
--- /dev/null
+++ b/Merge.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <stdlib.h>
+void merge(int arr[], int l, int m, int r)
+{
+    int i, j, k;
+    int n1 = m - l + 1;
+    int n2 = r - m;
+    int L[n1], R[n2];
+    for (i = 0; i < n1; i++)
+        L[i] = arr[l + i];
+    for (j = 0; j < n2; j++)
+        R[j] = arr[m + 1 + j];
+    i = 0; 
+    j = 0; 
+    k = l; 
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) {
+            arr[k] = L[i];
+            i++;
+        }
+        else {
+            arr[k] = R[j];
+            j++;
+        }
+        k++;
+    }
+    while (i < n1) {
+        arr[k] = L[i];
+        i++;
+        k++;
+    }
+    while (j < n2) {
+        arr[k] = R[j];
+        j++;
+        k++;
+    }
+}
+  
+void mergeSort(int arr[], int l, int r)
+{
+    if (l < r) {
+        int m = l + (r - l) / 2;
+        mergeSort(arr, l, m);
+        mergeSort(arr, m + 1, r);
+  
+        merge(arr, l, m, r);
+    }
+}
+  
+
+void printArray(int A[], int size)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        printf("%d ", A[i]);
+    printf("\n");
+}
+  
+//Driver code
+int main()
+{
+    int arr[] = { 12, 11, 13, 5, 6, 7 };
+    int arr_size = sizeof(arr) / sizeof(arr[0]);
+  
+    printf("Given array is \n");
+    printArray(arr, arr_size);
+    mergeSort(arr, 0, arr_size - 1);
+    printf("\nSorted array is \n");
+    printArray(arr, arr_size);
+    return 0;
+}
\ No newline at end of file
diff --git a/MergeSort.cpp b/MergeSort.cpp
new file mode 100644
index 00000000..79e4de59
--- /dev/null
+++ b/MergeSort.cpp
@@ -0,0 +1,81 @@
+// C++ program for Merge Sort
+#include <iostream>
+using namespace std;
+
+void merge(int array[], int const left, int const mid, int const right)
+{
+	auto const subArrayOne = mid - left + 1;
+	auto const subArrayTwo = right - mid;
+
+	// Create temp arrays
+	auto *leftArray = new int[subArrayOne],
+		*rightArray = new int[subArrayTwo];
+
+	for (auto i = 0; i < subArrayOne; i++)
+		leftArray[i] = array[left + i];
+	for (auto j = 0; j < subArrayTwo; j++)
+		rightArray[j] = array[mid + 1 + j];
+
+	auto indexOfSubArrayOne = 0, // Initial index of first sub-array
+		indexOfSubArrayTwo = 0; // Initial index of second sub-array
+	int indexOfMergedArray = left; // Initial index of merged array
+
+	while (indexOfSubArrayOne < subArrayOne && indexOfSubArrayTwo < subArrayTwo) {
+		if (leftArray[indexOfSubArrayOne] <= rightArray[indexOfSubArrayTwo]) {
+			array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
+			indexOfSubArrayOne++;
+		}
+		else {
+			array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
+			indexOfSubArrayTwo++;
+		}
+		indexOfMergedArray++;
+	}
+
+	while (indexOfSubArrayOne < subArrayOne) {
+		array[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
+		indexOfSubArrayOne++;
+		indexOfMergedArray++;
+	}
+
+	while (indexOfSubArrayTwo < subArrayTwo) {
+		array[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
+		indexOfSubArrayTwo++;
+		indexOfMergedArray++;
+	}
+}
+
+
+void mergeSort(int array[], int const begin, int const end)
+{
+	if (begin >= end)
+		return; // Returns recursively
+
+	auto mid = begin + (end - begin) / 2;
+	mergeSort(array, begin, mid);
+	mergeSort(array, mid + 1, end);
+	merge(array, begin, mid, end);
+}
+
+void printArray(int A[], int size)
+{
+	for (auto i = 0; i < size; i++)
+		cout << A[i] << " ";
+}
+
+
+int main()
+{
+	int arr[] = { 12, 11, 13, 5, 6, 7 };
+	auto arr_size = sizeof(arr) / sizeof(arr[0]);
+
+	cout << "Given array is \n";
+	printArray(arr, arr_size);
+
+	mergeSort(arr, 0, arr_size - 1);
+
+	cout << "\nSorted array is \n";
+	printArray(arr, arr_size);
+	return 0;
+}
+
diff --git a/MinimumPlatforms.cpp b/MinimumPlatforms.cpp
new file mode 100644
index 00000000..d2f61603
--- /dev/null
+++ b/MinimumPlatforms.cpp
@@ -0,0 +1,43 @@
+// C++ program to find minimum number of platforms
+// required on a railway station
+#include <bits/stdc++.h>
+using namespace std;
+
+int minPlatform(int arrival[], int departure[], int n)
+{
+
+	// as time range from 0 to 2359 in 24 hour clock,
+	// we declare an array for values from 0 to 2360
+	int platform[2361] = {0};
+	int requiredPlatform = 1;
+	for (int i = 0; i < n; i++) {
+
+		// increment the platforms for arrival
+		++platform[arrival[i]];
+
+		// once train departs we decrease the platform count
+		--platform[departure[i] + 1];
+	}
+
+	// We are running loop till 2361 because maximum time value
+	// in a day can be 23:60
+	for (int i = 1; i < 2361; i++) {
+
+		// taking cumulative sum of platform give us required
+		// number of platform fro every minute
+		platform[i] = platform[i] + platform[i - 1];
+		requiredPlatform = max(requiredPlatform, platform[i]);
+	}
+	return requiredPlatform;
+}
+
+// Driver code
+int main()
+{
+	int arr[] = { 900, 940, 950, 1100, 1500, 1800 };
+	int dep[] = { 910, 1200, 1120, 1130, 1900, 2000 };
+	int n = sizeof(arr) / sizeof(arr[0]);
+	cout << "Minimum Number of Platforms Required = "
+		<< minPlatform(arr, dep, n);
+	return 0;
+}
diff --git a/Modern b/Modern
new file mode 100644
index 00000000..71ba3964
--- /dev/null
+++ b/Modern
@@ -0,0 +1,75 @@
+Hi 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Bye
diff --git a/N permutation R b/N permutation R
new file mode 100644
index 00000000..c1f7f06c
--- /dev/null
+++ b/N permutation R	
@@ -0,0 +1,27 @@
+#include<stdio.h>
+
+int fact(int n)
+{
+	if (n <= 1)
+		return 1;
+	return n*fact(n-1);
+}
+
+int nPr(int n, int r)
+{
+	return fact(n)/fact(n-r);
+}
+
+int main()
+{
+	int n, r;
+	printf("Enter n: ");
+	scanf("%d", &n);
+
+	printf("Enter r: ");
+	scanf("%d", &r);
+
+	printf("%dP%d is %d", n, r, nPr(n, r));
+
+	return 0;
+}
diff --git a/Navigationmenu.html b/Navigationmenu.html
new file mode 100644
index 00000000..4074e4a6
--- /dev/null
+++ b/Navigationmenu.html
@@ -0,0 +1,12 @@
+<!-- Load an icon library to show a hamburger menu (bars) on small screens -->
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
+
+<div class="topnav" id="myTopnav">
+  <a href="#home" class="active">Home</a>
+  <a href="#news">News</a>
+  <a href="#contact">Contact</a>
+  <a href="#about">About</a>
+  <a href="javascript:void(0);" class="icon" onclick="myFunction()">
+    <i class="fa fa-bars"></i>
+  </a>
+</div>
diff --git a/Navmenu.html b/Navmenu.html
new file mode 100644
index 00000000..4074e4a6
--- /dev/null
+++ b/Navmenu.html
@@ -0,0 +1,12 @@
+<!-- Load an icon library to show a hamburger menu (bars) on small screens -->
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
+
+<div class="topnav" id="myTopnav">
+  <a href="#home" class="active">Home</a>
+  <a href="#news">News</a>
+  <a href="#contact">Contact</a>
+  <a href="#about">About</a>
+  <a href="javascript:void(0);" class="icon" onclick="myFunction()">
+    <i class="fa fa-bars"></i>
+  </a>
+</div>
diff --git a/Number Guessing Game b/Number Guessing Game
new file mode 100644
index 00000000..c952fd65
--- /dev/null
+++ b/Number Guessing Game	
@@ -0,0 +1,48 @@
+""" Number Guessing Game
+----------------------------------------
+"""
+import random
+attempts_list = []
+def show_score():
+    if len(attempts_list) <= 0:
+        print("There is currently no high score, it's yours for the taking!")
+    else:
+        print("The current high score is {} attempts".format(min(attempts_list)))
+def start_game():
+    random_number = int(random.randint(1, 10))
+    print("Hello traveler! Welcome to the game of guesses!")
+    player_name = input("What is your name? ")
+    wanna_play = input("Hi, {}, would you like to play the guessing game? (Enter Yes/No) ".format(player_name))
+    // Where the show_score function USED to be
+    attempts = 0
+    show_score()
+    while wanna_play.lower() == "yes":
+        try:
+            guess = input("Pick a number between 1 and 10 ")
+            if int(guess) < 1 or int(guess) > 10:
+                raise ValueError("Please guess a number within the given range")
+            if int(guess) == random_number:
+                print("Nice! You got it!")
+                attempts += 1
+                attempts_list.append(attempts)
+                print("It took you {} attempts".format(attempts))
+                play_again = input("Would you like to play again? (Enter Yes/No) ")
+                attempts = 0
+                show_score()
+                random_number = int(random.randint(1, 10))
+                if play_again.lower() == "no":
+                    print("That's cool, have a good one!")
+                    break
+            elif int(guess) > random_number:
+                print("It's lower")
+                attempts += 1
+            elif int(guess) < random_number:
+                print("It's higher")
+                attempts += 1
+        except ValueError as err:
+            print("Oh no!, that is not a valid value. Try again...")
+            print("({})".format(err))
+    else:
+        print("That's cool, have a good one!")
+if __name__ == '__main__':
+    start_game()
diff --git a/Operator Overloading b/Operator Overloading
new file mode 100644
index 00000000..8fbbc639
--- /dev/null
+++ b/Operator Overloading	
@@ -0,0 +1,33 @@
+#include <iostream>  
+using namespace std;  
+class A  
+{  
+    
+    string x;  
+      public:  
+      A(){}  
+    A(string i)  
+    {  
+       x=i;  
+    }  
+    void operator+(A);  
+    void display();  
+};  
+  
+void A:: operator+(A a)  
+{  
+     
+    string m = x+a.x;  
+    cout<<"The result of the addition of two objects is : "<<m;  
+  
+}  
+int main()  
+{  
+    A a1("Welcome");  
+    A a2("back");  
+    a1+a2;  
+    return 0;  
+}
+
+//Output
+//The result of the addition of two objects is: Welcomeback
diff --git a/Palidrome b/Palidrome
new file mode 100644
index 00000000..5bd71e96
--- /dev/null
+++ b/Palidrome
@@ -0,0 +1,46 @@
+Programiz
+
+Search Programiz
+Get App
+
+
+C++ Program to Check Whether a Number is Palindrome or Not
+This program reverses an integer (entered by the user) using while loop. Then, if statement is used to check whether the reversed number is equal to the original number or not.
+
+To understand this example, you should have the knowledge of the following C++ programming topics:
+
+C++ while and do...while Loop
+C++ if, if...else and Nested if...else
+This program takes an integer from user and that integer is reversed.
+
+If the reversed integer is equal to the integer entered by user then, that number is a palindrome if not that number is not a palindrome.
+
+Example: Check Palindrome Number
+#include <iostream>
+using namespace std;
+
+#int main()
+{
+     int n, num, digit, rev = 0;
+
+     cout << "Enter a positive number: ";
+     cin >> num;
+
+     n = num;
+
+     do
+     {
+         digit = num % 10;
+         rev = (rev * 10) + digit;
+         num = num / 10;
+     } while (num != 0);
+
+     cout << " The reverse of the number is: " << rev << endl;
+
+     if (n == rev)
+         cout << " The number is a palindrome.";
+     else
+         cout << " The number is not a palindrome.";
+
+    return 0;
+}
diff --git a/Palidrome.cpp b/Palidrome.cpp
new file mode 100644
index 00000000..5bd71e96
--- /dev/null
+++ b/Palidrome.cpp
@@ -0,0 +1,46 @@
+Programiz
+
+Search Programiz
+Get App
+
+
+C++ Program to Check Whether a Number is Palindrome or Not
+This program reverses an integer (entered by the user) using while loop. Then, if statement is used to check whether the reversed number is equal to the original number or not.
+
+To understand this example, you should have the knowledge of the following C++ programming topics:
+
+C++ while and do...while Loop
+C++ if, if...else and Nested if...else
+This program takes an integer from user and that integer is reversed.
+
+If the reversed integer is equal to the integer entered by user then, that number is a palindrome if not that number is not a palindrome.
+
+Example: Check Palindrome Number
+#include <iostream>
+using namespace std;
+
+#int main()
+{
+     int n, num, digit, rev = 0;
+
+     cout << "Enter a positive number: ";
+     cin >> num;
+
+     n = num;
+
+     do
+     {
+         digit = num % 10;
+         rev = (rev * 10) + digit;
+         num = num / 10;
+     } while (num != 0);
+
+     cout << " The reverse of the number is: " << rev << endl;
+
+     if (n == rev)
+         cout << " The number is a palindrome.";
+     else
+         cout << " The number is not a palindrome.";
+
+    return 0;
+}
diff --git a/Palidrome.cpp1 b/Palidrome.cpp1
new file mode 100644
index 00000000..b08d2720
--- /dev/null
+++ b/Palidrome.cpp1
@@ -0,0 +1,46 @@
+Programiz
+
+Search Programiz
+Get App
+
+
+C++ Program to Check Whether a Number is Palindrome or Not
+This program reverses an integer (entered by the user) using while loop. Then, if statement is used to check whether the reversed number is equal to the original number or not.
+
+To understand this example, you should have the knowledge of the following C++ programming topics:
+
+C++ while and do...while Loop
+C++ if, if...else and Nested if...else
+This program takes an integer from user and that integer is reversed.
+
+If the reversed integer is equal to the integer entered by user then, that number is a palindrome if not that number is not a palindrome.
+
+Example: Check Palindrome Number
+#include <iostream>
+using namespace std;
+
+int main()
+{
+     int n, num, digit, rev = 0;
+
+     cout << "Enter a positive number: ";
+     cin >> num;
+
+     n = num;
+
+     do
+     {
+         digit = num % 10;
+         rev = (rev * 10) + digit;
+         num = num / 10;
+     } while (num != 0);
+
+     cout << " The reverse of the number is: " << rev << endl;
+
+     if (n == rev)
+         cout << " The number is a palindrome.";
+     else
+         cout << " The number is not a palindrome.";
+
+    return 0;
+}
diff --git a/Palidrome.cpp2 b/Palidrome.cpp2
new file mode 100644
index 00000000..d7cfda59
--- /dev/null
+++ b/Palidrome.cpp2
@@ -0,0 +1 @@
+your subscriber !!!
diff --git a/Palindrome Number.java b/Palindrome Number.java
new file mode 100644
index 00000000..1e23b02b
--- /dev/null
+++ b/Palindrome Number.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public boolean isPalindrome(int x) {
+        if( x < 0){
+            return false;
+        }
+        int ans = 0;
+        int num = x;
+        while(x != 0){
+            int r  = x % 10;
+            ans = ans * 10 + r;
+            x = x / 10;
+        }
+        if(ans == num){
+            return true;
+        }
+        return false;
+        //System.out.println(ans);
+    }
+}
+
+
+
+//Author:https://github.com/Devesh-vi
diff --git a/Palindromic partitioning b/Palindromic partitioning
new file mode 100644
index 00000000..92b94ab9
--- /dev/null
+++ b/Palindromic partitioning	
@@ -0,0 +1,75 @@
+// { Driver Code Starts
+// Initial Template for c++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution{
+public:
+int t[502][502];
+bool ispalindrome(string &str,int i,int j)
+{
+    while(i<j)
+    if(str[i++]!=str[j--])
+    return false;
+    return true;
+}
+int solve(string &st,int i,int j)
+{
+     if(i>=j)
+     return 0;
+     if(ispalindrome(st,i,j)==true)
+     return 0;
+     if(t[i][j]!=-1)
+     return t[i][j];
+     int temp;
+     int ans=INT_MAX;
+     for(int k=i;k<j;k++)
+     { int left,right;
+        if(t[i][k]!=-1)
+                    left = t[i][k];
+                else
+                {
+                    left = solve(st,i,k);
+                    t[i][k] = left;
+                }
+                if(t[k+1][j]!=-1)
+                    right = t[k+1][j];
+                else
+                {
+                    right = solve(st,k+1,j);
+                    t[k+1][j] = right;
+                }
+                temp=1+left+right;
+        ans=min(ans,temp);
+     }
+     return t[i][j]=ans;
+}
+    int palindromicPartition(string str)
+    {
+        // code here
+        memset(t,-1,sizeof(t));
+        int i=0,j=str.length()-1;
+        
+         return solve(str,i,j);
+         
+    }
+};
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        string str;
+        cin>>str;
+        
+        Solution ob;
+        cout<<ob.palindromicPartition(str)<<"\n";
+    }
+    return 0;
+}  // } Driver Code Ends
diff --git a/Palindrone.py b/Palindrone.py
new file mode 100644
index 00000000..278d2208
--- /dev/null
+++ b/Palindrone.py
@@ -0,0 +1,12 @@
+def isPalindrome(s):
+    return s == s[::-1]
+ 
+ 
+# Driver code
+s = "malayalam"
+ans = isPalindrome(s)
+ 
+if ans:
+    print("Yes")
+else:
+    print("No")
diff --git a/Pattern.cpp b/Pattern.cpp
new file mode 100644
index 00000000..664869d8
--- /dev/null
+++ b/Pattern.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+// #include <string>
+#include<fstream>
+
+using namespace std;
+
+int pattern(int n){
+    int c;
+    cout<<"Enter 0 if you want triangle\nEnter 1 if you want reverse triangle ";
+    cin>>c;
+    if (c==0)
+    {
+       for (int i = 0; i < n; i++)
+       {
+           for (int j = 0; j < i+1; j++)
+           {
+               cout<<"*";
+           }
+           cout<<"\n";
+       }
+    }
+    else if (c==1)
+    {
+           for (int i = n; i > 0; i--)
+       {
+           for (int j = i; j > 0; j--)
+           {
+               cout<<"*";
+           }
+           cout<<"\n";
+       }
+    }
+    else
+    {
+        cout<<"Invalid Input";
+        return -1;
+    }
+    return 1;
+}
+
+int main(){
+    while (true)
+    {
+        int no_of_lines;
+        cout<<"Enter no of lines you want in pattern ";
+        cin>>no_of_lines;
+        if (no_of_lines>0)
+        {
+            int result=pattern(no_of_lines);
+            // if (result!=-1){
+            //     break;
+            // }
+        }
+        else
+        {
+            cout<<"Invalid input";
+        }
+
+        int Choice;
+        cout<<"Continue printing another pattern?? -- Press any no\nExit Program -- 0 ";
+        cin>>Choice;
+        if (Choice==0){
+            cout<<"Thanks For Using Our Program!!!"<<endl;
+            break;
+        }
+    }
+    return 0;
+}
diff --git a/Ping Pong Game b/Ping Pong Game
new file mode 100644
index 00000000..5945f78e
--- /dev/null
+++ b/Ping Pong Game	
@@ -0,0 +1,84 @@
+from random import choice, random
+from turtle import *
+
+from freegames import vector
+
+
+def value():
+    "Randomly generate value between (-5, -3) or (3, 5)."
+    return (3 + random() * 2) * choice([1, -1])
+
+
+ball = vector(0, 0)
+aim = vector(value(), value())
+state = {1: 0, 2: 0}
+
+
+def move(player, change):
+    "Move player position by change."
+    state[player] += change
+
+
+def rectangle(x, y, width, height):
+    "Draw rectangle at (x, y) with given width and height."
+    up()
+    goto(x, y)
+    down()
+    begin_fill()
+    for count in range(2):
+        forward(width)
+        left(90)
+        forward(height)
+        left(90)
+    end_fill()
+
+
+def draw():
+    "Draw game and move pong ball."
+    clear()
+    rectangle(-200, state[1], 10, 50)
+    rectangle(190, state[2], 10, 50)
+
+    ball.move(aim)
+    x = ball.x
+    y = ball.y
+
+    up()
+    goto(x, y)
+    dot(10)
+    update()
+
+    if y < -200 or y > 200:
+        aim.y = -aim.y
+
+    if x < -185:
+        low = state[1]
+        high = state[1] + 50
+
+        if low <= y <= high:
+            aim.x = -aim.x
+        else:
+            return
+
+    if x > 185:
+        low = state[2]
+        high = state[2] + 50
+
+        if low <= y <= high:
+            aim.x = -aim.x
+        else:
+            return
+
+    ontimer(draw, 50)
+
+
+setup(420, 420, 370, 0)
+hideturtle()
+tracer(False)
+listen()
+onkey(lambda: move(1, 20), 'w')
+onkey(lambda: move(1, -20), 's')
+onkey(lambda: move(2, 20), 'i')
+onkey(lambda: move(2, -20), 'k')
+draw()
+done()
diff --git a/PreorderTransversal.cpp b/PreorderTransversal.cpp
new file mode 100644
index 00000000..1b07cb92
--- /dev/null
+++ b/PreorderTransversal.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+
+struct Node {
+	int data;
+	struct Node *left, *right;
+	Node(int data)
+	{
+		this->data = data;
+		left = right = NULL;
+	}
+};
+
+void printPreorder(struct Node* node)
+{
+	if (node == NULL)
+		return;
+
+	cout << node->data << " ";
+
+	printPreorder(node->left);
+	printPreorder(node->right);
+}
+
+int main()
+{
+	struct Node* root = new Node(1);
+	root->left = new Node(2);
+	root->right = new Node(3);
+	root->left->left = new Node(4);
+	root->left->right = new Node(5);
+
+	cout << "Preorder traversal of binary tree is \n";
+	printPreorder(root);
+
+
+	return 0;
+}
diff --git a/Prim's_Algo.cpp b/Prim's_Algo.cpp
new file mode 100644
index 00000000..c64e0563
--- /dev/null
+++ b/Prim's_Algo.cpp
@@ -0,0 +1,80 @@
+// Prim's Algorithm in C++
+
+#include <cstring>
+#include <iostream>
+using namespace std;
+
+#define INF 9999999
+
+// number of vertices in grapj
+#define V 5
+
+// create a 2d array of size 5x5
+//for adjacency matrix to represent graph
+
+int G[V][V] = {
+  {0, 9, 75, 0, 0},
+  {9, 0, 95, 19, 42},
+  {75, 95, 0, 51, 66},
+  {0, 19, 51, 0, 31},
+  {0, 42, 66, 31, 0}};
+
+int main() {
+  int no_edge;  // number of edge
+
+  // create a array to track selected vertex
+  // selected will become true otherwise false
+  int selected[V];
+
+  // set selected false initially
+  memset(selected, false, sizeof(selected));
+
+  // set number of edge to 0
+  no_edge = 0;
+
+  // the number of egde in minimum spanning tree will be
+  // always less than (V -1), where V is number of vertices in
+  //graph
+
+  // choose 0th vertex and make it true
+  selected[0] = true;
+
+  int x;  //  row number
+  int y;  //  col number
+
+  // print for edge and weight
+  cout << "Edge"
+     << " : "
+     << "Weight";
+  cout << endl;
+  while (no_edge < V - 1) {
+    //For every vertex in the set S, find the all adjacent vertices
+    // , calculate the distance from the vertex selected at step 1.
+    // if the vertex is already in the set S, discard it otherwise
+    //choose another vertex nearest to selected vertex  at step 1.
+
+    int min = INF;
+    x = 0;
+    y = 0;
+
+    for (int i = 0; i < V; i++) {
+      if (selected[i]) {
+        for (int j = 0; j < V; j++) {
+          if (!selected[j] && G[i][j]) {  // not in selected and there is an edge
+            if (min > G[i][j]) {
+              min = G[i][j];
+              x = i;
+              y = j;
+            }
+          }
+        }
+      }
+    }
+    cout << x << " - " << y << " :  " << G[x][y];
+    cout << endl;
+    selected[y] = true;
+    no_edge++;
+  }
+
+  return 0;
+}
diff --git a/Prime_factors.cpp b/Prime_factors.cpp
new file mode 100644
index 00000000..61bdd808
--- /dev/null
+++ b/Prime_factors.cpp
@@ -0,0 +1,35 @@
+#include<iostream>
+
+using namespace std;
+
+int main()
+{
+	int number, i = 1, j, count;
+	
+	cout << "\nPlease Enter the Number to find the Prime Factors =  ";
+	cin >> number;
+	
+	while (i <= number)
+   	{
+   		count = 0;
+    	if(number % i == 0)
+      	{
+      		j = 1;
+      		while(j <= i)
+      		{
+      			if(i % j == 0)
+      			{
+      				count++;
+				}
+				j++;
+			}
+			if(count == 2)
+			{
+				cout << i << " is a Prime Factor\n";
+			} 
+      	}
+    	i++;
+   	}
+		
+ 	return 0;
+}
diff --git a/Printing Armstrong numbers b/Printing Armstrong numbers
new file mode 100644
index 00000000..3f97e08e
--- /dev/null
+++ b/Printing Armstrong numbers	
@@ -0,0 +1,28 @@
+#include<stdio.h>  
+#include<math.h>
+int main()
+{
+int n,s,r,n1,c,x;
+printf("Enter the range:\n");
+scanf("%d",&x);
+for(n=1;n<=x;n++)
+{
+    c=0;
+    n1=n;
+    while(n1!=0){
+        n1=n1/10;
+        c++;
+    }
+    n1=n;
+    s=0;
+    while(n1!=0)
+    {
+        r=n1%10;
+        s=s+pow(r,c);
+        n1=n1/10;
+    }
+    if(s==n)
+    printf("%d\t",n);
+}
+return 0;
+}
diff --git a/Program for FCFS b/Program for FCFS
new file mode 100644
index 00000000..54f5c3f7
--- /dev/null
+++ b/Program for FCFS	
@@ -0,0 +1,58 @@
+#include<iostream>
+using namespace std;
+int main() {
+	int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
+	cout<<"Enter Total Number of Process:";
+	cin>>n;
+	cout<<"nEnter Burst Time and Priorityn";
+	for (i=0;i<n;i++) {
+		cout<<"nP["<<i+1<<"]n";
+		cout<<"Burst Time:";
+		cin>>bt[i];
+		cout<<"Priority:";
+		cin>>pr[i];
+		p[i]=i+1;
+		//contains process number
+	}
+	//sorting burst time, priority and process number in ascending order using selection sort
+	for (i=0;i<n;i++) {
+		pos=i;
+		for (j=i+1;j<n;j++) {
+			if(pr[j]<pr[pos])
+			                pos=j;
+		}
+		temp=pr[i];
+		pr[i]=pr[pos];
+		pr[pos]=temp;
+		temp=bt[i];
+		bt[i]=bt[pos];
+		bt[pos]=temp;
+		temp=p[i];
+		p[i]=p[pos];
+		p[pos]=temp;
+	}
+	wt[0]=0;
+	//waiting time for first process is zero
+	//calculate waiting time
+	for (i=1;i<n;i++) {
+		wt[i]=0;
+		for (j=0;j<i;j++)
+		            wt[i]+=bt[j];
+		total+=wt[i];
+	}
+	avg_wt=total/n;
+	//average waiting time
+	total=0;
+	cout<<"nProcesst    Burst Time    tWaiting TimetTurnaround Time";
+	for (i=0;i<n;i++) {
+		tat[i]=bt[i]+wt[i];
+		//calculate turnaround time
+		total+=tat[i];
+		cout<<"nP["<<p[i]<<"]tt  "<<bt[i]<<"tt    "<<wt[i]<<"ttt"<<tat[i];
+	}
+	avg_tat=total/n;
+	//average turnaround time
+	cout<<"nnAverage Waiting Time="<<avg_wt;
+	cout<<"nAverage Turnaround Time="<<avg_tat;
+	return 0;
+}
diff --git a/PythonReverseString b/PythonReverseString
new file mode 100644
index 00000000..22d572df
--- /dev/null
+++ b/PythonReverseString
@@ -0,0 +1,13 @@
+def reverse(s):
+  str = ""
+  for i in s:
+    str = i + str
+  return str
+  
+s = "Geeksforgeeks"
+  
+print ("The original string  is : ",end="")
+print (s)
+  
+print ("The reversed string(using loops) is : ",end="")
+print (reverse(s))
diff --git a/Quotient_and_Remainder.cpp b/Quotient_and_Remainder.cpp
new file mode 100644
index 00000000..628d6fac
--- /dev/null
+++ b/Quotient_and_Remainder.cpp
@@ -0,0 +1,21 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{    
+    int divisor, dividend, quotient, remainder;
+
+    cout << "Enter dividend: ";
+    cin >> dividend;
+
+    cout << "Enter divisor: ";
+    cin >> divisor;
+
+    quotient = dividend / divisor;
+    remainder = dividend % divisor;
+
+    cout << "Quotient = " << quotient << endl;
+    cout << "Remainder = " << remainder;
+
+    return 0;
+}
diff --git a/README.md b/README.md
index 4c46033c..7a416166 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,4 @@
 # Competitive-Programming-Algos
-C++ implementation of algorithms learned and used while competitive programming
+This repository is all about:
+Implementation of C++ algorithms learned and used while doing competitive programming.
+You can freely add your implementations or just make the earlier ones better
diff --git a/Radix sort b/Radix sort
new file mode 100644
index 00000000..36cae2fe
--- /dev/null
+++ b/Radix sort	
@@ -0,0 +1,73 @@
+#include <iostream>
+using namespace std;
+ 
+// A utility function to get maximum value in arr[]
+int getMax(int arr[], int n)
+{
+    int mx = arr[0];
+    for (int i = 1; i < n; i++)
+        if (arr[i] > mx)
+            mx = arr[i];
+    return mx;
+}
+ 
+// A function to do counting sort of arr[] according to
+// the digit represented by exp.
+void countSort(int arr[], int n, int exp)
+{
+    int output[n]; // output array
+    int i, count[10] = { 0 };
+ 
+    // Store count of occurrences in count[]
+    for (i = 0; i < n; i++)
+        count[(arr[i] / exp) % 10]++;
+ 
+    // Change count[i] so that count[i] now contains actual
+    //  position of this digit in output[]
+    for (i = 1; i < 10; i++)
+        count[i] += count[i - 1];
+ 
+    // Build the output array
+    for (i = n - 1; i >= 0; i--) {
+        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
+        count[(arr[i] / exp) % 10]--;
+    }
+ 
+    // Copy the output array to arr[], so that arr[] now
+    // contains sorted numbers according to current digit
+    for (i = 0; i < n; i++)
+        arr[i] = output[i];
+}
+ 
+// The main function to that sorts arr[] of size n using
+// Radix Sort
+void radixsort(int arr[], int n)
+{
+    // Find the maximum number to know number of digits
+    int m = getMax(arr, n);
+ 
+    // Do counting sort for every digit. Note that instead
+    // of passing digit number, exp is passed. exp is 10^i
+    // where i is current digit number
+    for (int exp = 1; m / exp > 0; exp *= 10)
+        countSort(arr, n, exp);
+}
+ 
+// A utility function to print an array
+void print(int arr[], int n)
+{
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+}
+ 
+// Driver Code
+int main()
+{
+    int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+     
+      // Function Call
+      radixsort(arr, n);
+    print(arr, n);
+    return 0;
+}
diff --git a/Radix_Sort.cpp b/Radix_Sort.cpp
new file mode 100644
index 00000000..1ff500c6
--- /dev/null
+++ b/Radix_Sort.cpp
@@ -0,0 +1,128 @@
+// implementation of radix sort using bin/bucket sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// structure for a single linked list to help further in the
+// sorting
+struct node {
+	int data;
+	node* next;
+};
+
+// function for creating a new node in the linked list
+struct node* create(int x)
+{
+	node* temp = new node();
+	temp->data = x;
+	temp->next = NULL;
+
+	return temp;
+}
+
+// utility function to append node in the linked list
+// here head is passed by reference, to know more about this
+// search pass by reference
+void insert(node*& head, int n)
+{
+	if (head == NULL) {
+		head = create(n);
+		return;
+	}
+
+	node* t = head;
+	while (t->next != NULL)
+		t = t->next;
+	t->next = create(n);
+}
+
+// utility function to pop an element from front in the list
+// for the sake of stability in sorting
+int del(node*& head)
+{
+	if (head == NULL)
+		return 0;
+	node* temp = head;
+	// storing the value of head before updating
+	int val = head->data;
+
+	// updation of head to next node
+	head = head->next;
+
+	delete temp;
+	return val;
+}
+
+// utility function to get the number of digits in the
+// max_element
+int digits(int n)
+{
+	int i = 1;
+	if (n < 10)
+		return 1;
+
+	while (n > (int)pow(10, i))
+		i++;
+	return i;
+}
+
+void radix_sort(vector<int>& arr)
+{
+	// size of the array to be sorted
+	int sz = arr.size();
+
+	// getting the maximum element in the array
+	int max_val = *max_element(arr.begin(), arr.end());
+
+	// getting digits in the maximum element
+	int d = digits(max_val);
+
+	// creating buckets to store the pointers
+	node** bins;
+
+	// array of pointers to linked list of size 10 as
+	// integers are decimal numbers so they can hold numbers
+	// from 0-9 only, that's why size of 10
+
+	bins = new node*[10];
+
+	// initializing the hash array with null to all
+	for (int i = 0; i < 10; i++)
+		bins[i] = NULL;
+
+	// first loop working for a constant time only and inner
+	// loop is iterating through the array to store elements
+	// of array in the linked list by their digits value
+	for (int i = 0; i < d; i++) {
+		for (int j = 0; j < sz; j++) // bins updation
+			insert(bins[(arr[j] / (int)pow(10, i)) % 10],
+				arr[j]);
+
+		int x = 0, y = 0;
+		// write back to the array after each pass
+
+		while (x < 10) {
+			while (bins[x] != NULL)
+				arr[y++] = del(bins[x]);
+			x++;
+		}
+	}
+}
+
+// a utility function to print the sorted array
+void print(vector<int> arr)
+{
+	for (int i = 0; i < arr.size(); i++)
+		cout << arr[i] << " ";
+	cout << endl;
+}
+
+int main()
+{
+	vector<int> arr = { 573, 25, 415, 12, 161, 6 };
+
+	// function call
+	radix_sort(arr);
+	print(arr);
+
+	return 0;
+}
diff --git a/Recursive factorials b/Recursive factorials
new file mode 100644
index 00000000..2d3cb898
--- /dev/null
+++ b/Recursive factorials	
@@ -0,0 +1,30 @@
+/*A recursive function is a nonleaf function that calls itself.
+The factorial function can be written as a recursive function call. 
+Recall that factorial(n) = n × (n – 1) × (n – 2) × … × 2 × 1. 
+The factorial function can be rewritten recursively as factorial(n) = n × factorial(n – 1).*/
+
+
+/#include<iostream>
+using namespace std;
+
+int factorial(int n);
+
+int main()
+{
+    int n;
+
+    cout << "Enter a positive integer: ";
+    cin >> n;
+
+    cout << "Factorial of " << n << " = " << factorial(n);
+
+    return 0;
+}
+
+int factorial(int n)
+{
+    if(n > 1)
+        return n * factorial(n - 1);
+    else
+        return 1;
+}
diff --git a/RecursiveBinarySearch.cpp b/RecursiveBinarySearch.cpp
new file mode 100644
index 00000000..43c54f3d
--- /dev/null
+++ b/RecursiveBinarySearch.cpp
@@ -0,0 +1,28 @@
+
+#include <bits/stdc++.h>
+using namespace std;
+int binarysearch(int arr[],int l,int r,int x){
+    if( r >= l){
+        int mid =l + (r - 1)/2;
+        
+        if(arr[mid]==x)
+            return mid;
+            
+        if(arr[mid] > x)
+            return binarysearch(arr,l,mid -1 ,x);
+        
+        return binarysearch(arr,mid+1,r,x);
+    }
+    return -1;
+}
+int main()
+{
+    int a[] = { 2, 3, 4, 10, 40 };
+    int x = 10;
+    int n = sizeof(a) / sizeof(a[0]);
+    int result = binarysearch(a, 0, n - 1, x);
+    (result == -1) ? cout << "Element is not present in array"
+                   : cout << "Element is present at index " << result;
+    return 0;
+}
+
diff --git a/RepeatedString.cpp b/RepeatedString.cpp
new file mode 100644
index 00000000..a9b11165
--- /dev/null
+++ b/RepeatedString.cpp
@@ -0,0 +1,70 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string ltrim(const string &);
+string rtrim(const string &);
+
+/*
+ * Complete the 'repeatedString' function below.
+ *
+ * The function is expected to return a LONG_INTEGER.
+ * The function accepts following parameters:
+ *  1. STRING s
+ *  2. LONG_INTEGER n
+ */
+
+long repeatedString(string s, long n) {
+    long count = 0;
+    for(int i=0;i<s.size();i++){
+        if(s[i]=='a') count++;
+    }
+    count = n/s.size()*count;
+    for(int i=0;i<n%s.size();i++){
+    if(s[i]=='a') count++;
+    }
+    return count;
+}
+
+int main()
+{
+    ofstream fout(getenv("OUTPUT_PATH"));
+
+    string s;
+    getline(cin, s);
+
+    string n_temp;
+    getline(cin, n_temp);
+
+    long n = stol(ltrim(rtrim(n_temp)));
+
+    long result = repeatedString(s, n);
+
+    fout << result << "\n";
+
+    fout.close();
+
+    return 0;
+}
+
+string ltrim(const string &str) {
+    string s(str);
+
+    s.erase(
+        s.begin(),
+        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
+    );
+
+    return s;
+}
+
+string rtrim(const string &str) {
+    string s(str);
+
+    s.erase(
+        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
+        s.end()
+    );
+
+    return s;
+}
diff --git a/RevArr.cpp b/RevArr.cpp
new file mode 100644
index 00000000..3bc44741
--- /dev/null
+++ b/RevArr.cpp
@@ -0,0 +1,26 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{
+
+    int n;
+    cout << ("Enter Size of Array ");
+    cin >> n;
+
+    cout << ("Enter Elements ");
+    int arr[n];
+    for (int i = 0; i < n; i++)
+    {
+        cin >> arr[i];
+    }
+
+    cout << ("The Array After Reversing is ");
+
+    for (int j = n-1 ; j >= 0; j--)
+    {
+        cout << arr[j]<<" ";
+    }
+
+    return 0;
+}
diff --git a/Reverse String Array.py b/Reverse String Array.py
new file mode 100644
index 00000000..af0831dc
--- /dev/null
+++ b/Reverse String Array.py	
@@ -0,0 +1,12 @@
+def reverseList(A, start, end):
+    while start < end:
+        A[start], A[end] = A[end], A[start]
+        start += 1
+        end -= 1
+
+        
+A = [1, 2, 3, 4, 5, 6]
+print(A)
+reverseList(A, 0, 5)
+print("Reversed list is")
+print(A)
diff --git a/Reverse a number using while loop b/Reverse a number using while loop
new file mode 100644
index 00000000..9598d0e0
--- /dev/null
+++ b/Reverse a number using while loop	
@@ -0,0 +1,14 @@
+public class ReverseNumberExample1   
+{  
+public static void main(String[] args)   
+{  
+int number = 987654, reverse = 0;  
+while(number != 0)   
+{  
+int remainder = number % 10;  
+reverse = reverse * 10 + remainder;  
+number = number/10;  
+}  
+System.out.println("The reverse of the given number is: " + reverse);  
+}  
+}  
diff --git a/Reverse_words_in_a_String.cpp b/Reverse_words_in_a_String.cpp
new file mode 100644
index 00000000..38f86e26
--- /dev/null
+++ b/Reverse_words_in_a_String.cpp
@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>                                                               
+using namespace std;
+
+void reverse(string& s, int low, int high){
+    while(low < high){
+        swap(s[low],s[high]);
+        low++;
+        high--;
+    }
+}
+string reverseString(string str){
+    str.insert(str.end(), ' ');
+    int start =0;
+    int n =str.length();
+    for(int end=0; end<n; end++)
+    {
+        if(str[end]==' '){
+            reverse(str,start,end-1);
+            start=end+1;
+        }
+
+    } 
+    str.pop_back();
+    reverse(str,0, str.length() -1);
+    return str;
+}
+
+int main(){
+
+    string str = "Ikl like this code";
+
+    string rev = reverseString(str);
+
+
+    cout << rev;
+    return 0;
+
+}
diff --git a/SelectionSort b/SelectionSort
new file mode 100644
index 00000000..85f88464
--- /dev/null
+++ b/SelectionSort
@@ -0,0 +1,36 @@
+import java.util.Scanner;
+
+public class SelectionSort_009 {// search for the smallest ele andswap it with 1st element
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // int n = a.length;
+        System.out.println("Enter the No. of elements you want to sort : ");
+        int m = sc.nextInt();
+        int a[] = new int[m];
+        System.out.println("Enter the elements :");
+        for (int i = 0; i < m; i++) {
+            a[i] = sc.nextInt();
+        }
+
+        for (int i = 0; i < m - 1; i++) {
+            int minInd = i;
+            for (int j = i; j < m; j++) {
+                if (a[j] < a[minInd]) {
+                    minInd = j;
+
+                }
+
+            }
+            int temp = a[i];
+            a[i] = a[minInd];
+            a[minInd] = temp;
+        }
+
+        for (int e : a) {
+            System.out.print(e + " ");
+        }
+        sc.close();
+    }
+
+}
diff --git a/SelectionSort.c b/SelectionSort.c
new file mode 100644
index 00000000..b3cf038c
--- /dev/null
+++ b/SelectionSort.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+int main()
+{ int n,i,j,swap;
+ printf("Enter number of elements\n");
+ scanf("%d",&n);
+ int arr[n];
+ printf("Enter elements\n");
+ for(i=0;i<n;i++){
+     scanf("%d",&arr[i]);
+ }
+ for(i=0;i<n-1;i++){
+     int pos= i;
+  for(j=i+1;j<n;j++){
+     if(arr[j]<arr[pos]){
+         pos=j;
+     } 
+  }
+  if(pos!=i){
+      swap=arr[pos];
+      arr[pos]=arr[i];
+      arr[i]=swap;
+  }
+ }
+ printf("Sorted array\n");
+ for(i=0;i<n;i++){
+     printf("%d\n",arr[i]);
+ }
+}
diff --git a/Sequential-search.py b/Sequential-search.py
new file mode 100644
index 00000000..77227589
--- /dev/null
+++ b/Sequential-search.py
@@ -0,0 +1,24 @@
+# Python3 code to linearly search x in arr[].
+# If x is present then return its location,
+# otherwise return -1
+
+
+def search(arr, n, x):
+
+	for i in range(0, n):
+		if (arr[i] == x):
+			return i
+	return -1
+
+
+# Driver Code
+arr = [2, 3, 4, 10, 40]
+x = 10
+n = len(arr)
+
+# Function call
+result = search(arr, n, x)
+if(result == -1):
+	print("Element is not present in array")
+else:
+	print("Element is present at index", result)
diff --git a/Sieve of Eratosthenes.cpp b/Sieve of Eratosthenes.cpp
new file mode 100644
index 00000000..96000c86
--- /dev/null
+++ b/Sieve of Eratosthenes.cpp	
@@ -0,0 +1,36 @@
+#include <bits/stdc++.h>
+using namespace std;
+ 
+void Sieve(int n)
+{
+    
+    vector<bool>prime(n+1,true);
+   
+ 
+    for (int p = 2; p * p <= n; p++)
+    {
+        
+        if (prime[p])
+        {
+            
+            for (int i = p * p; i <= n; i += p)
+                prime[i] = false;
+        }
+    }
+ 
+ 
+    for (int i = 2; i <= n; i++)
+        if (prime[i])
+            cout << i << " ";
+}
+ 
+
+int main()
+{
+    int n ;
+    
+    cin>>n;
+    
+    Sieve(n);
+    return 0;
+}
\ No newline at end of file
diff --git a/Simple half pyramid pattern b/Simple half pyramid pattern
new file mode 100644
index 00000000..3d6fb0ac
--- /dev/null
+++ b/Simple half pyramid pattern	
@@ -0,0 +1,9 @@
+# number of rows
+rows = 5
+for i in range(0, rows):
+    # nested loop for each column
+    for j in range(0, i + 1):
+        # print star
+        print("*", end=' ')
+    # new line after each row
+    print("\r")
diff --git a/Sort array with squares.cpp b/Sort array with squares.cpp
new file mode 100644
index 00000000..5fb5a424
--- /dev/null
+++ b/Sort array with squares.cpp	
@@ -0,0 +1,39 @@
+vector<int> Solution::solve(vector<int> &arr) {
+     int mid=0;
+    for(int i=0;i<arr.size();i++)
+    {
+        if(arr[i]>=0)
+        {
+            mid=i;
+            break;
+        }
+    }
+    int i=mid-1,j=mid;
+    vector<int>res(arr.size());
+    int k=0;
+    while(i>=0 && j<arr.size())
+    {
+        if((arr[i]*arr[i])<(arr[j]*arr[j]))
+        {
+            res[k++]=arr[i]*arr[i];
+            i--;
+        }
+        else
+        {
+            res[k++]=arr[j]*arr[j];
+            j++;
+        }
+    }
+    while(i>=0)
+    {
+        res[k++]=arr[i]*arr[i];
+        i--;
+    }
+    while(j<arr.size())
+    {
+        res[k++]=arr[j]*arr[j];
+        j++;
+    }
+
+    return res;
+}
diff --git a/Stock_Span_Problem.cpp b/Stock_Span_Problem.cpp
new file mode 100644
index 00000000..84db281d
--- /dev/null
+++ b/Stock_Span_Problem.cpp
@@ -0,0 +1,45 @@
+// C++ program for a linear time solution for stock
+// span problem without using stack
+#include <iostream>
+#include <stack>
+using namespace std;
+
+// An efficient method to calculate stock span values
+// implementing the same idea without using stack
+void calculateSpan(int A[], int n, int ans[])
+{
+	// Span value of first element is always 1
+	ans[0] = 1;
+
+	// Calculate span values for rest of the elements
+	for (int i = 1; i < n; i++) {
+		int counter = 1;
+		while ((i - counter) >= 0 && A[i] >= A[i - counter]) {
+			counter += ans[i - counter];
+		}
+		ans[i] = counter;
+	}
+}
+
+// A utility function to print elements of array
+void printArray(int arr[], int n)
+{
+	for (int i = 0; i < n; i++)
+		cout << arr[i] << " ";
+}
+
+// Driver program to test above function
+int main()
+{
+	int price[] = { 10, 4, 5, 90, 120, 80 };
+	int n = sizeof(price) / sizeof(price[0]);
+	int S[n];
+
+	// Fill the span values in array S[]
+	calculateSpan(price, n, S);
+
+	// print the calculated span values
+	printArray(S, n);
+
+	return 0;
+}
diff --git a/Subset Sum Problem b/Subset Sum Problem
new file mode 100644
index 00000000..09d8f449
--- /dev/null
+++ b/Subset Sum Problem	
@@ -0,0 +1,60 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution{
+public:
+
+    int dp[1001][1001]; 
+    int findAns(int N, int arr[], int s){
+        if(N==-1){
+            if(s==0){
+                return 1; 
+            }
+            return 0; 
+        }
+        if(s<0){
+            return 0; 
+        }
+        if(s==0){
+            return 1; 
+        }
+        if(dp[N][s] != -1){
+            return dp[N][s]; 
+        }
+
+        return dp[N][s]= findAns(N-1, arr, s-arr[N]) || findAns(N-1, arr, s) ; 
+        
+    }
+    int equalPartition(int N, int arr[])
+    {
+        //find sum
+        memset(dp, -1, sizeof(dp)); 
+        int sum=0; 
+        for(int i=0;i<N;i++){
+            sum+=arr[i]; 
+        }
+        if(sum%2 != 0){
+            return 0; 
+        }
+        return findAns(N-1, arr, sum/2);
+    }
+};
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        int arr[N];
+        for(int i = 0;i < N;i++)
+            cin>>arr[i];
+        
+        Solution ob;
+        if(ob.equalPartition(N, arr))
+            cout<<"YES\n";
+        else
+            cout<<"NO\n";
+    }
+    return 0;
+}
diff --git a/Sum of 3 numbers b/Sum of 3 numbers
new file mode 100644
index 00000000..6827be02
--- /dev/null
+++ b/Sum of 3 numbers	
@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+  double num1, num2,num3, sum;
+  cout << "Enter two numbers: ";
+
+  // stores two floating point numbers in num1 and num2 respectively
+  cin >> num1 >> num2>>num3;
+ 
+  // performs multiplication and stores the result in product variable
+  product = num1 + num2 + num3;  
+
+  cout << "sum = " << sum;    
+    
+  return 0;
+}
diff --git a/Tagsort.java b/Tagsort.java
new file mode 100644
index 00000000..cfb82fed
--- /dev/null
+++ b/Tagsort.java
@@ -0,0 +1,91 @@
+class Person
+{
+    private int id;
+    private float salary;
+    private Object someBigObject = new Object();
+  
+    public Person(int id, float salary)
+    {
+        this.id = id;
+        this.salary = salary;
+    }
+  
+    public float getSalary()
+    {
+        return salary;
+    }
+  
+    @Override
+    public String toString()
+    {
+        return "Person{" +
+               "id=" + id +
+               ", salary=" + salary +
+               ", someBigObject=" + someBigObject +
+               '}';
+    }
+}
+  
+public class Main
+{
+    public static void main(String[] args)
+    {
+        // Creating objects and their original
+        // order (in tag array)
+        int n = 5;
+        Person persons[] = new Person[n];
+        persons[0] = new Person(0, 233.5f);
+        persons[1] = new Person(1, 23f);
+        persons[2] = new Person(2, 13.98f);
+        persons[3] = new Person(3, 143.2f);
+        persons[4] = new Person(4, 3f);
+        int tag[] = new int[n];
+        for (int i = 0; i < n; i++)
+            tag[i] = i;
+  
+        // Every Person object is tagged to
+        // an element in the tag array.
+        System.out.println("Given Person and Tag ");
+        for (int i = 0; i < n; i++)
+            System.out.println(persons[i] +
+                               " : Tag: " + tag[i]);
+  
+        // Modifying tag array so that we can access
+        // persons in sorted order.
+        tagSort(persons, tag);
+  
+        System.out.println("New Tag Array after "+
+                           "getting sorted as per Person[] ");
+        for (int i=0; i<n; i++)
+            System.out.println(tag[i]);
+  
+        // Accessing persons in sorted (by salary)
+        // way using modified tag array.
+        for (int i = 0; i < n; i++)
+            System.out.println(persons[tag[i]]);
+    }
+  
+    // Modifying tag array so that we can access
+    // persons in sorted order of salary.
+    public static void tagSort(Person persons[],
+                               int tag[])
+    {
+        int n = persons.length;
+        for (int i=0; i<n; i++)
+        {
+            for (int j=i+1; j<n; j++)
+            {
+                if (persons[tag[i]].getSalary() >
+                        persons[tag[j]].getSalary())
+                {
+                    // Note we are not sorting the
+                    // actual Persons array, but only
+                    // the tag array
+                    int temp = tag[i];
+                    tag[i] = tag[j];
+                    tag[j] = temp;
+                }
+            }
+        }
+    }
+}
diff --git a/Ternary Search b/Ternary Search
new file mode 100644
index 00000000..8fa17967
--- /dev/null
+++ b/Ternary Search	
@@ -0,0 +1,14 @@
+double ternary_search(double l, double r) {
+    double eps = 1e-9;              //set the error limit here
+    while (r - l > eps) {
+        double m1 = l + (r - l) / 3;
+        double m2 = r - (r - l) / 3;
+        double f1 = f(m1);      //evaluates the function at m1
+        double f2 = f(m2);      //evaluates the function at m2
+        if (f1 < f2)
+            l = m1;
+        else
+            r = m2;
+    }
+    return f(l);                    //return the maximum of f(x) in [l, r]
+}
diff --git a/The Inclusion-Exclusion Principle b/The Inclusion-Exclusion Principle
new file mode 100644
index 00000000..d1ff2537
--- /dev/null
+++ b/The Inclusion-Exclusion Principle	
@@ -0,0 +1,27 @@
+int n;
+bool good[MAXN];
+int deg[MAXN], cnt[MAXN];
+
+long long solve() {
+    memset (good, 1, sizeof good);
+    memset (deg, 0, sizeof deg);
+    memset (cnt, 0, sizeof cnt);
+
+    long long ans_bad = 0;
+    for (int i=2; i<=n; ++i) {
+        if (good[i]) {
+            if (deg[i] == 0)  deg[i] = 1;
+            for (int j=1; i*j<=n; ++j) {
+                if (j > 1 && deg[i] == 1)
+                    if (j % i == 0)
+                        good[i*j] = false;
+                    else
+                        ++deg[i*j];
+                cnt[i*j] += (n / i) * (deg[i]%2==1 ? +1 : -1);
+            }
+        }
+        ans_bad += (cnt[i] - 1) * 1ll * (n-1 - cnt[i]);
+    }
+
+    return (n-1) * 1ll * (n-2) * (n-3) / 6 - ans_bad / 2;
+}
diff --git a/The Stock Span Problem b/The Stock Span Problem
new file mode 100644
index 00000000..9f84c2b0
--- /dev/null
+++ b/The Stock Span Problem	
@@ -0,0 +1,54 @@
+The Stock Span Problem
+
+
+// C++ program for brute force method
+// to calculate stock span values
+#include <bits/stdc++.h>
+using namespace std;
+ 
+// Fills array S[] with span values
+void calculateSpan(int price[], int n, int S[])
+{
+    // Span value of first day is always 1
+    S[0] = 1;
+ 
+    // Calculate span value of remaining days 
+    // by linearly checking previous days
+    for (int i = 1; i < n; i++)
+    {
+        S[i] = 1; // Initialize span value
+ 
+        // Traverse left while the next element 
+        // on left is smaller than price[i]
+        for (int j = i - 1; (j >= 0) &&
+                (price[i] >= price[j]); j--)
+            S[i]++;
+    }
+}
+ 
+// A utility function to print elements of array
+void printArray(int arr[], int n)
+{
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+}
+ 
+// Driver code
+int main()
+{
+    int price[] = { 10, 4, 5, 90, 120, 80 };
+    int n = sizeof(price) / sizeof(price[0]);
+    int S[n];
+ 
+    // Fill the span values in array S[]
+    calculateSpan(price, n, S);
+ 
+    // print the calculated span values
+    printArray(S, n);
+ 
+    return 0;
+}
+ 
+// This is code is contributed by rathbhupendra
+Output
+1 1 2 4 5 1
diff --git a/Topological Sort b/Topological Sort
new file mode 100644
index 00000000..55a76bca
--- /dev/null
+++ b/Topological Sort	
@@ -0,0 +1,108 @@
+// A C++ program to print topological
+// sorting of a DAG
+#include <iostream>
+#include <list>
+#include <stack>
+using namespace std;
+
+// Class to represent a graph
+class Graph {
+	// No. of vertices'
+	int V;
+
+	// Pointer to an array containing adjacency listsList
+	list<int>* adj;
+
+	// A function used by topologicalSort
+	void topologicalSortUtil(int v, bool visited[],
+							stack<int>& Stack);
+
+public:
+	// Constructor
+	Graph(int V);
+
+	// function to add an edge to graph
+	void addEdge(int v, int w);
+
+	// prints a Topological Sort of
+	// the complete graph
+	void topologicalSort();
+};
+
+Graph::Graph(int V)
+{
+	this->V = V;
+	adj = new list<int>[V];
+}
+
+void Graph::addEdge(int v, int w)
+{
+	// Add w to v’s list.
+	adj[v].push_back(w);
+}
+
+// A recursive function used by topologicalSort
+void Graph::topologicalSortUtil(int v, bool visited[],
+								stack<int>& Stack)
+{
+	// Mark the current node as visited.
+	visited[v] = true;
+
+	// Recur for all the vertices
+	// adjacent to this vertex
+	list<int>::iterator i;
+	for (i = adj[v].begin(); i != adj[v].end(); ++i)
+		if (!visited[*i])
+			topologicalSortUtil(*i, visited, Stack);
+
+	// Push current vertex to stack
+	// which stores result
+	Stack.push(v);
+}
+
+// The function to do Topological Sort.
+// It uses recursive topologicalSortUtil()
+void Graph::topologicalSort()
+{
+	stack<int> Stack;
+
+	// Mark all the vertices as not visited
+	bool* visited = new bool[V];
+	for (int i = 0; i < V; i++)
+		visited[i] = false;
+
+	// Call the recursive helper function
+	// to store Topological
+	// Sort starting from all
+	// vertices one by one
+	for (int i = 0; i < V; i++)
+		if (visited[i] == false)
+			topologicalSortUtil(i, visited, Stack);
+
+	// Print contents of stack
+	while (Stack.empty() == false) {
+		cout << Stack.top() << " ";
+		Stack.pop();
+	}
+}
+
+// Driver Code
+int main()
+{
+	// Create a graph given in the above diagram
+	Graph g(6);
+	g.addEdge(5, 2);
+	g.addEdge(5, 0);
+	g.addEdge(4, 0);
+	g.addEdge(4, 1);
+	g.addEdge(2, 3);
+	g.addEdge(3, 1);
+
+	cout << "Following is a Topological Sort of the given "
+			"graph \n";
+
+	// Function Call
+	g.topologicalSort();
+
+	return 0;
+}
diff --git a/Total Moves For Bishop.cpp b/Total Moves For Bishop.cpp
new file mode 100644
index 00000000..352a0768
--- /dev/null
+++ b/Total Moves For Bishop.cpp	
@@ -0,0 +1,11 @@
+int Solution::solve(int A, int B) {
+
+    int c = 0;
+
+    c = c + min(8 - A,8 - B);
+    c = c + min(8 - A,  B -1);
+    c += min(A - 1, 8 - B);
+    c += min(A - 1, B - 1);
+
+    return c;
+}
diff --git a/Tower of hanoi b/Tower of hanoi
new file mode 100644
index 00000000..64851814
--- /dev/null
+++ b/Tower of hanoi	
@@ -0,0 +1,29 @@
+// C++ recursive function to
+// solve tower of hanoi puzzle
+#include <bits/stdc++.h>
+using namespace std;
+
+void towerOfHanoi(int n, char from_rod,
+					char to_rod, char aux_rod)
+{
+	if (n == 1)
+	{
+		cout << "Move disk 1 from rod " << from_rod <<
+							" to rod " << to_rod<<endl;
+		return;
+	}
+	towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
+	cout << "Move disk " << n << " from rod " << from_rod <<
+								" to rod " << to_rod << endl;
+	towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
+}
+
+// Driver code
+int main()
+{
+	int n = 4; // Number of disks
+	towerOfHanoi(n, 'A', 'C', 'B'); // A, B and C are names of rods
+	return 0;
+}
+
+// This is code is contributed by rathbhupendra
diff --git a/TowerOfHanoi.cpp b/TowerOfHanoi.cpp
new file mode 100644
index 00000000..1727ef0e
--- /dev/null
+++ b/TowerOfHanoi.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+using namespace std;
+
+int ToH(int n, char s = 'S', char d = 'D', char h = 'H') //Represented as No. of plate, Source's plate, destination's plate, helper's plate
+{
+    static int count = 0;
+    if (n == 1)
+    {
+        cout << "Moving " << n << "th plate from " << s << " to " << d << ".\n";
+        count++;
+        return 0;
+    }
+    ToH(n - 1, s, h, d);
+    cout << "Moving " << n << "th plate from " << s << " to " << d << ".\n";
+    count++;
+    ToH(n - 1, h, d, s);
+    return count;
+}
+
+int main()
+{
+    int num;
+    cout<<"Total number of Plates: ";
+    cin>>num;
+    long long int cnt = ToH(num);
+    cout<<"\nFor "<<num<<" plates ";
+    cout << cnt<<" Steps required!";
+    return 0;
+}
\ No newline at end of file
diff --git a/Transparentlogin.html b/Transparentlogin.html
new file mode 100644
index 00000000..c309e1ad
--- /dev/null
+++ b/Transparentlogin.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html> 
+
+<html lang="en"> 
+
+    <head> 
+
+        <meta charset="UTF-8" /> 
+
+        <meta
+
+            name="viewport"
+
+            content="width=device-width,  
+
+                     initial-scale=1.0" 
+
+        /> 
+
+        <script src="https://kit.fontawesome.com/5845bc1bb6.js"
+
+                crossorigin="anonymous"></script> 
+
+        <link href= 
+
+"https://fonts.googleapis.com/css2?family=Baloo+Bhai+2:wght@600&display=swap" 
+
+              rel="stylesheet" /> 
+
+        <link rel="stylesheet" href="style.css" /> 
+
+        <title>Transparent Login Page using HTML/CSS</title> 
+
+    </head> 
+
+  
+
+    <body> 
+
+        <div class="container"> 
+
+            <div class="row1"> 
+
+                <h1>LogIn</h1> 
+
+                <div class="row"> 
+
+                    <i class="fas fa-envelope-square"></i> 
+
+                    <input type="email" name="Email" 
+
+                           placeholder="Enter your email" /> 
+
+                </div> 
+
+                <div class="row"> 
+
+                    <i class="fas fa-key"></i> 
+
+                    <input type="password" name="pass" 
+
+                           placeholder="Enter your password" /> 
+
+                </div> 
+
+                <button class="btn">Submit</button> 
+
+            </div> 
+
+        </div> 
+
+    </body> 
+
+</html>
diff --git a/Transpose.cpp b/Transpose.cpp
new file mode 100644
index 00000000..88b3e2e0
--- /dev/null
+++ b/Transpose.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+   int a[10][10], transpose[10][10], row, column, i, j;
+
+   cout << "Enter rows and columns of matrix: ";
+   cin >> row >> column;
+
+   cout << "\nEnter elements of matrix: " << endl;
+
+   // Storing matrix elements
+   for (int i = 0; i < row; ++i) {
+      for (int j = 0; j < column; ++j) {
+         cout << "Enter element a" << i + 1 << j + 1 << ": ";
+         cin >> a[i][j];
+      }
+   }
+
+   // Printing the a matrix
+   cout << "\nEntered Matrix: " << endl;
+   for (int i = 0; i < row; ++i) {
+      for (int j = 0; j < column; ++j) {
+         cout << " " << a[i][j];
+         if (j == column - 1)
+            cout << endl << endl;
+      }
+   }
+
+   // Computing transpose of the matrix
+   for (int i = 0; i < row; ++i)
+      for (int j = 0; j < column; ++j) {
+         transpose[j][i] = a[i][j];
+      }
+
+   // Printing the transpose
+   cout << "\nTranspose of Matrix: " << endl;
+   for (int i = 0; i < column; ++i)
+      for (int j = 0; j < row; ++j) {
+         cout << " " << transpose[i][j];
+         if (j == row - 1)
+            cout << endl << endl;
+      }
+
+   return 0;
+}
diff --git a/Tree from Postorder and Inorder b/Tree from Postorder and Inorder
new file mode 100644
index 00000000..c7c2bb54
--- /dev/null
+++ b/Tree from Postorder and Inorder	
@@ -0,0 +1,122 @@
+Given inorder and postorder traversals of a Binary Tree in the arrays in[] and post[] respectively. The task is to construct the binary tree from these traversals.
+
+ 
+
+Example 1:
+
+Input:
+N = 8
+in[] = 4 8 2 5 1 6 3 7
+post[] =8 4 5 2 6 7 3 1
+Output: 1 2 4 8 5 3 6 7
+Explanation: For the given postorder and
+inorder traversal of tree the  resultant
+binary tree will be
+           1
+       /      \
+     2         3
+   /  \      /  \
+  4    5    6    7
+   \
+     8
+
+ 
+
+Example 2:
+
+Input:
+N = 5
+in[] = 9 5 2 3 4
+post[] = 5 9 3 4 2
+Output: 2 9 5 4 3
+Explanation:  
+the  resultant binary tree will be
+           2
+        /     \
+       9       4
+        \     /
+         5   3
+
+ 
+
+Your Task:
+You do not need to read input or print anything. Complete the function buildTree() which takes the inorder, postorder traversals and the number of nodes in the tree as input parameters
+and returns the root node of the newly constructed Binary Tree. The generated output contains the preorder traversal of the constructed tree.
+ 
+
+Expected Time Complexity: O(N2)
+Expected Auxiliary Space: O(N)
+
+ 
+
+Constraints:
+1 <= N <= 103
+1 <= in[i], post[i] <= 10^3
+
+Solution :
+
+/* Tree node structure
+
+struct Node
+{
+    int data;
+    struct Node* left;
+    struct Node* right;
+
+    Node(int x){
+        data = x;
+        left = right = NULL;
+    }
+};*/
+
+//Function to return a tree created from postorder and inoreder traversals.
+
+Node* newNode(int data);
+
+Node* buildUtil(int in[], int post[], int inStrt,
+    int inEnd, int* pIndex, unordered_map<int, int>& mp)
+{
+    // Base case
+    if (inStrt > inEnd)
+        return NULL;
+ 
+    /* Pick current node from Postorder traversal 
+    using postIndex and decrement postIndex */
+    int curr = post[*pIndex];
+    Node* node = newNode(curr);
+    (*pIndex)--;
+ 
+    /* If this node has no children then return */
+    if (inStrt == inEnd)
+        return node;
+ 
+    /* Else find the index of this node in Inorder
+    traversal */
+    int iIndex = mp[curr];
+ 
+    /* Using index in Inorder traversal, construct
+    left and right subtress */
+    node->right = buildUtil(in, post, iIndex + 1,
+                            inEnd, pIndex, mp);
+    node->left = buildUtil(in, post, inStrt,
+                           iIndex - 1, pIndex, mp);
+ 
+    return node;
+}
+
+Node *buildTree(int in[], int post[], int len) {
+    unordered_map<int, int> mp;
+    for (int i = 0; i < len; i++)
+        mp[in[i]] = i;
+ 
+    int index = len - 1; // Index in postorder
+    return buildUtil(in, post, 0, len - 1, &index, mp);
+}
+
+Node* newNode(int data)
+{
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->data = data;
+    node->left = node->right = NULL;
+    return (node);
+}
diff --git a/Treeheight.cpp b/Treeheight.cpp
new file mode 100644
index 00000000..f2433d37
--- /dev/null
+++ b/Treeheight.cpp
@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class node
+{
+	public:
+	int data;
+	node* left;
+	node* right;
+};
+
+int maxDepth(node* node)
+{
+	if (node == NULL)
+		return 0;
+	else
+	{
+		int lDepth = maxDepth(node->left);
+		int rDepth = maxDepth(node->right);
+	
+		if (lDepth > rDepth)
+			return(lDepth + 1);
+		else return(rDepth + 1);
+	}
+}
+
+node* newNode(int data)
+{
+	node* Node = new node();
+	Node->data = data;
+	Node->left = NULL;
+	Node->right = NULL;
+	
+	return(Node);
+}
+	
+int main()
+{
+	node *root = newNode(1);
+
+	root->left = newNode(4);
+	root->right = newNode(8);
+	root->left->left = newNode(14);
+	root->left->right = newNode(15);
+	
+	cout << "Height of tree : " << maxDepth(root);
+	return 0;
+}
+
diff --git a/Triply_Linked_List.cpp b/Triply_Linked_List.cpp
new file mode 100644
index 00000000..3e511346
--- /dev/null
+++ b/Triply_Linked_List.cpp
@@ -0,0 +1,149 @@
+#include<stdio.h>
+#include<conio.h>
+#include<iostream>
+using namespace std;
+int c = 0;
+struct node
+{
+    node *next, *prev, *top;
+    int data;
+}*head = NULL, *tail = NULL, *p = NULL, *r = NULL, *np = NULL, *q = NULL;
+
+void create(int x)
+{
+    np = new node;
+    np->data = x;
+    np->next = NULL;
+    np->prev = NULL;
+    np->top = NULL;
+    if (c == 0)
+    {
+        tail = np;
+        head = np;
+        p = head;
+        p->next = NULL;
+        p->prev = NULL;
+        p->top = NULL;
+        c++;
+    }
+    else
+    {
+        p = head;
+        r = p;
+        if (np->data < p->data)
+        {
+            np->next = p;
+            p->prev = np;
+            np->prev = NULL;
+            head = np;
+            p = head;
+            do
+            {
+                p = p->next;
+            }
+            while (p->next != NULL);
+            tail = p;
+        }
+        else if (np->data > p->data)
+        {
+            while (p != NULL && np->data > p->data)
+            {
+                r = p;
+                p = p->next;
+                if (p == NULL)
+                {
+                    r->next = np;
+                    np->prev = r;
+                    np->next = NULL;
+                    tail = np;
+                    break;
+                }   
+                else if (np->data <= p->data)
+                {
+                    if (np->data < p->data)
+                    { 
+                        r->next = np;
+                        np->prev = r;
+                        np->next = p;
+                        p->prev = np;
+                        if (p->next != NULL)
+                        {
+                            do
+                            {
+                                p = p->next;
+                            }
+                        while (p->next !=NULL);
+                    }
+                    tail = p;
+                    break;
+                    }
+                    else if (p->data == np->data)
+                    {
+                        q = p;
+                        while (q->top != NULL)
+                        {
+                           q = q->top;
+                        }
+                        q->top = np;
+                        np->top = NULL;
+                        break;
+                    }
+                }
+            }
+        }        
+    }
+}
+
+void traverse_tail()
+{
+    node *t = tail;
+    //cout<<"\n\nlinear display of nodes currently present in linked list....\n\n";
+    while (t != NULL)
+    {
+        cout<<t->data<<"\t";
+        q = t;
+        while (q->top != NULL)
+        {
+              q = q->top;
+              cout<<"top->"<<q->data<<"\t";
+        }
+        t = t->prev;
+    }
+    cout<<endl;
+}
+
+void traverse_head()
+{
+    node *t = head;
+    while (t != NULL)
+    {
+        cout<<t->data<<"\t";
+        q = t;
+        while (q->top != NULL)
+        {
+            q = q->top; 
+            cout<<"top->"<<q->data<<"\t";
+        }
+        t = t->next;
+    }
+    cout<<endl;
+}
+
+int main()
+{
+    int i = 0, n, x, ch;
+    cout<<"enter the no of nodes\n";
+    cin>>n;
+    while (i < n)
+    {
+        cout<<"\nenter value of node\n";
+        cin>>x;
+        create(x);
+        i++;
+    }
+    cout<<"\nTraversing Doubly Linked List head first\n";
+    traverse_head();
+    cout<<"\nTraversing Doubly Linked List tail first\n";
+    traverse_tail();
+    getch();
+}
diff --git a/ValidParenthesis.cpp b/ValidParenthesis.cpp
new file mode 100644
index 00000000..d3188622
--- /dev/null
+++ b/ValidParenthesis.cpp
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <cmath>
+#include <climits>
+#include <vector>
+#include <set>
+#include <stack>
+#include <queue>
+#include <algorithm>
+using namespace std;
+#define ll             long long int
+#define ld             long double
+#define mod            1000000007
+#define endl           "\n"
+#define vi             vector<ll>
+#define vs             vector<string>
+#define pii            pair<ll, ll>
+#define ump            unordered_map
+#define mp             map
+#define pq_max         priority_queue<ll>
+#define pq_min         priority_queue<ll,vi,greater<ll>
+#define ff             first
+#define ss             second
+#define mid(l,r)       (l+(r-l)/2)
+#define loop(i,a,b)    for(int i=(a); i <=(b);i++)
+#define looprev(i,a,b) for(int i=(a); i >=(b);i--)
+#define clr(val)       memset(val,0,sizeof(val))
+#define what_is(x)     cerr << #x << " is " << x << endl; 
+#define OJ             \
+    freopen("input.txt", "r", stdin); \
+    freopen("output.txt", "w", stdout);
+#define FIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+ 
+bool Balanced(string exp){          
+
+    stack <char> st;
+    char p;
+
+    for(int i = 0; i < exp.length(); i++){
+
+        if (exp[i] == '(' || exp[i] == '[' || exp[i] == '{'){
+            st.push(exp[i]);
+            continue;
+        }
+        if (st.empty()){
+            return false;
+        }
+
+        switch (exp[i])
+        {
+        case ')':
+            p = st.top();
+            st.pop();
+            if (p == '{' || p == '['){
+                return false;
+            }
+            break;
+        case ']':
+            p = st.top();
+            st.pop();
+            if (p == '{' || p == '('){
+                return false;
+            }
+            break;
+        case '}':
+            p = st.top();
+            st.pop();
+            if (p == '[' || p == '('){
+                return false;
+            }
+            break;
+        }
+    }
+    return (st.empty());
+} 
+
+int main() 
+{
+    string s;       //()[]{}    ()[}
+    cin>>s;
+ 
+    if (Balanced(s)){
+        cout<<"Balanced";
+    }
+    else{
+        cout<<"Not Balanced";
+    }
+ 
+return 0;
+   
+}
diff --git a/Valid_Parenthesis.cpp b/Valid_Parenthesis.cpp
new file mode 100644
index 00000000..75dfa86c
--- /dev/null
+++ b/Valid_Parenthesis.cpp
@@ -0,0 +1,120 @@
+/*Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid or not .
+
+An input string is valid if:
+
+ a) Open brackets must be closed by the same type of brackets.
+ b) Open brackets must be closed in the correct order.
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+#define ll long long int
+#define pb push_back
+#define mp make_pair
+#define pf push_front
+
+int main()
+{
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    //Declaring a string variable named 's':
+    string s;
+    //Declaring  a bool variable to store the value and initializing it as true
+    bool result = true;
+    cout << "Enter a string containing";
+    cout << "("
+         << ")"
+         << "{"
+         << "}"
+         << "["
+         << "]" << endl;
+
+    //Taking the string of brackets as input
+    cin >> s;
+
+    //Declaring a stack of type char, since each of the bracket as individual are treated as characters:
+    stack<char> st;
+
+    //Traversing through the length of the string:
+    for (int i = 0; i < s.length(); i++)
+    {
+        //checking the the character at the ith index is '(' / '{' / '['
+        //in either case we need to push it in the stack
+
+        if (s[i] == '(' || s[i] == '{' || s[i] == '[')
+            st.push(s[i]);
+
+        //checking the condition when the character is neither of the opening bracket
+
+        else
+        {
+
+            if (s[i] == ')')
+            {
+                //checking if the stack is empty or the top of the stack is not the corresponding opening bracket of the closing bracket
+
+                if (st.empty() || st.top() != '(')
+                    //In that case the string is invalid.
+                    result = false;
+                else
+                    //If the top of the stack matches with the corresponding opening bracket, then
+                    //we're supposed to pop it out of the stack since it is a valid pair
+                    st.pop();
+            }
+            else if (s[i] == '}')
+            {
+                //checking if the stack is empty or the top of the stack is not the corresponding opening bracket of the closing bracket
+
+                if (st.empty() || st.top() != '{')
+                    //In that case the string is invalid.
+                    result = false;
+                else
+                    //If the top of the stack matches with the corresponding opening bracket, then
+                    //we're supposed to pop it out of the stack since it is a valid pair
+                    st.pop();
+            }
+            else if (s[i] == ']')
+            {
+                //checking if the stack is empty or the top of the stack is not the corresponding opening bracket of the closing bracket
+
+                if (st.empty() || st.top() != '[')
+                    //In that case the string is invalid.
+                    result = false;
+                else
+                    //If the top of the stack matches with the corresponding opening bracket, then
+                    //we're supposed to pop it out of the stack since it is a valid pair
+                    st.pop();
+            }
+        }
+    }
+
+    //For the condition where the string contains only opening brackets, the value of result would have been true
+    //which would have given us a wrong answer.
+
+    //Checking if the value of result is true and the stack is not empty in that case the string is invalid
+
+    if (result && (!st.empty()))
+        result = false;
+
+    if (result)
+        //if value of result is true, it's a valid string
+        cout << "Valid String" << endl;
+
+    else
+        //else it's an invalid string
+        cout << "Invalid String" << endl;
+}
+
+/*Time complexity of this program would be : O(n), where n is the length of the string
+
+EXPLANATION:
+We traversed through the length of the string only once, at the cost of O(n),
+the cost of pushing element into the stack and popping them is O(1)
+
+Hence, the overall time complexity of this code is O(n)!
+
+
+
+*/
diff --git a/Vector_STL.cpp b/Vector_STL.cpp
new file mode 100644
index 00000000..249a351a
--- /dev/null
+++ b/Vector_STL.cpp
@@ -0,0 +1,222 @@
+//Vector 
+
+begin() – Returns an iterator pointing to the first element in the vector
+end() – Returns an iterator pointing to the theoretical element that follows the last element in the vector
+rbegin() – Returns a reverse iterator pointing to the last element in the vector (reverse beginning). It moves from last to first element
+rend() – Returns a reverse iterator pointing to the theoretical element preceding the first element in the vector (considered as reverse end)
+
+// C++ program to illustrate the iterators in vector
+#include <iostream>
+#include <vector>
+  
+using namespace std;
+  
+int main()
+{
+    vector<int> g1;
+  
+    for (int i = 1; i <= 5; i++)
+        g1.push_back(i);
+  
+    cout << "Output of begin and end: ";
+    for (auto i = g1.begin(); i != g1.end(); ++i)
+        cout << *i << " ";
+  
+    cout << "\nOutput of rbegin and rend: ";
+    for (auto ir = g1.rbegin(); ir != g1.rend(); ++ir)
+        cout << *ir << " ";
+  
+    return 0;
+}
+Output:
+Output of begin and end: 1 2 3 4 5 
+Output of rbegin and rend: 5 4 3 2 1 
+
+size() – Returns the number of elements in the vector.
+max_size() – Returns the maximum number of elements that the vector can hold.
+resize(n) – Resizes the container so that it contains ‘n’ elements.
+empty() – Returns whether the container is empty.
+shrink_to_fit() – Reduces the capacity of the container to fit its size and destroys all elements beyond the capacity.
+reserve() – Requests that the vector capacity be at least enough to contain n elements.
+
+// C++ program to illustrate the capacity function in vector
+#include <iostream>
+#include <vector>
+  
+using namespace std;
+  
+int main()
+{
+    vector<int> g1;
+  
+    for (int i = 1; i <= 5; i++)
+        g1.push_back(i);
+  
+    cout << "Size : " << g1.size();
+    cout << "\nMax_Size : " << g1.max_size();
+  
+    // resizes the vector size to 4
+    g1.resize(4);
+  
+    // prints the vector size after resize()
+    cout << "\nSize : " << g1.size();
+  
+    // checks if the vector is empty or not
+    if (g1.empty() == false)
+        cout << "\nVector is not empty";
+    else
+        cout << "\nVector is empty";
+  
+    // Shrinks the vector
+    g1.shrink_to_fit();
+    cout << "\nVector elements are: ";
+    for (auto it = g1.begin(); it != g1.end(); it++)
+        cout << *it << " ";
+  
+    return 0;
+}
+Output:
+Size : 5
+Max_Size : 4611686018427387903
+Size : 4
+Vector is not empty
+Vector elements are: 1 2 3 4
+
+reference operator [g] – Returns a reference to the element at position ‘g’ in the vector
+at(g) – Returns a reference to the element at position ‘g’ in the vector
+front() – Returns a reference to the first element in the vector
+back() – Returns a reference to the last element in the vector
+
+// C++ program to illustrate the element accesser in vector
+#include <bits/stdc++.h>
+using namespace std;
+  
+int main()
+{
+    vector<int> g1;
+  
+    for (int i = 1; i <= 10; i++)
+        g1.push_back(i * 10);
+  
+    cout << "\nReference operator [g] : g1[2] = " << g1[2];
+  
+    cout << "\nat : g1.at(4) = " << g1.at(4);
+  
+    cout << "\nfront() : g1.front() = " << g1.front();
+  
+    cout << "\nback() : g1.back() = " << g1.back();
+  
+    return 0;
+}
+Output:
+Reference operator [g] : g1[2] = 30
+at : g1.at(4) = 50
+front() : g1.front() = 10
+back() : g1.back() = 100
+
+assign() – It assigns new value to the vector elements by replacing old ones
+push_back() – It push the elements into a vector from the back
+pop_back() – It is used to pop or remove elements from a vector from the back.
+insert() – It inserts new elements before the element at the specified position
+erase() – It is used to remove elements from a container from the specified position or range.
+swap() – It is used to swap the contents of one vector with another vector of same type. Sizes may differ.
+clear() – It is used to remove all the elements of the vector container
+emplace() – It extends the container by inserting new element at position
+emplace_back() – It is used to insert a new element into the vector container, the new element is added to the end of the vector
+.
+
+
+// C++ program to illustrate the Modifiers in vector
+#include <bits/stdc++.h>
+#include <vector>
+using namespace std;
+  
+int main()
+{
+    // Assign vector
+    vector<int> v;
+  
+    // fill the array with 10 five times
+    v.assign(5, 10);
+  
+    cout << "The vector elements are: ";
+    for (int i = 0; i < v.size(); i++)
+        cout << v[i] << " ";
+  
+    // inserts 15 to the last position
+    v.push_back(15);
+    int n = v.size();
+    cout << "\nThe last element is: " << v[n - 1];
+  
+    // removes last element
+    v.pop_back();
+  
+    // prints the vector
+    cout << "\nThe vector elements are: ";
+    for (int i = 0; i < v.size(); i++)
+        cout << v[i] << " ";
+  
+    // inserts 5 at the beginning
+    v.insert(v.begin(), 5);
+  
+    cout << "\nThe first element is: " << v[0];
+  
+    // removes the first element
+    v.erase(v.begin());
+  
+    cout << "\nThe first element is: " << v[0];
+  
+    // inserts at the beginning
+    v.emplace(v.begin(), 5);
+    cout << "\nThe first element is: " << v[0];
+  
+    // Inserts 20 at the end
+    v.emplace_back(20);
+    n = v.size();
+    cout << "\nThe last element is: " << v[n - 1];
+  
+    // erases the vector
+    v.clear();
+    cout << "\nVector size after erase(): " << v.size();
+  
+    // two vector to perform swap
+    vector<int> v1, v2;
+    v1.push_back(1);
+    v1.push_back(2);
+    v2.push_back(3);
+    v2.push_back(4);
+  
+    cout << "\n\nVector 1: ";
+    for (int i = 0; i < v1.size(); i++)
+        cout << v1[i] << " ";
+  
+    cout << "\nVector 2: ";
+    for (int i = 0; i < v2.size(); i++)
+        cout << v2[i] << " ";
+  
+    // Swaps v1 and v2
+    v1.swap(v2);
+  
+    cout << "\nAfter Swap \nVector 1: ";
+    for (int i = 0; i < v1.size(); i++)
+        cout << v1[i] << " ";
+  
+    cout << "\nVector 2: ";
+    for (int i = 0; i < v2.size(); i++)
+        cout << v2[i] << " ";
+}
+Output:
+The vector elements are: 10 10 10 10 10 
+The last element is: 15
+The vector elements are: 10 10 10 10 10 
+The first element is: 5
+The first element is: 10
+The first element is: 5
+The last element is: 20
+Vector size after erase(): 0
+
+Vector 1: 1 2 
+Vector 2: 3 4 
+After Swap 
+Vector 1: 3 4 
+Vector 2: 1 2
diff --git a/YearMonthDay.java b/YearMonthDay.java
new file mode 100644
index 00000000..42c96381
--- /dev/null
+++ b/YearMonthDay.java
@@ -0,0 +1,23 @@
+package clz;
+import java.util.Scanner;
+public class YearMonthDay {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.print("Enter Days : ");
+		int n = sc.nextInt();
+		
+		int year = n/365;
+		System.out.print("Your result is : "+year+" years ");
+		int year_rem = n%365;
+		
+		int month = year_rem/30;
+		System.out.print(month+" months ");
+		int month_rem = year_rem%30;
+		
+		System.out.println(month_rem+" days.");
+		
+		sc.close();
+	}
+
+}
diff --git a/add 2 numbers b/add 2 numbers
new file mode 100644
index 00000000..2b66319d
--- /dev/null
+++ b/add 2 numbers	
@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+  double num1, num2, product;
+  cout << "Enter two numbers: ";
+
+  // stores two floating point numbers in num1 and num2 respectively
+  cin >> num1 >> num2;
+ 
+  // performs multiplication and stores the result in product variable
+  product = num1 * num2;  
+
+  cout << "Product = " << product;    
+    
+  return 0;
+}
diff --git a/all subsequences of string b/all subsequences of string
new file mode 100644
index 00000000..2e92233c
--- /dev/null
+++ b/all subsequences of string	
@@ -0,0 +1,37 @@
+// C++ program for the above approach
+#include <bits/stdc++.h>
+using namespace std;
+
+// Find all subsequences
+void printSubsequence(string input, string output)
+{
+	// Base Case
+	// if the input is empty print the output string
+	if (input.empty()) {
+		cout << output << endl;
+		return;
+	}
+
+	// output is passed with including
+	// the Ist character of
+	// Input string
+	printSubsequence(input.substr(1), output + input[0]);
+
+	// output is passed without
+	// including the Ist character
+	// of Input string
+	printSubsequence(input.substr(1), output);
+}
+
+// Driver code
+int main()
+{
+	// output is set to null before passing in as a
+	// parameter
+	string output = "";
+	string input = "abcd";
+
+	printSubsequence(input, output);
+
+	return 0;
+}
diff --git a/anagram.cpp b/anagram.cpp
new file mode 100644
index 00000000..c87c77b6
--- /dev/null
+++ b/anagram.cpp
@@ -0,0 +1,58 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+bool isAnagram(string str1, string str2)
+{
+
+    int str1_size=str1.size();
+    int str2_size=str2.size();
+    int flag=0;
+    map<char,int>m;
+    
+    for(int i=0;i<str1_size;i++)
+    {
+        m[str1[i]]++;
+    }
+    for(int i=0;i<str2_size;i++)
+    {
+        m[str2[i]]--;
+    }
+    
+    for(auto i:m)
+    {
+        // cout<<i.first;
+        if(i.second!=0 || i.second<0)
+        {
+            // cout<<i.first;
+            flag=1;
+        }
+    }
+    
+    if(flag==1)
+    {
+        return false;
+    }
+    else
+        return true;
+    
+}
+
+
+
+
+int main()
+{
+    
+    string str1;
+    string str2;
+    cin>>str1>>str2;
+    bool result;
+    result=isAnagram(str1,str2);
+    if(result)
+    cout<<"Yes";
+    else
+    cout<<"No";
+    
+    return 0;
+}
diff --git a/anagrams.cpp b/anagrams.cpp
new file mode 100644
index 00000000..348df44d
--- /dev/null
+++ b/anagrams.cpp
@@ -0,0 +1,160 @@
+/*
+// C++ code to print all anagrams together 
+#include <bits/stdc++.h>
+using namespace std;
+
+void solver(vector<string> my_list)
+{
+    
+    // Inner hashmap counts frequency
+    // of characters in a string.
+    // Outer hashmap for if same
+    // frequency characters are present in
+    // in a string then it will add it to
+    // the vector.
+    map<map<char, int>, vector<string> > my_map;
+    
+    // Loop over all words
+    for(string str : my_list)
+    {
+        
+        // Counting the frequency of the
+        // characters present in a string
+        map<char, int> temp_map;
+        vector<string> temp_my_list;
+        for(int i = 0; i < str.length(); ++i) 
+        {
+            ++temp_map[str[i]];
+        }
+        
+        // If the same frequency of chanracters
+        // are alraedy present then add that
+        // string into that arraylist otherwise
+        // created a new arraylist and add that
+        // string
+        auto it = my_map.find(temp_map);
+        if (it != my_map.end())
+        {
+            it->second.push_back(str);
+        }
+        else
+        {
+            temp_my_list.push_back(str);
+            my_map.insert(make_pair(temp_map, temp_my_list));
+        }
+    }
+    
+    // Stores the result in a vector
+    vector<vector<string> > result;
+
+    for(auto it = my_map.begin();it != my_map.end(); ++it)
+    {
+        result.push_back(it->second);
+    }
+
+    for(int i = 0; i < result.size(); ++i) 
+    {
+          cout << "[";
+        for(int j = 0; j < result[i].size(); ++j) 
+        {
+            cout << result[i][j] << ", ";
+        }
+          cout << "]";
+    }
+}
+
+// Driver code
+int main()
+{
+    vector<string> my_list= { "cat", "dog", "ogd", "god", "atc" };
+    solver(my_list);
+    return 0;
+}
+*/
+// C++ program for finding all anagram
+// pairs in the given array
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+using namespace std;
+
+// Utility function for
+// printing anagram list
+void printAnagram(
+	unordered_map<string,
+				vector<string> >& store)
+{
+	unordered_map<string,
+				vector<string> >::iterator it;
+	for (it = store.begin();
+		it != store.end(); it++) {
+		vector<string> temp_vec(it->second);
+		int size = temp_vec.size();
+		if (size >= 1) {
+			for (int i = 0; i < size; i++) {
+				cout << temp_vec[i] << " ";
+			}
+			cout << "\n";
+		}
+	}
+}
+
+// Utility function for storing
+// the vector of strings into HashMap
+void storeInMap(vector<string>& vec)
+{
+	unordered_map<string,
+				vector<string> >
+		store;
+	for (int i = 0; i < vec.size(); i++) {
+
+		string tempString(vec[i]);
+		sort(tempString.begin(),
+			tempString.end());
+
+		// Check for sorted string
+		// if it already exists
+		if (store.find(
+				tempString)
+			== store.end()) {
+			vector<string> temp_vec;
+			temp_vec.push_back(vec[i]);
+			store.insert(make_pair(
+				tempString, temp_vec));
+		}
+
+		else {
+			// Push new string to
+			// already existing key
+			vector<string> temp_vec(
+				store[tempString]);
+			temp_vec.push_back(vec[i]);
+			store[tempString] = temp_vec;
+		}
+	}
+
+	// print utility function for printing
+	// all the anagrams
+	printAnagram(store);
+}
+
+// Driver code
+int main()
+{
+	// initialize vector of strings
+	vector<string> arr;
+	arr.push_back("geeksquiz");
+	arr.push_back("geeksforgeeks");
+	arr.push_back("abcd");
+	arr.push_back("forgeeksgeeks");
+	arr.push_back("zuiqkeegs");
+	arr.push_back("cat");
+	arr.push_back("act");
+	arr.push_back("tca");
+
+	// utility function for storing
+	// strings into hashmap
+	storeInMap(arr);
+	return 0;
+}
diff --git a/avoid-flood-in-the-city.cpp b/avoid-flood-in-the-city.cpp
new file mode 100644
index 00000000..6a1767fe
--- /dev/null
+++ b/avoid-flood-in-the-city.cpp
@@ -0,0 +1,33 @@
+
+// Time:  O(nlogn)
+// Space: O(n)
+
+class Solution {
+public:
+    vector<int> avoidFlood(vector<int>& rains) {
+        unordered_map<int, vector<int>> lookup;
+        for (int i = rains.size() - 1; i >= 0; --i) {
+            lookup[rains[i]].emplace_back(i);
+        }
+        vector<int> result;
+        priority_queue<int, vector<int>, greater<int>> min_heap;
+        for (int i = 0; i < rains.size(); ++i) {
+            if (rains[i]) {
+                if (lookup[rains[i]].size() >= 2) {
+                    lookup[rains[i]].pop_back();
+                    min_heap.emplace(lookup[rains[i]].back());
+                }
+                result.emplace_back(-1);
+            } else if (!min_heap.empty()) {
+                int j = min_heap.top(); min_heap.pop();
+                if (j < i) {
+                    return {};
+                }
+                result.emplace_back(rains[j]);
+            } else {
+                result.emplace_back(1);
+            }
+        }
+        return min_heap.empty() ? result : vector<int>();
+    }
+};
diff --git a/balanced_binary_tree.cpp b/balanced_binary_tree.cpp
new file mode 100644
index 00000000..b798ba91
--- /dev/null
+++ b/balanced_binary_tree.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+bool isBalanced(Node* root) {
+return height(root)!= -1;
+
+}
+int height(Node *root){
+    if(root==NULL){
+        return 0;
+    }
+    int leftHeight = height(root->left);
+        if(leftHeight==-1)
+            return -1;
+    int rightHeight = height(root->right);
+        if(rightHeight ==-1)
+            return -1;
+    if(abs(leftHeight - rightHeight)>1)
+        return -1;
+    return max(leftHeight , rightHeight) + 1;
+}
+
+};
diff --git a/bfs.cpp b/bfs.cpp
new file mode 100644
index 00000000..aed42892
--- /dev/null
+++ b/bfs.cpp
@@ -0,0 +1,95 @@
+// Program to print BFS traversal from a given
+// source vertex. BFS(int s) traverses vertices
+// reachable from s.
+#include<iostream>
+#include <list>
+
+using namespace std;
+
+// This class represents a directed graph using
+// adjacency list representation
+class Graph
+{
+	int V; // No. of vertices
+
+	// Pointer to an array containing adjacency
+	// lists
+	list<int> *adj;
+public:
+	Graph(int V); // Constructor
+
+	// function to add an edge to graph
+	void addEdge(int v, int w);
+
+	// prints BFS traversal from a given source s
+	void BFS(int s);
+};
+
+Graph::Graph(int V)
+{
+	this->V = V;
+	adj = new list<int>[V];
+}
+
+void Graph::addEdge(int v, int w)
+{
+	adj[v].push_back(w); // Add w to v’s list.
+}
+
+void Graph::BFS(int s)
+{
+	// Mark all the vertices as not visited
+	bool *visited = new bool[V];
+	for(int i = 0; i < V; i++)
+		visited[i] = false;
+
+	// Create a queue for BFS
+	list<int> queue;
+
+	// Mark the current node as visited and enqueue it
+	visited[s] = true;
+	queue.push_back(s);
+
+	// 'i' will be used to get all adjacent
+	// vertices of a vertex
+	list<int>::iterator i;
+
+	while(!queue.empty())
+	{
+		// Dequeue a vertex from queue and print it
+		s = queue.front();
+		cout << s << " ";
+		queue.pop_front();
+
+		// Get all adjacent vertices of the dequeued
+		// vertex s. If a adjacent has not been visited,
+		// then mark it visited and enqueue it
+		for (i = adj[s].begin(); i != adj[s].end(); ++i)
+		{
+			if (!visited[*i])
+			{
+				visited[*i] = true;
+				queue.push_back(*i);
+			}
+		}
+	}
+}
+
+// Driver program to test methods of graph class
+int main()
+{
+	// Create a graph given in the above diagram
+	Graph g(4);
+	g.addEdge(0, 1);
+	g.addEdge(0, 2);
+	g.addEdge(1, 2);
+	g.addEdge(2, 0);
+	g.addEdge(2, 3);
+	g.addEdge(3, 3);
+
+	cout << "Following is Breadth First Traversal "
+		<< "(starting from vertex 2) \n";
+	g.BFS(2);
+
+	return 0;
+}
diff --git a/binarySearch.cpp b/binarySearch.cpp
new file mode 100644
index 00000000..b19a2f35
--- /dev/null
+++ b/binarySearch.cpp
@@ -0,0 +1,45 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+int s;
+int binarySearch(int arr[],int i, int j)
+{
+    int a=1,b=0;
+    int mid=(i+j)/2;
+    while(i<j)
+    {
+        if(arr[mid]==s)
+        {
+            return a;
+        }
+        if(s>arr[mid])
+        {
+            return binarySearch(arr,mid+1,j);
+        }
+        if(s<arr[mid])
+        {
+            return binarySearch(arr,i,mid);
+        }
+    }
+    return b;
+}
+int main()
+{
+    int n,result;
+    cout<<"enter size of array: ";
+    cin>>n;
+    int arr[n];
+    cout<<"enter array elements: "<<endl;
+    for(int i=0;i<n;i++)
+    {
+        cin>>arr[i];
+    }
+    sort(arr,arr+n);
+    cout<<"enter element to search: ";
+    cin>>s;
+    result=binarySearch(arr,0,n-1);
+    if(result==1)
+        cout<<"element is present";
+    else
+        cout<<"element is not present";
+}
diff --git a/binary_search_tree.cpp b/binary_search_tree.cpp
new file mode 100644
index 00000000..853e1eea
--- /dev/null
+++ b/binary_search_tree.cpp
@@ -0,0 +1,286 @@
+#include <iostream>
+#include <cstdlib>
+using namespace std;
+
+class BinarySearchTree
+{
+    private:
+        struct tree_node
+        {
+           tree_node* left;
+           tree_node* right;
+           int data;
+        };
+        tree_node* root;
+    public:
+        BinarySearchTree()
+        {
+           root = NULL;
+        }
+        bool isEmpty() const { return root==NULL; }
+        void print_inorder();
+        void inorder(tree_node*);
+        void print_preorder();
+        void preorder(tree_node*);
+        void print_postorder();
+        void postorder(tree_node*);
+        void insert(int);
+        void remove(int);
+};
+
+// Smaller elements go left
+// larger elements go right
+void BinarySearchTree::insert(int d)
+{
+    tree_node* t = new tree_node;
+    tree_node* parent;
+    t->data = d;
+    t->left = NULL;
+    t->right = NULL;
+    parent = NULL;
+  // is this a new tree?
+  if(isEmpty()) root = t;
+  else
+  {
+    //Note: ALL insertions are as leaf nodes
+    tree_node* curr;
+    curr = root;
+    // Find the Node's parent
+    while(curr)
+    {
+        parent = curr;
+        if(t->data > curr->data) curr = curr->right;
+        else curr = curr->left;
+    }
+
+    if(t->data < parent->data)
+       parent->left = t;
+    else
+       parent->right = t;
+  }
+}
+
+void BinarySearchTree::remove(int d)
+{
+    //Locate the element
+    bool found = false;
+    if(isEmpty())
+    {
+        cout<<" This Tree is empty! "<<endl;
+        return;
+    }
+    tree_node* curr;
+    tree_node* parent;
+    curr = root;
+    while(curr != NULL)
+    {
+         if(curr->data == d)
+         {
+            found = true;
+            break;
+         }
+         else
+         {
+             parent = curr;
+             if(d>curr->data) curr = curr->right;
+             else curr = curr->left;
+         }
+    }
+    if(!found)
+		 {
+        cout<<" Data not found! "<<endl;
+        return;
+    }
+
+
+		 // 3 cases :
+    // 1. We're removing a leaf node
+    // 2. We're removing a node with a single child
+    // 3. we're removing a node with 2 children
+
+    // Node with single child
+    if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL
+&& curr->right == NULL))
+    {
+       if(curr->left == NULL && curr->right != NULL)
+       {
+           if(parent->left == curr)
+           {
+             parent->left = curr->right;
+             delete curr;
+           }
+           else
+           {
+             parent->right = curr->right;
+             delete curr;
+           }
+       }
+       else // left child present, no right child
+       {
+          if(parent->left == curr)
+           {
+             parent->left = curr->left;
+             delete curr;
+           }
+           else
+           {
+             parent->right = curr->left;
+             delete curr;
+           }
+       }
+     return;
+    }
+
+		 //We're looking at a leaf node
+		 if( curr->left == NULL && curr->right == NULL)
+    {
+        if(parent->left == curr) parent->left = NULL;
+        else parent->right = NULL;
+		 		 delete curr;
+		 		 return;
+    }
+
+
+    //Node with 2 children
+    // replace node with smallest value in right subtree
+    if (curr->left != NULL && curr->right != NULL)
+    {
+        tree_node* chkr;
+        chkr = curr->right;
+        if((chkr->left == NULL) && (chkr->right == NULL))
+        {
+            curr = chkr;
+            delete chkr;
+            curr->right = NULL;
+        }
+        else // right child has children
+        {
+            //if the node's right child has a left child
+            // Move all the way down left to locate smallest element
+
+            if((curr->right)->left != NULL)
+            {
+                tree_node* lcurr;
+                tree_node* lcurrp;
+                lcurrp = curr->right;
+                lcurr = (curr->right)->left;
+                while(lcurr->left != NULL)
+                {
+                   lcurrp = lcurr;
+                   lcurr = lcurr->left;
+                }
+		 		 		 		 curr->data = lcurr->data;
+                delete lcurr;
+                lcurrp->left = NULL;
+           }
+           else
+           {
+               tree_node* tmp;
+               tmp = curr->right;
+               curr->data = tmp->data;
+		 		 		    curr->right = tmp->right;
+               delete tmp;
+           }
+
+        }
+		 return;
+    }
+
+}
+
+void BinarySearchTree::print_inorder()
+{
+  inorder(root);
+}
+
+void BinarySearchTree::inorder(tree_node* p)
+{
+    if(p != NULL)
+    {
+        if(p->left) inorder(p->left);
+        cout<<" "<<p->data<<" ";
+        if(p->right) inorder(p->right);
+    }
+    else return;
+}
+
+void BinarySearchTree::print_preorder()
+{
+  preorder(root);
+}
+
+void BinarySearchTree::preorder(tree_node* p)
+{
+    if(p != NULL)
+    {
+        cout<<" "<<p->data<<" ";
+        if(p->left) preorder(p->left);
+        if(p->right) preorder(p->right);
+    }
+    else return;
+}
+
+void BinarySearchTree::print_postorder()
+{
+  postorder(root);
+}
+
+void BinarySearchTree::postorder(tree_node* p)
+{
+    if(p != NULL)
+    {
+        if(p->left) postorder(p->left);
+        if(p->right) postorder(p->right);
+        cout<<" "<<p->data<<" ";
+    }
+    else return;
+}
+
+int main()
+{
+    BinarySearchTree b;
+    int ch,tmp,tmp1;
+    while(1)
+    {
+       cout<<endl<<endl;
+       cout<<" Binary Search Tree Operations "<<endl;
+       cout<<" ----------------------------- "<<endl;
+       cout<<" 1. Insertion/Creation "<<endl;
+       cout<<" 2. In-Order Traversal "<<endl;
+       cout<<" 3. Pre-Order Traversal "<<endl;
+       cout<<" 4. Post-Order Traversal "<<endl;
+       cout<<" 5. Removal "<<endl;
+       cout<<" 6. Exit "<<endl;
+       cout<<" Enter your choice : ";
+       cin>>ch;
+       switch(ch)
+       {
+           case 1 : cout<<" Enter Number to be inserted : ";
+                    cin>>tmp;
+                    b.insert(tmp);
+                    break;
+           case 2 : cout<<endl;
+                    cout<<" In-Order Traversal "<<endl;
+                    cout<<" -------------------"<<endl;
+                    b.print_inorder();
+                    break;
+           case 3 : cout<<endl;
+                    cout<<" Pre-Order Traversal "<<endl;
+                    cout<<" -------------------"<<endl;
+                    b.print_preorder();
+                    break;
+           case 4 : cout<<endl;
+                    cout<<" Post-Order Traversal "<<endl;
+                    cout<<" --------------------"<<endl;
+                    b.print_postorder();
+                    break;
+           case 5 : cout<<" Enter data to be deleted : ";
+                    cin>>tmp1;
+                    b.remove(tmp1);
+                    break;
+           case 6 : system("pause");
+                    return 0;
+                    break;
+       }
+    }
+}
diff --git a/binarytodecimal.cpp b/binarytodecimal.cpp
new file mode 100644
index 00000000..8ceff0aa
--- /dev/null
+++ b/binarytodecimal.cpp
@@ -0,0 +1,33 @@
+// C++ program to convert binary to decimal
+#include <iostream>
+using namespace std;
+
+// Function to convert binary to decimal
+int binaryToDecimal(int n)
+{
+	int num = n;
+	int dec_value = 0;
+
+	// Initializing base value to 1, i.e 2^0
+	int base = 1;
+
+	int temp = num;
+	while (temp) {
+		int last_digit = temp % 10;
+		temp = temp / 10;
+
+		dec_value += last_digit * base;
+
+		base = base * 2;
+	}
+
+	return dec_value;
+}
+
+// Driver program to test above function
+int main()
+{
+	int num = 10101001;
+
+	cout << binaryToDecimal(num) << endl;
+}
diff --git a/bookallocationproblem.cpp b/bookallocationproblem.cpp
new file mode 100644
index 00000000..3e85dcc4
--- /dev/null
+++ b/bookallocationproblem.cpp
@@ -0,0 +1,74 @@
+//allocating minimum number of pages to read among given number of readers based on binary search concept
+#include<bits/stdc++.h>
+using namespace std;
+int maxinarray(int *arr,int n)
+{
+    int max=arr[0];
+    for(int i=1;i<n;i++)
+    {
+        if(arr[i]>=max)
+        max=arr[i];
+    }
+    return max;
+}
+int sumofallarrayelements(int *arr,int n)
+{
+    int sum=0;
+    for(int i=0;i<n;i++)
+    {
+        sum=sum+arr[i];
+    }
+    return sum;
+}
+bool isvalid(int *arr,int n,int m,int mid)
+{
+    int student=1;
+    int sum=0;
+    for(int i=0;i<n;i++)
+    {
+        sum=sum+arr[i];
+        if(sum>mid)
+        {
+            student++;
+            sum=arr[i];
+        }
+        if(student>m)
+        return false;
+    }
+    return true;
+}
+int main()
+{
+    int n,m;
+    cout<<"ENTER NUMBER OF BOOKS: ";
+    cin>>n;
+    int arr[n];
+    for(int i=0;i<n;i++)
+    {
+        cout<<"ENTER NUMBER OF PAGES IN BOOK "<<i+1<<" : ";
+        cin>>arr[i];
+    }
+    cout<<"ENTER NUMBER OF STUDENTS: ";
+    cin>>m;
+    int maxpos=(n-m)+1,ans=-1;
+    if(maxpos<=0)
+    cout<<"BOOKS CANNOT BE ALLOCATED";
+    else
+    {
+        int start=maxinarray(arr,n);
+        int end=sumofallarrayelements(arr,n);
+        while(start<=end)
+        {
+            int mid=start+((end-start)/2);
+            if(isvalid(arr,n,m,mid))
+            {
+                ans=mid;
+                end=mid-1;
+            }
+            else
+            start=mid+1;
+        }
+        cout<<"THE MINIMUM NUMBER OF PAGES WILL BE: "<<ans;     
+    }
+    //cout<<"THE MINIMUM NUMBER OF PAGES WILL BE: "<<ans;
+}
diff --git a/boruvka's-algorithm.cpp b/boruvka's-algorithm.cpp
new file mode 100644
index 00000000..0266e16a
--- /dev/null
+++ b/boruvka's-algorithm.cpp
@@ -0,0 +1,168 @@
+#include <stdio.h>
+
+struct Edge
+{
+	int src, dest, weight;
+};
+
+struct Graph
+{
+	int V, E;
+	Edge* edge;
+};
+
+struct subset
+{
+	int parent;
+	int rank;
+};
+
+int find(struct subset subsets[], int i);
+void Union(struct subset subsets[], int x, int y);
+
+
+void boruvkaMST(struct Graph* graph)
+{
+	int V = graph->V, E = graph->E;
+	Edge *edge = graph->edge;
+
+	struct subset *subsets = new subset[V];
+
+	int *cheapest = new int[V];
+
+	for (int v = 0; v < V; ++v)
+	{
+		subsets[v].parent = v;
+		subsets[v].rank = 0;
+		cheapest[v] = -1;
+	}
+
+	int numTrees = V;
+	int MSTweight = 0;
+
+	while (numTrees > 1)
+	{
+		for (int v = 0; v < V; ++v)
+		{
+			cheapest[v] = -1;
+		}
+		for (int i=0; i<E; i++)
+		{
+			int set1 = find(subsets, edge[i].src);
+			int set2 = find(subsets, edge[i].dest);
+
+			
+			if (set1 == set2)
+				continue;			
+			else
+			{
+			if (cheapest[set1] == -1 ||
+				edge[cheapest[set1]].weight > edge[i].weight)
+				cheapest[set1] = i;
+
+			if (cheapest[set2] == -1 ||
+				edge[cheapest[set2]].weight > edge[i].weight)
+				cheapest[set2] = i;
+			}
+		}
+
+		
+		for (int i=0; i<V; i++)
+		{
+			if (cheapest[i] != -1)
+			{
+				int set1 = find(subsets, edge[cheapest[i]].src);
+				int set2 = find(subsets, edge[cheapest[i]].dest);
+
+				if (set1 == set2)
+					continue;
+				MSTweight += edge[cheapest[i]].weight;
+				printf("Edge %d-%d included in MST\n",
+					edge[cheapest[i]].src, edge[cheapest[i]].dest);
+				Union(subsets, set1, set2);
+				numTrees--;
+			}
+		}
+	}
+
+	printf("Weight of MST is %d\n", MSTweight);
+	return;
+}
+
+struct Graph* createGraph(int V, int E)
+{
+	Graph* graph = new Graph;
+	graph->V = V;
+	graph->E = E;
+	graph->edge = new Edge[E];
+	return graph;
+}
+
+int find(struct subset subsets[], int i)
+{
+	if (subsets[i].parent != i)
+	subsets[i].parent =
+			find(subsets, subsets[i].parent);
+
+	return subsets[i].parent;
+}
+
+void Union(struct subset subsets[], int x, int y)
+{
+	int xroot = find(subsets, x);
+	int yroot = find(subsets, y);
+
+	if (subsets[xroot].rank < subsets[yroot].rank)
+		subsets[xroot].parent = yroot;
+	else if (subsets[xroot].rank > subsets[yroot].rank)
+		subsets[yroot].parent = xroot;
+	else
+	{
+		subsets[yroot].parent = xroot;
+		subsets[xroot].rank++;
+	}
+}
+
+int main()
+{
+	int V = 4; // Number of vertices in graph
+	int E = 5; // Number of edges in graph
+	struct Graph* graph = createGraph(V, E);
+
+
+	// add edge 0-1
+	graph->edge[0].src = 0;
+	graph->edge[0].dest = 1;
+	graph->edge[0].weight = 10;
+
+	// add edge 0-2
+	graph->edge[1].src = 0;
+	graph->edge[1].dest = 2;
+	graph->edge[1].weight = 6;
+
+	// add edge 0-3
+	graph->edge[2].src = 0;
+	graph->edge[2].dest = 3;
+	graph->edge[2].weight = 5;
+
+	// add edge 1-3
+	graph->edge[3].src = 1;
+	graph->edge[3].dest = 3;
+	graph->edge[3].weight = 15;
+
+	// add edge 2-3
+	graph->edge[4].src = 2;
+	graph->edge[4].dest = 3;
+	graph->edge[4].weight = 4;
+
+	boruvkaMST(graph);
+
+	return 0;
+}
+
+
+/*Output:
+Edge 0-3 included in MST
+Edge 0-1 included in MST
+Edge 2-3 included in MST
+Weight of MST is 19*/
\ No newline at end of file
diff --git a/bubbleSort b/bubbleSort
new file mode 100644
index 00000000..c6320f7b
--- /dev/null
+++ b/bubbleSort
@@ -0,0 +1,31 @@
+import java.util.Scanner;
+
+public class BubbleSort_006 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // int n = a.length;
+        System.out.println("Enter the No. of elements you want to sort : ");
+        int m = sc.nextInt();
+        int a[] = new int[m];
+        System.out.println("Enter the elements :");
+        for (int i = 0; i < m; i++) {
+            a[i] = sc.nextInt();
+        }
+
+        for (int i = 0; i < (m - 1); i++) {
+            for (int j = 0; j < (m - 1); j++) {
+                if (a[j + 1] < a[j]) {
+                    int temp = a[j + 1];
+                    a[j + 1] = a[j];
+                    a[j] = temp;
+                }
+            }
+        }
+
+        for (int item : a) {
+            System.out.print(item + " ");
+        }
+        sc.close();
+    }
+}
diff --git a/bubble_sort.cpp b/bubble_sort.cpp
new file mode 100644
index 00000000..c0345f16
--- /dev/null
+++ b/bubble_sort.cpp
@@ -0,0 +1,44 @@
+// C++ program for implementation of Bubble sort
+#include <bits/stdc++.h>
+using namespace std;
+
+void swap(int *xp, int *yp)
+{
+	int temp = *xp;
+	*xp = *yp;
+	*yp = temp;
+}
+
+// A function to implement bubble sort
+void bubbleSort(int arr[], int n)
+{
+	int i, j;
+	for (i = 0; i < n-1; i++)	
+	
+	// Last i elements are already in place
+	for (j = 0; j < n-i-1; j++)
+		if (arr[j] > arr[j+1])
+			swap(&arr[j], &arr[j+1]);
+}
+
+/* Function to print an array */
+void printArray(int arr[], int size)
+{
+	int i;
+	for (i = 0; i < size; i++)
+		cout << arr[i] << " ";
+	cout << endl;
+}
+
+// Driver code
+int main()
+{
+	int arr[] = {64, 34, 25, 12, 22, 11, 90};
+	int n = sizeof(arr)/sizeof(arr[0]);
+	bubbleSort(arr, n);
+	cout<<"Sorted array: \n";
+	printArray(arr, n);
+	return 0;
+}
+
+// This code is contributed by midhun
diff --git a/bubblesort.cpp b/bubblesort.cpp
new file mode 100644
index 00000000..3a957228
--- /dev/null
+++ b/bubblesort.cpp
@@ -0,0 +1,24 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+    cout<<"Enter 10 numbers"<<endl;
+    int arr[10];
+    for(int i=0; i<10; i++){
+        cin>>arr[i];
+    }
+    for(int i=1; i<10; i++){
+        for(int j=0; j<10-i; j++){
+            if(arr[j]>arr[j+1]){
+                int temp= arr[j+1];
+                arr[j+1]= arr[j];
+                arr[j]= temp;
+            }
+        }
+    }
+    cout<<"array after sorting"<<endl;
+     for(int i=0; i<10; i++){
+        cout<<arr[i]<<" ";
+    }
+}
\ No newline at end of file
diff --git a/calculate_diff.cpp b/calculate_diff.cpp
new file mode 100644
index 00000000..c34a7d9b
--- /dev/null
+++ b/calculate_diff.cpp
@@ -0,0 +1,51 @@
+// Computes time difference of two time period
+// Time periods are entered by the user
+
+#include <iostream>
+using namespace std;
+
+struct TIME
+{
+  int seconds;
+  int minutes;
+  int hours;
+};
+
+void computeTimeDifference(struct TIME, struct TIME, struct TIME *);
+
+int main()
+{
+    struct TIME t1, t2, difference;
+
+    cout << "Enter start time." << endl;
+    cout << "Enter hours, minutes and seconds respectively: ";
+    cin >> t1.hours >> t1.minutes >> t1.seconds;
+
+    cout << "Enter stop time." << endl;
+    cout << "Enter hours, minutes and seconds respectively: ";
+    cin >> t2.hours >> t2.minutes >> t2.seconds;
+
+    computeTimeDifference(t1, t2, &difference);
+
+    cout << endl << "TIME DIFFERENCE: " << t1.hours << ":" << t1.minutes << ":" << t1.seconds;
+    cout << " - " << t2.hours << ":" << t2.minutes << ":" << t2.seconds;
+    cout << " = " << difference.hours << ":" << difference.minutes << ":" << difference.seconds;
+    return 0;
+}
+void computeTimeDifference(struct TIME t1, struct TIME t2, struct TIME *difference){
+    
+    if(t2.seconds > t1.seconds)
+    {
+        --t1.minutes;
+        t1.seconds += 60;
+    }
+
+    difference->seconds = t1.seconds - t2.seconds;
+    if(t2.minutes > t1.minutes)
+    {
+        --t1.hours;
+        t1.minutes += 60;
+    }
+    difference->minutes = t1.minutes-t2.minutes;
+    difference->hours = t1.hours-t2.hours;
+}
diff --git a/camelMatch.cpp b/camelMatch.cpp
new file mode 100644
index 00000000..0a68e038
--- /dev/null
+++ b/camelMatch.cpp
@@ -0,0 +1,130 @@
+/*
+A query word matches a given pattern if we can insert lowercase letters to the pattern word so that it equals the query. (We may insert each character at any position, and may insert 0 characters.)
+
+Given a list of queries, and a pattern, return an answer list of booleans, where answer[i] is true if and only if queries[i] matches the pattern.
+
+ 
+
+Example 1:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FB"
+Output: [true,false,true,true,false]
+Explanation: 
+"FooBar" can be generated like this "F" + "oo" + "B" + "ar".
+"FootBall" can be generated like this "F" + "oot" + "B" + "all".
+"FrameBuffer" can be generated like this "F" + "rame" + "B" + "uffer".
+Example 2:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBa"
+Output: [true,false,true,false,false]
+Explanation: 
+"FooBar" can be generated like this "Fo" + "o" + "Ba" + "r".
+"FootBall" can be generated like this "Fo" + "ot" + "Ba" + "ll".
+Example 3:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBaT"
+Output: [false,true,false,false,false]
+Explanation: 
+"FooBarTest" can be generated like this "Fo" + "o" + "Ba" + "r" + "T" + "est".
+ 
+
+Note:
+
+1 <= queries.length <= 100
+1 <= queries[i].length <= 100
+1 <= pattern.length <= 100
+All strings consists only of lower and upper case English letters.
+*/
+
+class Solution {
+public:
+    vector<bool> camelMatch(vector<string>& q, string p) {
+        
+        vector<bool> res;
+        vector<string> subs;
+        int p_size=p.length();
+        string str="";
+        int flag=0,i=0,countp=0;
+        
+        while(1){
+            if(isupper(p[i])){
+                countp++;
+                if(i==0) {//subs.push_back(p[0]);
+                    i++;
+                    continue;
+                }
+                str+=p[i-1];
+                subs.push_back(str);
+                str="";
+                i++;
+                if(i==p_size){
+                    str+=p[i-1];
+                    subs.push_back(str);
+                    break;
+                }
+            }
+            else{
+                str+=p[i-1];
+                i++;
+                if(i==p_size){
+                    str+=p[i-1];
+                    subs.push_back(str);
+                    break;
+                }    
+            }
+        }
+        
+        //for(int i=0;i<p_size;i++)
+        
+        for(int i=0;i<q.size();i++){
+            size_t found=-1;
+            flag=0;
+            for(int j=0;j<subs.size();j++){
+                while(true){
+                    found = q[i].find(subs[j],found+1);
+                    if (found != string::npos)
+                        flag++;
+                    else { found=-1; break;}
+                }    
+            }
+            if(flag == subs.size()){ 
+                int countq=0;
+                for(int k=0;k<q[i].size();k++){
+                    if(isupper(q[i][k])) countq++;
+                }
+                if(countp==countq) res.push_back(true);
+                else res.push_back(false);
+            }    
+            else res.push_back(false);
+        }
+        return res;
+    }
+};
+
+_____________________________________
+
+class Solution {
+    inline bool check(const string& q, const string& p) const
+    {
+        int j = 0;
+        for(auto c: q) {
+            if(c == p[j])
+                ++j;
+            else if(isupper(c))
+                return false;
+        }
+
+        return j == p.size();
+    }
+    
+public:
+    vector<bool> camelMatch(vector<string>& queries, string pattern) {
+        vector<bool> ret;
+        
+        ret.reserve(queries.size());
+        for(const auto& q: queries)
+            ret.push_back(check(q, pattern));
+        
+        return ret;
+    }
+};
\ No newline at end of file
diff --git a/check HCF b/check HCF
new file mode 100644
index 00000000..2b05ce1c
--- /dev/null
+++ b/check HCF	
@@ -0,0 +1,24 @@
+#include <iostream>
+using namespace std;
+
+int hcf(int n1, int n2);
+
+int main()
+{
+   int n1, n2;
+
+   cout << "Enter two positive integers: ";
+   cin >> n1 >> n2;
+
+   cout << "H.C.F of " << n1 << " & " <<  n2 << " is: " << hcf(n1, n2);
+
+   return 0;
+}
+
+int hcf(int n1, int n2)
+{
+    if (n2 != 0)
+       return hcf(n2, n1 % n2);
+    else 
+       return n1;
+}
diff --git a/checkArmstrongNumber.java b/checkArmstrongNumber.java
new file mode 100644
index 00000000..89997510
--- /dev/null
+++ b/checkArmstrongNumber.java
@@ -0,0 +1,28 @@
+//PROGRAM TO CHECK WHETHER THE NUMBER IS ARMSTRONG OR NOT
+
+import java.util.Scanner;
+
+public class ArmstrongNumber 
+{
+
+    public static void main(String[] args) {
+
+        int num, number, temp, total = 0;
+        System.out.println("Enter the number:");
+        Scanner inp = new Scanner(System.in);
+        num = scanner.nextInt();
+        inp.close();
+        number = num;
+
+        for( ;number!=0;number /= 10)
+        {
+            temp = number % 10;
+            total = total + temp*temp*temp;
+        }
+
+        if(total == num)
+            System.out.println(num + " is ARMSTRONG NUMBER");
+        else
+            System.out.println(num + " is an ARMSTRONG NUMBER");
+    }
+}
diff --git a/checkPalindrome.java b/checkPalindrome.java
new file mode 100644
index 00000000..0d8e0e2e
--- /dev/null
+++ b/checkPalindrome.java
@@ -0,0 +1,23 @@
+class Solution {
+    int isPlaindrome(String S) {
+        // code here
+        char c[]=S.toCharArray();
+        int flag=0;
+        int n=S.length();
+        for(int i=0;i<(n/2)+1;i++){
+            if(c[i]==c[n-1-i]){
+                flag=1;
+            }
+            else{
+                flag=0;
+                break;
+            }
+        }
+        if(flag==1){
+            return(1);
+        }
+        else{
+            return(0);
+        }
+    }
+};
diff --git a/checksum.cpp b/checksum.cpp
new file mode 100644
index 00000000..89b6aa3c
--- /dev/null
+++ b/checksum.cpp
@@ -0,0 +1,254 @@
+#include<iostream>
+#include<fstream>
+using namespace std;
+class A
+{
+    public:
+     int a[4][8];
+int cs[8]={0,0,0,0,0,0,0,0};
+int carry=0;
+int carry1=0;
+
+
+    void input()
+    {
+        cout<<"enter the bit stream "<<endl;
+        for(int i=0;i<4;i++)
+    {
+        for(int j=0;j<8;j++)
+        {
+            cin>>a[i][j];
+        }
+    }
+for(int i=0;i<4;i++)
+{
+    for(int j=7;j>=0;j--)
+    {
+        if(cs[j]==1 && a[i][j]==1&&carry==0)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==1 && carry==1)
+        {
+            cs[j]=1;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==0 && carry==1)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==0 && a[i][j]==1 && carry==1)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==0 && carry==0)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==1 && carry==0)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==0 && carry==1)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==0 && carry==0)
+        {
+            cs[j]=0;
+            carry=0;
+        }
+    }
+    if(carry==1)
+    {
+        carry1=carry;
+        for(int j=7;j>=0;j--)
+        {
+            if(cs[j]==1 && carry1==1)
+            {
+                cs[j]=0;
+                carry1=1;
+            }
+            else if(cs[j]==0 && carry1==1)
+            {
+                cs[j]=1;
+                carry1=0;
+            }
+            else if(cs[j]==1 && carry1==0)
+            {
+                cs[j]=1;
+                carry1=0;
+            }
+            else if(cs[j]==0 && carry1==0)
+            {
+                cs[j]=0;
+                carry1=0;
+            }
+            carry=0;
+        }
+    }
+}
+cout<<"the final result"<<endl;
+for(int i=0;i<8;i++)
+{
+    cout<<cs[i]<"*\t";
+}
+for(int i=0;i<8;i++)
+{
+    if(cs[i]==0)
+    {
+        cs[i]=1;
+    }
+    else
+    {
+        cs[i]=0;
+    }
+}
+cout<<endl<<"compliment"<<endl;
+for(int i=0;i<8;i++)
+{
+    cout<<cs[i]<"*\t";
+}
+    }
+
+};
+void cmd()
+{
+     A a;
+    a.input();
+}
+int main()
+{
+    int a;
+    cout<<"enter 1 if you want to open cmd and enter 2 if you want to open in file ";
+    cin>>a;
+    switch (a)
+    {
+        case 1:
+    {
+        cmd();
+        break;
+    }
+case 2:
+    {
+        ofstream files;
+    files.open("checksumfile.txt");
+    int a[4][8];
+int cs[]={0,0,0,0,0,0,0,0};
+int carry=0;
+int carry1=0;
+        cout<<"enter the bit stream "<<endl;
+        for(int i=0;i<4;i++)
+    {
+        for(int j=0;j<8;j++)
+        {
+            cin>>a[i][j];
+        }
+    }
+for(int i=0;i<4;i++)
+{
+    for(int j=7;j>=0;j--)
+    {
+        if(cs[j]==1 && a[i][j]==1&&carry==0)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==1 && carry==1)
+        {
+            cs[j]=1;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==0 && carry==1)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==0 && a[i][j]==1 && carry==1)
+        {
+            cs[j]=0;
+            carry=1;
+        }
+        else if(cs[j]==1 && a[i][j]==0 && carry==0)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==1 && carry==0)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==0 && carry==1)
+        {
+            cs[j]=1;
+            carry=0;
+        }
+        else if(cs[j]==0 && a[i][j]==0 && carry==0)
+        {
+            cs[j]=0;
+            carry=0;
+        }
+    }
+    if(carry==1)
+    {
+        carry1=carry;
+        for(int j=7;j>=0;j--)
+        {
+            if(cs[j]==1 && carry1==1)
+            {
+                cs[j]=0;
+                carry1=1;
+            }
+            else if(cs[j]==0 && carry1==1)
+            {
+                cs[j]=1;
+                carry1=0;
+            }
+            else if(cs[j]==1 && carry1==0)
+            {
+                cs[j]=1;
+                carry1=0;
+            }
+            else if(cs[j]==0 && carry1==0)
+            {
+                cs[j]=0;
+                carry1=0;
+            }
+            carry=0;
+        }
+    }
+}
+files<<"the final result"<<endl;
+for(int i=0;i<8;i++)
+{
+    files<<cs[i]<"*\t";
+}
+for(int i=0;i<8;i++)
+{
+    if(cs[i]==0)
+    {
+        cs[i]=1;
+    }
+    else
+    {
+        cs[i]=0;
+    }
+}
+files<<endl<<"compliment"<<endl;
+for(int i=0;i<8;i++)
+{
+    files<<cs[i]<"*\t";
+}
+        files.close();
+   std::cin.get();
+        break;
+    }
+    }
+}
diff --git a/chocolate_problem.py b/chocolate_problem.py
new file mode 100644
index 00000000..7c94c7ed
--- /dev/null
+++ b/chocolate_problem.py
@@ -0,0 +1,107 @@
+# Author : DEVESH VISHNOI 
+# https://github.com/Devesh-vi
+
+
+import matplotlib.pyplot as plt
+number=int(input("Input the number: "))
+#Definif a function for finding out te sequence of the next 15 moves given the first 3 moves.
+#L- Moving one place left
+#R- Moving one place right
+#T- Moving one place upwards
+#D- Moving one place downwards
+def seq(a):
+    l="LRTD"
+    sequence=""
+    sequence+=a
+    k=a
+    k=(k[1]+k[1]+k[0])
+    sequence+=k
+    for i in l:
+        if i not in a:
+            z=i
+    k=z+a[0]+a[1]
+    sequence+=k
+    k=k[1]+k[0]+k[0]
+    sequence+=k
+    k=a[2]+z+a[0]
+    sequence+=k
+    return sequence
+#It is found that the graph follows a particular pattern. The grapn of n resembled the graph of n-1. A function to create that pattern is defined.
+def seqtwo(n):
+    dd=""
+    if n==1:
+        return "DRT"
+    if n==2:
+        return seq("RDL")
+    a = seqtwo(n-1)
+    #d and o are the 2 patterns.
+    d=""
+    o=""
+    for i in a:
+        if i == "R":
+            d+="D"
+        if i == "T":
+            d+="L"
+        if i == "L":
+            d+="T"
+        if i == "D":
+            d+="R"
+    for i in a:
+        if i == "R":
+            o+="T"
+        if i == "D":
+            o+="L"
+        if i == "L":
+            o+="D"
+        if i =="T":
+            o+="R"
+    dd=dd+d+"D"+a+"R"+a+"T"+o
+    return dd
+
+#Functions to change coordinates when moved left,right, upwards and downwards
+def right(x,y):
+    return (x,y+1)
+def left(x,y):
+    return (x,y-1)
+def top(x,y):
+    return (x-1,y)
+def down(x,y):
+    return (x+1,y)
+
+#The answer list is created by assighning values coordinates to the output that we get from the function seqtwo
+(a,b)=(1,1)
+anslist=[(1,1)]
+
+#Defining x and y for ploting 
+x=[1]
+y=[-1]
+number= seqtwo(number)
+for i in number:
+    if i=="R":
+        (a,b)=right(a,b)
+        anslist.append(tuple((a,b)))
+        y.append(-a)
+        x.append(b)
+    if i=="L":
+        (a,b)=left(a,b)
+        anslist.append(tuple((a,b)))
+        y.append(-a)
+        x.append(b)
+    if i=="T":
+        (a,b)=top(a,b)
+        anslist.append(tuple((a,b)))
+        y.append(-a)
+        x.append(b)
+    if i=="D":
+        (a,b)=down(a,b)
+        anslist.append(tuple((a,b)))
+        y.append(-a)
+        x.append(b)
+print(anslist)
+        
+#Ploting the graph
+plt.plot(x, y,marker="o",color="red")
+plt.xlabel('x - axis')
+plt.ylabel('y - axis')
+plt.title('Graph')
+plt.show()
diff --git a/codesforces1009B.cpp b/codesforces1009B.cpp
new file mode 100644
index 00000000..981d2b38
--- /dev/null
+++ b/codesforces1009B.cpp
@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+  string s;
+  cin >> s;
+  bool found = true;
+  int two = -1;
+  for (int i = 0; i < s.size(); i++) {
+    if (s[i] == '2') {
+      two = i;
+      break;
+    }
+  }
+  string ans = "";
+  if (two != -1) {
+    int zeros = 0, onesbefore = 0;
+    for (int i = 0; i < two; i++) {
+      if (s[i] == '0') {
+        zeros++;
+      } else {
+        onesbefore++;
+      }
+    }
+    while (zeros--) {
+      ans += string(1, '0');
+    }
+    while (onesbefore--) {
+      ans += string(1, '1');
+    }
+    int onesafter = 0;
+    for (int i = 0; i < s.size(); i++) {
+      if (i > two and s[i] == '1') {
+        onesafter++;
+      }
+    }
+    while (onesafter--) {
+      ans += string(1, '1');
+    }
+    ans += string(1, '2');
+    for (int i = two + 1; i < s.size(); i++) {
+      if (s[i] != '1') {
+        ans += string(1, s[i]);
+      }
+    }
+  } else {
+    ans = "";
+    int zeros = 0, ones = 0;
+    for (int i = 0; i < s.size(); i++) {
+      if (s[i] == '0') {
+        zeros++;
+      } else {
+        ones++;
+      }
+    }
+    while (zeros--) {
+      ans += string(1, '0');
+    }
+    while (ones--) {
+      ans += string(1, '1');
+    }
+  }
+  cout << ans << endl;
+  return 0;
+}
\ No newline at end of file
diff --git a/construct-quad-tree.cpp b/construct-quad-tree.cpp
new file mode 100644
index 00000000..c080431e
--- /dev/null
+++ b/construct-quad-tree.cpp
@@ -0,0 +1,54 @@
+// Time:  O(n)
+// Space: O(h)
+
+/*
+// Definition for a QuadTree node.
+class Node {
+public:
+    bool val;
+    bool isLeaf;
+    Node* topLeft;
+    Node* topRight;
+    Node* bottomLeft;
+    Node* bottomRight;
+    Node() {}
+    Node(bool _val, bool _isLeaf, Node* _topLeft, Node* _topRight, Node* _bottomLeft, Node* _bottomRight) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = _topLeft;
+        topRight = _topRight;
+        bottomLeft = _bottomLeft;
+        bottomRight = _bottomRight;
+    }
+};
+*/
+class Solution {
+public:
+    Node* construct(vector<vector<int>>& grid) {
+        if (grid.empty()) {
+            return nullptr;
+        }
+        return dfs(grid, 0, 0, grid.size());
+    }
+
+private:
+    Node* dfs(const vector<vector<int>>& grid,
+                    int x, int y, int l) {
+        if (l == 1) {
+            return new Node(grid[x][y] == 1, true, nullptr, nullptr, nullptr, nullptr);
+        }
+        int half = l / 2;
+        auto topLeftNode = dfs(grid, x, y, half);
+        auto topRightNode = dfs(grid, x, y + half, half);
+        auto bottomLeftNode = dfs(grid, x + half, y, half);
+        auto bottomRightNode = dfs(grid, x + half, y + half, half);
+        if (topLeftNode->isLeaf && topRightNode->isLeaf &&
+            bottomLeftNode->isLeaf && bottomRightNode->isLeaf &&
+            topLeftNode->val == topRightNode->val &&
+            topRightNode->val == bottomLeftNode->val &&
+            bottomLeftNode->val == bottomRightNode->val) {
+            return new Node(topLeftNode->val, true, nullptr, nullptr, nullptr, nullptr);
+        }
+        return new Node(true, false, topLeftNode, topRightNode, bottomLeftNode, bottomRightNode);
+    }
+};
diff --git a/convex shell b/convex shell
new file mode 100644
index 00000000..f81921a9
--- /dev/null
+++ b/convex shell	
@@ -0,0 +1,85 @@
+// A C++ program to find convex hull of a set of points. Refer
+// https://www.geeksforgeeks.org/orientation-3-ordered-points/
+// for explanation of orientation()
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Point
+{
+	int x, y;
+};
+
+// To find orientation of ordered triplet (p, q, r).
+// The function returns following values
+// 0 --> p, q and r are collinear
+// 1 --> Clockwise
+// 2 --> Counterclockwise
+int orientation(Point p, Point q, Point r)
+{
+	int val = (q.y - p.y) * (r.x - q.x) -
+			(q.x - p.x) * (r.y - q.y);
+
+	if (val == 0) return 0; // collinear
+	return (val > 0)? 1: 2; // clock or counterclock wise
+}
+
+// Prints convex hull of a set of n points.
+void convexHull(Point points[], int n)
+{
+	// There must be at least 3 points
+	if (n < 3) return;
+
+	// Initialize Result
+	vector<Point> hull;
+
+	// Find the leftmost point
+	int l = 0;
+	for (int i = 1; i < n; i++)
+		if (points[i].x < points[l].x)
+			l = i;
+
+	// Start from leftmost point, keep moving counterclockwise
+	// until reach the start point again. This loop runs O(h)
+	// times where h is number of points in result or output.
+	int p = l, q;
+	do
+	{
+		// Add current point to result
+		hull.push_back(points[p]);
+
+		// Search for a point 'q' such that orientation(p, q,
+		// x) is counterclockwise for all points 'x'. The idea
+		// is to keep track of last visited most counterclock-
+		// wise point in q. If any point 'i' is more counterclock-
+		// wise than q, then update q.
+		q = (p+1)%n;
+		for (int i = 0; i < n; i++)
+		{
+		// If i is more counterclockwise than current q, then
+		// update q
+		if (orientation(points[p], points[i], points[q]) == 2)
+			q = i;
+		}
+
+		// Now q is the most counterclockwise with respect to p
+		// Set p as q for next iteration, so that q is added to
+		// result 'hull'
+		p = q;
+
+	} while (p != l); // While we don't come to first point
+
+	// Print Result
+	for (int i = 0; i < hull.size(); i++)
+		cout << "(" << hull[i].x << ", "
+			<< hull[i].y << ")\n";
+}
+
+// Driver program to test above functions
+int main()
+{
+	Point points[] = {{0, 3}, {2, 2}, {1, 1}, {2, 1},
+					{3, 0}, {0, 0}, {3, 3}};
+	int n = sizeof(points)/sizeof(points[0]);
+	convexHull(points, n);
+	return 0;
+}
diff --git a/count string.c b/count string.c
new file mode 100644
index 00000000..03ef4694
--- /dev/null
+++ b/count string.c	
@@ -0,0 +1,19 @@
+#include <stdio.h>  
+#include <string.h>  
+   
+int main()  
+{  
+    char string[] = "The best of both worlds";  
+    int count = 0;  
+      
+    //Counts each character except space  
+    for(int i = 0; i < strlen(string); i++) {  
+        if(string[i] != ' ')  
+            count++;  
+    }  
+      
+    //Displays the total number of characters present in the given string  
+    printf("Total number of characters in a string: %d", count);  
+   
+    return 0;  
+}  
diff --git a/countSort.cpp b/countSort.cpp
new file mode 100644
index 00000000..f90f67dd
--- /dev/null
+++ b/countSort.cpp
@@ -0,0 +1,52 @@
+//The O(N) sort.
+//Note: Only limited to small positive integers only.
+//Input: Given an array.
+//Output: Print the sorted array.
+//Time Complexity: O(N)
+
+#include<iostream>
+using namespace std;
+
+void countSort(int arr[], int n)
+{
+    int k = arr[0];
+    for(int i=0;i<n;i++)
+    {
+        k=max(arr[i],k);
+    }
+
+    int countArray[k]={0};
+
+    for(int i=0; i<n; i++)
+    {
+        countArray[arr[i]]++; 
+    }
+
+    for(int i=1;i<=n;i++)
+    {
+        countArray[i]=countArray[i]+countArray[i-1];
+    }
+    
+    int output[n]={0};
+
+    for(int i=n-1;i>=0;i--)                      
+    {                                           
+        output[--countArray[arr[i]]] = arr[i];
+    }
+
+    for(int i=0;i<n;i++)        
+    {
+        arr[i]=output[i];
+    }
+}
+
+int main()
+{
+    int arr[]={4,1,2,1,3,5,7,5,2};
+    countSort(arr,9);
+    for(int i=0;i<9;i++)
+    {
+        cout<<arr[i]<<" ";
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/create-pyramid b/create-pyramid
new file mode 100644
index 00000000..2d718073
--- /dev/null
+++ b/create-pyramid
@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+
+int main(){
+  int i,j,k,space=10;
+  for (int i=0;i<=5;i++){
+    for (int k=0;k<space;k++){
+      cout<<" ";
+    }
+    for (int j=0;j<2*i-1;j++){
+      cout<<"*";
+    }
+    space--;
+    cout<<endl;
+  }
+  cin.get();
+} 
diff --git a/cyclicsort.cpp b/cyclicsort.cpp
new file mode 100644
index 00000000..ee55c5c4
--- /dev/null
+++ b/cyclicsort.cpp
@@ -0,0 +1,76 @@
+#include <iostream>
+using namespace std;
+ 
+
+void cycleSort(int arr[], int n)
+{
+    // count number of memory writes
+    int writes = 0;
+ 
+    // traverse array elements and put it to on
+    // the right place
+    for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++) {
+        // initialize item as starting point
+        int item = arr[cycle_start];
+ 
+        // Find position where we put the item. We basically
+        // count all smaller elements on right side of item.
+        int pos = cycle_start;
+        for (int i = cycle_start + 1; i < n; i++)
+            if (arr[i] < item)
+                pos++;
+ 
+        // If item is already in correct position
+        if (pos == cycle_start)
+            continue;
+ 
+        // ignore all duplicate  elements
+        while (item == arr[pos])
+            pos += 1;
+ 
+        // put the item to it's right position
+        if (pos != cycle_start) {
+            swap(item, arr[pos]);
+            writes++;
+        }
+ 
+        // Rotate rest of the cycle
+        while (pos != cycle_start) {
+            pos = cycle_start;
+ 
+            // Find position where we put the element
+            for (int i = cycle_start + 1; i < n; i++)
+                if (arr[i] < item)
+                    pos += 1;
+ 
+            // ignore all duplicate  elements
+            while (item == arr[pos])
+                pos += 1;
+ 
+            // put the item to it's right position
+            if (item != arr[pos]) {
+                swap(item, arr[pos]);
+                writes++;
+            }
+        }
+    }
+ 
+   
+}
+ 
+
+int main()
+{
+    int n; cin >> n;
+    int arr[] = {0};
+    for(int i=0;i<n;i++){
+        cin >> arr[i];
+    }
+    
+    cycleSort(arr, n);
+ 
+    cout << "After sort : " << endl;
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+    return 0;
+}
\ No newline at end of file
diff --git a/decimaltobinary.cpp b/decimaltobinary.cpp
new file mode 100644
index 00000000..97798789
--- /dev/null
+++ b/decimaltobinary.cpp
@@ -0,0 +1,20 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+string decimal_to_binary(int n)
+{
+   string ans;
+   while(n>0){
+       int current_bit = n&1;
+       ans+=current_bit+'0';
+       n>>=1;
+   }
+   reverse(ans.begin(),ans.end());
+   return ans;
+}
+int main()
+{
+    string binary = decimal_to_binary(244);
+    cout << binary << endl;
+    return 0;
+}
diff --git a/depth first search.cpp b/depth first search.cpp
new file mode 100644
index 00000000..1cc9f9ea
--- /dev/null
+++ b/depth first search.cpp	
@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Graph class represents a directed graph
+// using adjacency list representation
+class Graph
+{
+public:
+    map<int, bool> visited;
+    map<int, list<int>> adj;
+
+    // function to add an edge to graph
+    void addEdge(int v, int w);
+
+    // DFS traversal of the vertices
+    // reachable from v
+    void DFS(int v);
+};
+
+void Graph::addEdge(int v, int w)
+{
+    adj[v].push_back(w); // Add w to v’s list.
+}
+
+void Graph::DFS(int v)
+{
+    // Mark the current node as visited and
+    // print it
+    visited[v] = true;
+    cout << v << " ";
+
+    // Recur for all the vertices adjacent
+    // to this vertex
+    list<int>::iterator i;
+    for (i = adj[v].begin(); i != adj[v].end(); ++i)
+        if (!visited[*i])
+            DFS(*i);
+}
+
+// Driver code
+int main()
+{
+    // Create a graph given in the above diagram
+    Graph g;
+    g.addEdge(0, 1);
+    g.addEdge(0, 2);
+    g.addEdge(1, 2);
+    g.addEdge(2, 0);
+    g.addEdge(2, 3);
+    g.addEdge(3, 3);
+
+    cout << "Following is Depth First Traversal"
+            " (starting from vertex 2) \n";
+    g.DFS(2);
+
+    return 0;
+}
diff --git a/digitSum.js b/digitSum.js
new file mode 100644
index 00000000..eab8850a
--- /dev/null
+++ b/digitSum.js
@@ -0,0 +1,14 @@
+const m = 5465767;
+const n = 4;
+const digitSumUpto = (m, n) => {
+   if(n > String(m).length){
+      return 0;
+   };
+   let sum = 0;
+   for(let i = 0; i < n; i++){
+      const el = +String(m)[i];
+      sum += el;
+   };
+   return sum;
+};
+console.log(digitSumUpto(m, n));
diff --git a/dijsktra's algorithm b/dijsktra's algorithm
new file mode 100644
index 00000000..259ad39f
--- /dev/null
+++ b/dijsktra's algorithm	
@@ -0,0 +1,94 @@
+// A C++ program for Dijkstra's single source shortest path algorithm.
+// The program is for adjacency matrix representation of the graph
+#include <iostream>
+using namespace std;
+#include <limits.h>
+
+// Number of vertices in the graph
+#define V 9
+
+// A utility function to find the vertex with minimum distance value, from
+// the set of vertices not yet included in shortest path tree
+int minDistance(int dist[], bool sptSet[])
+{
+
+	// Initialize min value
+	int min = INT_MAX, min_index;
+
+	for (int v = 0; v < V; v++)
+		if (sptSet[v] == false && dist[v] <= min)
+			min = dist[v], min_index = v;
+
+	return min_index;
+}
+
+// A utility function to print the constructed distance array
+void printSolution(int dist[])
+{
+	cout <<"Vertex \t Distance from Source" << endl;
+	for (int i = 0; i < V; i++)
+		cout << i << " \t\t"<<dist[i]<< endl;
+}
+
+// Function that implements Dijkstra's single source shortest path algorithm
+// for a graph represented using adjacency matrix representation
+void dijkstra(int graph[V][V], int src)
+{
+	int dist[V]; // The output array. dist[i] will hold the shortest
+	// distance from src to i
+
+	bool sptSet[V]; // sptSet[i] will be true if vertex i is included in shortest
+	// path tree or shortest distance from src to i is finalized
+
+	// Initialize all distances as INFINITE and stpSet[] as false
+	for (int i = 0; i < V; i++)
+		dist[i] = INT_MAX, sptSet[i] = false;
+
+	// Distance of source vertex from itself is always 0
+	dist[src] = 0;
+
+	// Find shortest path for all vertices
+	for (int count = 0; count < V - 1; count++) {
+		// Pick the minimum distance vertex from the set of vertices not
+		// yet processed. u is always equal to src in the first iteration.
+		int u = minDistance(dist, sptSet);
+
+		// Mark the picked vertex as processed
+		sptSet[u] = true;
+
+		// Update dist value of the adjacent vertices of the picked vertex.
+		for (int v = 0; v < V; v++)
+
+			// Update dist[v] only if is not in sptSet, there is an edge from
+			// u to v, and total weight of path from src to v through u is
+			// smaller than current value of dist[v]
+			if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
+				&& dist[u] + graph[u][v] < dist[v])
+				dist[v] = dist[u] + graph[u][v];
+	}
+
+	// print the constructed distance array
+	printSolution(dist);
+}
+
+// driver program to test above function
+int main()
+{
+
+	/* Let us create the example graph discussed above */
+	int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
+						{ 4, 0, 8, 0, 0, 0, 0, 11, 0 },
+						{ 0, 8, 0, 7, 0, 4, 0, 0, 2 },
+						{ 0, 0, 7, 0, 9, 14, 0, 0, 0 },
+						{ 0, 0, 0, 9, 0, 10, 0, 0, 0 },
+						{ 0, 0, 4, 14, 10, 0, 2, 0, 0 },
+						{ 0, 0, 0, 0, 0, 2, 0, 1, 6 },
+						{ 8, 11, 0, 0, 0, 0, 1, 0, 7 },
+						{ 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
+
+	dijkstra(graph, 0);
+
+	return 0;
+}
+
+
diff --git a/divide_string_in_n_equal_parts.cpp b/divide_string_in_n_equal_parts.cpp
new file mode 100644
index 00000000..83e423fb
--- /dev/null
+++ b/divide_string_in_n_equal_parts.cpp
@@ -0,0 +1,53 @@
+// C++ program to divide a string 
+// in n equal parts 
+#include<iostream> 
+#include<string.h> 
+
+using namespace std; 
+
+class string_division
+{ 
+
+// Function to print n equal parts of str 
+public: 
+void divide_String(char str[], int n) 
+{ 
+	
+	int str_size = strlen(str); 
+	int i; 
+	int part_size; 
+
+	// Check if string can be divided in 
+	// n equal parts 
+	if (str_size % n != 0) 
+	{ 
+		cout<<"Invalid Input: String size"; 
+		cout<<" is not divisible by n"; 
+		return; 
+	} 
+
+	// Calculate the size of parts to 
+	// find the division points 
+	part_size = str_size / n; 
+	for (i = 0; i< str_size; i++) 
+	{ 
+		if (i % part_size == 0) 
+			cout<<endl; 
+		cout<< str[i]; 
+	} 
+} 
+}; 
+
+// Driver code 
+int main() 
+{ 
+	string_division g; 
+	
+	// length od string is 28 
+	char str[] = "a_simple_divide_string_quest"; 
+
+	// Print 4 equal parts of the string 
+	g.divide_String(str, 4); 
+	return 0; 
+} 
+
diff --git a/egg_dropping_puzzle.cpp b/egg_dropping_puzzle.cpp
new file mode 100644
index 00000000..769ba8fe
--- /dev/null
+++ b/egg_dropping_puzzle.cpp
@@ -0,0 +1,58 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+
+
+class Solution
+{
+    public:
+    //Function to find minimum number of attempts needed in 
+    //order to find the critical floor.
+    int eggDrop(int n, int k) 
+    {
+        
+        int dp[n+1][k+1]; 
+        //set our base conditions 
+        for(int i=0;i<=k;i++){
+            dp[0][i]=0; 
+        }
+        for(int i=0;i<=n;i++){
+            dp[i][0]=0; 
+        }
+        for(int i=1;i<=n;i++){
+            dp[i][1]=1; 
+        }
+        for(int i=1;i<=k;i++){
+            dp[1][i]=i; 
+        }
+        for(int i=2; i<=n; i++){
+            for(int j=2; j<=k; j++){
+                //iterate over all rows
+                dp[i][j]= INT_MAX;
+                for(int x=1; x<=j; x++){
+                    int res= 1 + max(dp[i-1][x-1], dp[i][j-x]); 
+                    dp[i][j]= min(dp[i][j], res); 
+                }
+            }
+        }
+        return dp[n][k]; 
+    }
+};
+
+int main()
+{
+    //taking total testcases
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        //taking eggs and floors count
+        int n, k;
+        cin>>n>>k;
+        Solution ob;
+        //calling function eggDrop()
+        cout<<ob.eggDrop(n, k)<<endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
diff --git a/exponential_search.cpp b/exponential_search.cpp
new file mode 100644
index 00000000..e0419f32
--- /dev/null
+++ b/exponential_search.cpp
@@ -0,0 +1,50 @@
+#include <bits/stdc++.h> 
+using namespace std; 
+  
+int binarySearch(int arr[], int, int, int); 
+  
+int exponentialSearch(int arr[], int n, int x) 
+{ 
+
+    if (arr[0] == x) 
+        return 0; 
+    int i = 1; 
+    while (i < n && arr[i] <= x) 
+        i = i*2; 
+  
+  
+    return binarySearch(arr, i/2, min(i, n), x); 
+} 
+  
+
+int binarySearch(int arr[], int l, int r, int x) 
+{ 
+    if (r >= l) 
+    { 
+        int mid = l + (r - l)/2; 
+  
+        if (arr[mid] == x) 
+            return mid; 
+  
+        if (arr[mid] > x) 
+            return binarySearch(arr, l, mid-1, x); 
+  
+        return binarySearch(arr, mid+1, r, x); 
+    } 
+  
+    
+    return -1; 
+} 
+  
+ 
+int main(void) 
+{ 
+   int arr[] = {2, 3, 4, 10, 40}; 
+   int n = sizeof(arr)/ sizeof(arr[0]); 
+   int x = 10; 
+   int result = exponentialSearch(arr, n, x); 
+   (result == -1)? printf("Element is not present in array") 
+                 : printf("Element is present at index %d", 
+                                                    result); 
+   return 0; 
+} 
diff --git a/factorial b/factorial
new file mode 100644
index 00000000..60f1e3bb
--- /dev/null
+++ b/factorial
@@ -0,0 +1,21 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+    int n;
+    long double factorial = 1.0;
+
+    cout << "Enter a positive integer: ";
+    cin >> n;
+
+    if (n < 0)
+        cout << "Error! Factorial of a negative number doesn't exist.";
+    else {
+        for(int i = 1; i <= n; ++i) {
+            factorial *= i;
+        }
+        cout << "Factorial of " << n << " = " << factorial;    
+    }
+
+    return 0;
+}
diff --git a/factorial.js b/factorial.js
new file mode 100644
index 00000000..5c3d090f
--- /dev/null
+++ b/factorial.js
@@ -0,0 +1,23 @@
+// program to find the factorial of a number
+
+// take input from the user
+const number = parseInt(prompt('Enter a positive integer: '));
+
+// checking if number is negative
+if (number < 0) {
+    console.log('Error! Factorial for negative number does not exist.');
+}
+
+// if number is 0
+else if (number === 0) {
+    console.log(`The factorial of ${number} is 1.`);
+}
+
+// if number is positive
+else {
+    let fact = 1;
+    for (i = 1; i <= number; i++) {
+        fact *= i;
+    }
+    console.log(`The factorial of ${number} is ${fact}.`);
+}
diff --git a/farthest_buildings.cpp b/farthest_buildings.cpp
new file mode 100644
index 00000000..c21d229c
--- /dev/null
+++ b/farthest_buildings.cpp
@@ -0,0 +1,45 @@
+class Solution {
+public:
+    int furthestBuilding(vector<int>& heights, int br, int lad) {
+        priority_queue<int,vector<int>,greater<int>> que;
+        int i=0;
+        int diff;
+        while(que.size()<lad && i<heights.size()-1)
+        {
+            diff = heights[i+1]-heights[i];
+            if(diff<=0)
+            {
+                i++;
+                continue;
+            }
+            que.push(diff);
+            i++;
+            
+        }
+        for(;i<heights.size()-1;i++)
+        {
+            diff = heights[i+1]-heights[i];
+            if(diff>0)
+            {
+                if(!que.empty() && que.top()<diff)
+                {
+                    br = br - que.top();
+                    que.pop();
+                    que.push(diff);
+                }
+                else
+                {
+                    br = br - diff;
+                }
+            }
+            if(br<0)
+            {
+                return i;
+            }
+                
+        }
+        return i;
+        
+        
+    }
+};
diff --git a/fibonacci search b/fibonacci search
new file mode 100644
index 00000000..892c123a
--- /dev/null
+++ b/fibonacci search	
@@ -0,0 +1,76 @@
+// C program for Fibonacci Search
+#include <stdio.h>
+
+// Utility function to find minimum of two elements
+int min(int x, int y) { return (x <= y) ? x : y; }
+
+/* Returns index of x if present, else returns -1 */
+int fibMonaccianSearch(int arr[], int x, int n)
+{
+	/* Initialize fibonacci numbers */
+	int fibMMm2 = 0; // (m-2)'th Fibonacci No.
+	int fibMMm1 = 1; // (m-1)'th Fibonacci No.
+	int fibM = fibMMm2 + fibMMm1; // m'th Fibonacci
+
+	/* fibM is going to store the smallest Fibonacci
+	Number greater than or equal to n */
+	while (fibM < n) {
+		fibMMm2 = fibMMm1;
+		fibMMm1 = fibM;
+		fibM = fibMMm2 + fibMMm1;
+	}
+
+	// Marks the eliminated range from front
+	int offset = -1;
+
+	/* while there are elements to be inspected. Note that
+	we compare arr[fibMm2] with x. When fibM becomes 1,
+	fibMm2 becomes 0 */
+	while (fibM > 1) {
+		// Check if fibMm2 is a valid location
+		int i = min(offset + fibMMm2, n - 1);
+
+		/* If x is greater than the value at index fibMm2,
+		cut the subarray array from offset to i */
+		if (arr[i] < x) {
+			fibM = fibMMm1;
+			fibMMm1 = fibMMm2;
+			fibMMm2 = fibM - fibMMm1;
+			offset = i;
+		}
+
+		/* If x is greater than the value at index fibMm2,
+		cut the subarray after i+1 */
+		else if (arr[i] > x) {
+			fibM = fibMMm2;
+			fibMMm1 = fibMMm1 - fibMMm2;
+			fibMMm2 = fibM - fibMMm1;
+		}
+
+		/* element found. return index */
+		else
+			return i;
+	}
+
+	/* comparing the last element with x */
+	if (fibMMm1 && arr[offset + 1] == x)
+		return offset + 1;
+
+	/*element not found. return -1 */
+	return -1;
+}
+
+/* driver function */
+int main(void)
+{
+	int arr[]
+		= { 10, 22, 35, 40, 45, 50, 80, 82, 85, 90, 100,235};
+	int n = sizeof(arr) / sizeof(arr[0]);
+	int x = 235;
+	int ind = fibMonaccianSearch(arr, x, n);
+if(ind>=0)
+	printf("Found at index: %d",ind);
+else
+	printf("%d isn't present in the array",x);
+	return 0;
+}
diff --git a/fibonacciDP.cpp b/fibonacciDP.cpp
new file mode 100644
index 00000000..cb212a0c
--- /dev/null
+++ b/fibonacciDP.cpp
@@ -0,0 +1,20 @@
+#include <iostream>
+using namespace std;
+int fib(int x) {
+   if((x==1)||(x==0)) {
+      return(x);
+   }else {
+      return(fib(x-1)+fib(x-2));
+   }
+}
+int main() {
+   int x , i=0;
+   cout << "Enter the number of terms of series : ";
+   cin >> x;
+   cout << "\nFibonnaci Series : ";
+   while(i < x) {
+      cout << " " << fib(i);
+      i++;
+   }
+   return 0;
+}
diff --git a/flappy_bird_game.py b/flappy_bird_game.py
new file mode 100644
index 00000000..42ddd172
--- /dev/null
+++ b/flappy_bird_game.py
@@ -0,0 +1,222 @@
+import random # For generating random numbers
+import sys # We will use sys.exit to exit the program
+import pygame
+from pygame.locals import * # Basic pygame imports
+
+# Global Variables for the game
+FPS = 32
+SCREENWIDTH = 289
+SCREENHEIGHT = 511
+SCREEN = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT))
+GROUNDY = SCREENHEIGHT * 0.8
+GAME_SPRITES = {}
+GAME_SOUNDS = {}
+PLAYER = 'gallery/sprites/bird.png'
+BACKGROUND = 'gallery/sprites/background.png'
+PIPE = 'gallery/sprites/pipe.png'
+
+def welcomeScreen():
+    """
+    Shows welcome images on the screen
+    """
+
+    playerx = int(SCREENWIDTH/5)
+    playery = int((SCREENHEIGHT - GAME_SPRITES['player'].get_height())/2)
+    messagex = int((SCREENWIDTH - GAME_SPRITES['message'].get_width())/2)
+    messagey = int(SCREENHEIGHT*0.13)
+    basex = 0
+    while True:
+        for event in pygame.event.get():
+            # if user clicks on cross button, close the game
+            if event.type == QUIT or (event.type==KEYDOWN and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+
+            # If the user presses space or up key, start the game for them
+            elif event.type==KEYDOWN and (event.key==K_SPACE or event.key == K_UP):
+                return
+            else:
+                SCREEN.blit(GAME_SPRITES['background'], (0, 0))    
+                SCREEN.blit(GAME_SPRITES['player'], (playerx, playery))    
+                SCREEN.blit(GAME_SPRITES['message'], (messagex,messagey ))    
+                SCREEN.blit(GAME_SPRITES['base'], (basex, GROUNDY))    
+                pygame.display.update()
+                FPSCLOCK.tick(FPS)
+
+def mainGame():
+    score = 0
+    playerx = int(SCREENWIDTH/5)
+    playery = int(SCREENWIDTH/2)
+    basex = 0
+
+    # Create 2 pipes for blitting on the screen
+    newPipe1 = getRandomPipe()
+    newPipe2 = getRandomPipe()
+
+    # my List of upper pipes
+    upperPipes = [
+        {'x': SCREENWIDTH+200, 'y':newPipe1[0]['y']},
+        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[0]['y']},
+    ]
+    # my List of lower pipes
+    lowerPipes = [
+        {'x': SCREENWIDTH+200, 'y':newPipe1[1]['y']},
+        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[1]['y']},
+    ]
+
+    pipeVelX = -4
+
+    playerVelY = -9
+    playerMaxVelY = 10
+    playerMinVelY = -8
+    playerAccY = 1
+
+    playerFlapAccv = -8 # velocity while flapping
+    playerFlapped = False # It is true only when the bird is flapping
+
+
+    while True:
+        for event in pygame.event.get():
+            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
+                if playery > 0:
+                    playerVelY = playerFlapAccv
+                    playerFlapped = True
+                    GAME_SOUNDS['wing'].play()
+
+
+        crashTest = isCollide(playerx, playery, upperPipes, lowerPipes) # This function will return true if the player is crashed
+        if crashTest:
+            return     
+
+        #check for score
+        playerMidPos = playerx + GAME_SPRITES['player'].get_width()/2
+        for pipe in upperPipes:
+            pipeMidPos = pipe['x'] + GAME_SPRITES['pipe'][0].get_width()/2
+            if pipeMidPos<= playerMidPos < pipeMidPos +4:
+                score +=1
+                print(f"Your score is {score}") 
+                GAME_SOUNDS['point'].play()
+
+
+        if playerVelY <playerMaxVelY and not playerFlapped:
+            playerVelY += playerAccY
+
+        if playerFlapped:
+            playerFlapped = False            
+        playerHeight = GAME_SPRITES['player'].get_height()
+        playery = playery + min(playerVelY, GROUNDY - playery - playerHeight)
+
+        # move pipes to the left
+        for upperPipe , lowerPipe in zip(upperPipes, lowerPipes):
+            upperPipe['x'] += pipeVelX
+            lowerPipe['x'] += pipeVelX
+
+        # Add a new pipe when the first is about to cross the leftmost part of the screen
+        if 0<upperPipes[0]['x']<5:
+            newpipe = getRandomPipe()
+            upperPipes.append(newpipe[0])
+            lowerPipes.append(newpipe[1])
+
+        # if the pipe is out of the screen, remove it
+        if upperPipes[0]['x'] < -GAME_SPRITES['pipe'][0].get_width():
+            upperPipes.pop(0)
+            lowerPipes.pop(0)
+        
+        # blit our sprites 
+        SCREEN.blit(GAME_SPRITES['background'], (0, 0))
+        for upperPipe, lowerPipe in zip(upperPipes, lowerPipes):
+            SCREEN.blit(GAME_SPRITES['pipe'][0], (upperPipe['x'], upperPipe['y']))
+            SCREEN.blit(GAME_SPRITES['pipe'][1], (lowerPipe['x'], lowerPipe['y']))
+
+        SCREEN.blit(GAME_SPRITES['base'], (basex, GROUNDY))
+        SCREEN.blit(GAME_SPRITES['player'], (playerx, playery))
+        myDigits = [int(x) for x in list(str(score))]
+        width = 0
+        for digit in myDigits:
+            width += GAME_SPRITES['numbers'][digit].get_width()
+        Xoffset = (SCREENWIDTH - width)/2
+
+        for digit in myDigits:
+            SCREEN.blit(GAME_SPRITES['numbers'][digit], (Xoffset, SCREENHEIGHT*0.12))
+            Xoffset += GAME_SPRITES['numbers'][digit].get_width()
+        pygame.display.update()
+        FPSCLOCK.tick(FPS)
+
+def isCollide(playerx, playery, upperPipes, lowerPipes):
+    if playery> GROUNDY - 25  or playery<0:
+        GAME_SOUNDS['hit'].play()
+        return True
+    
+    for pipe in upperPipes:
+        pipeHeight = GAME_SPRITES['pipe'][0].get_height()
+        if(playery < pipeHeight + pipe['y'] and abs(playerx - pipe['x']) < GAME_SPRITES['pipe'][0].get_width()):
+            GAME_SOUNDS['hit'].play()
+            return True
+
+    for pipe in lowerPipes:
+        if (playery + GAME_SPRITES['player'].get_height() > pipe['y']) and abs(playerx - pipe['x']) < GAME_SPRITES['pipe'][0].get_width():
+            GAME_SOUNDS['hit'].play()
+            return True
+
+    return False
+
+def getRandomPipe():
+    """
+    Generate positions of two pipes(one bottom straight and one top rotated ) for blitting on the screen
+    """
+    pipeHeight = GAME_SPRITES['pipe'][0].get_height()
+    offset = SCREENHEIGHT/3
+    y2 = offset + random.randrange(0, int(SCREENHEIGHT - GAME_SPRITES['base'].get_height()  - 1.2 *offset))
+    pipeX = SCREENWIDTH + 10
+    y1 = pipeHeight - y2 + offset
+    pipe = [
+        {'x': pipeX, 'y': -y1}, #upper Pipe
+        {'x': pipeX, 'y': y2} #lower Pipe
+    ]
+    return pipe
+
+
+
+
+
+
+if __name__ == "__main__":
+    # This will be the main point from where our game will start
+    pygame.init() # Initialize all pygame's modules
+    FPSCLOCK = pygame.time.Clock()
+    pygame.display.set_caption('Flappy Bird by Rohit Paiya')
+    GAME_SPRITES['numbers'] = ( 
+        pygame.image.load('gallery/sprites/0.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/1.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/2.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/3.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/4.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/5.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/6.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/7.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/8.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/9.png').convert_alpha(),
+    )
+
+    GAME_SPRITES['message'] =pygame.image.load('gallery/sprites/message.jpeg').convert_alpha()
+    GAME_SPRITES['base'] =pygame.image.load('gallery/sprites/base.png').convert_alpha()
+    GAME_SPRITES['pipe'] =(pygame.transform.rotate(pygame.image.load( PIPE).convert_alpha(), 180), 
+    pygame.image.load(PIPE).convert_alpha()
+    )
+
+    # Game sounds
+    GAME_SOUNDS['die'] = pygame.mixer.Sound('gallery/audio/die.wav')
+    GAME_SOUNDS['hit'] = pygame.mixer.Sound('gallery/audio/hit.wav')
+    GAME_SOUNDS['point'] = pygame.mixer.Sound('gallery/audio/point.wav')
+    GAME_SOUNDS['swoosh'] = pygame.mixer.Sound('gallery/audio/swoosh.wav')
+    GAME_SOUNDS['wing'] = pygame.mixer.Sound('gallery/audio/wing.wav')
+
+    GAME_SPRITES['background'] = pygame.image.load(BACKGROUND).convert()
+    GAME_SPRITES['player'] = pygame.image.load(PLAYER).convert_alpha()
+
+    while True:
+        welcomeScreen() # Shows welcome screen to the user until he presses a button
+        mainGame() # This is the main game function 
\ No newline at end of file
diff --git a/floyd_warshall.cpp b/floyd_warshall.cpp
new file mode 100644
index 00000000..b416d178
--- /dev/null
+++ b/floyd_warshall.cpp
@@ -0,0 +1,43 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+#define INF 10000
+
+vector<vector<int>> floyd_warshall(vector<vector<int>> graph){
+
+	vector<vector<int>> dist(graph);
+	int V = graph.size();
+
+	for(int k=0;k<V;k++){
+		for(int i=0;i<V;i++){
+			for(int j=0;j<V;j++){
+				if(dist[i][k] + dist[k][j] < dist[i][j]){
+					dist[i][j] = dist[i][k] + dist[k][j];
+				}
+			}
+		}
+	}
+	return dist;
+}
+
+int main(){
+
+	vector<vector<int>> graph = {
+								{0,INF,-2,INF},
+								{4,0,3,INF},
+								{INF,INF,0,2},
+								{INF,-1,INF,0}
+								};
+
+	auto result = floyd_warshall(graph);
+
+	for(int i=0;i<result.size();i++){
+		for(int j=0;j<result.size();j++){
+			cout<<result[i][j]<<" ";
+		}
+		cout<<endl;
+	}
+	
+	return 0;
+}
diff --git a/frequency_of_chars.cpp b/frequency_of_chars.cpp
new file mode 100644
index 00000000..c3a503ae
--- /dev/null
+++ b/frequency_of_chars.cpp
@@ -0,0 +1,152 @@
+#include<stdio.h>
+#include<conio.h>
+#include<string.h>
+main()
+{
+	int ch,i,j,k,l,fc[50][2],flag;
+	char line[50],fw[50][50];
+	clrscr();
+	do
+	{
+		printf("\n<1> Input a line");
+		printf("\n<2> Number of characters");
+		printf("\n<3> Number of words");
+		printf("\n<4> Number of vowals");
+		printf("\n<5> Frequency of characters");
+		printf("\n<6> Frequency of words");
+		printf("\n<7> Exit\n");
+		do
+		{
+			printf("\n enter your choice ");
+			scanf("%d",&ch);
+		}while(ch>7 || ch<1);
+		switch (ch)
+		{
+			case 1:		//input a line
+				printf("\n Enter a line ");
+				scanf("\n%[^\n]",line);
+				break;
+			case 2:		//number of characters
+				j=0;
+				for(i=0;i<strlen(line);++i)
+				{
+					if(line[i]>64 && line[i]<93)
+						++j;
+					else
+						if(line[i]>96 && line[i]<123)
+							++j;
+				}
+				printf("total number of characters are %d",j);
+				break;
+			case 3:		//number of words
+				j=0;
+				for(i=0;i<strlen(line);++i)
+				{
+					if(line[i]==' ' || line[i]=='\t')
+						continue;
+					else
+					{
+						for(k=i;k<strlen(line);++k)
+						{
+							if(line[k]==' ' || line[k]=='\t')
+								break;
+							else
+								++i;
+						}
+					}
+					++j;
+				}
+				printf("\n total number of words are %d",j);
+				break;
+			case 4:		//number of vowels
+				j=0;
+				for(i=0;i<strlen(line);++i)
+				{
+					if(line[i]=='a' || line[i]=='e' || line[i]=='i' || line[i]=='o' || line[i]=='u')
+						++j;
+					else
+						if(line[i]=='A' || line[i]=='E' || line[i]=='I' || line[i]=='O' || line[i]=='U')
+							++j;
+				}
+				printf("total number of vowels are %d",j);
+				break;
+			case 5:		//frequency of characters
+				for(i=0;i<strlen(line);++i)
+				{
+					fc[i][1]=0;
+					flag=0;
+					for(j=0;j<strlen(line);++j)
+					{
+						if(line[i]==fc[j][0])
+						{
+							fc[j][0]=line[i];
+							++fc[j][1];
+							flag=1;
+							break;
+						}
+					}
+					if(flag==0)
+						fc[i][0]=line[i],fc[i][1]=1;
+				}
+				printf("\n Frequency of each characters");
+				for(i=0;i<strlen(line);++i)
+					if(fc[i][1]!=0)
+						printf("\n%c %d",fc[i][0],fc[i][1]);
+				break;
+			case 6:		//frequency of words
+				j=0;
+				for(i=0;i<strlen(line);++i)
+				{
+					if(line[i]==' ' || line[i]=='\t')
+						continue;
+					else
+					{
+						l=0;
+						for(k=i;k<strlen(line);++k)
+						{
+							if(line[k]==' ' || line[k]=='\t')
+								break;
+							else
+							{
+								fw[j][l]=line[k],fw[j][++l]='\0';
+								++i;
+							}
+						}
+					}
+					++j;
+				}
+				for(i=0;i<j;++i)
+				{
+					fc[0][0]=0;
+					for(k=i;k<j;++k)
+					{
+						flag=1;
+						for(l=0;l<j;++l)
+							if(fw[i][l]!=fw[k][l])
+								flag=0;
+						if(flag==1)
+						{
+							++fc[0][0];
+							if(fc[0][0]>1)
+								fw[k][0]='\0';
+						}
+					}
+					if(fc[0][0]>0)
+					{
+						flag=0;
+						do
+						{
+							printf("%c",fw[i][flag]);
+						} while(fw[i][flag++]!='\0');
+						if(fw[i][0]!='\0')
+							printf("%d\n",fc[0][0]);
+					}
+					fc[0][0]=0;
+				}
+				break;
+		}
+	}while(ch!=7);
+	printf("\n\n i will wait for your mails ");
+	getch();
+	return ;
+}
diff --git a/game b/game
new file mode 100644
index 00000000..5945f78e
--- /dev/null
+++ b/game
@@ -0,0 +1,84 @@
+from random import choice, random
+from turtle import *
+
+from freegames import vector
+
+
+def value():
+    "Randomly generate value between (-5, -3) or (3, 5)."
+    return (3 + random() * 2) * choice([1, -1])
+
+
+ball = vector(0, 0)
+aim = vector(value(), value())
+state = {1: 0, 2: 0}
+
+
+def move(player, change):
+    "Move player position by change."
+    state[player] += change
+
+
+def rectangle(x, y, width, height):
+    "Draw rectangle at (x, y) with given width and height."
+    up()
+    goto(x, y)
+    down()
+    begin_fill()
+    for count in range(2):
+        forward(width)
+        left(90)
+        forward(height)
+        left(90)
+    end_fill()
+
+
+def draw():
+    "Draw game and move pong ball."
+    clear()
+    rectangle(-200, state[1], 10, 50)
+    rectangle(190, state[2], 10, 50)
+
+    ball.move(aim)
+    x = ball.x
+    y = ball.y
+
+    up()
+    goto(x, y)
+    dot(10)
+    update()
+
+    if y < -200 or y > 200:
+        aim.y = -aim.y
+
+    if x < -185:
+        low = state[1]
+        high = state[1] + 50
+
+        if low <= y <= high:
+            aim.x = -aim.x
+        else:
+            return
+
+    if x > 185:
+        low = state[2]
+        high = state[2] + 50
+
+        if low <= y <= high:
+            aim.x = -aim.x
+        else:
+            return
+
+    ontimer(draw, 50)
+
+
+setup(420, 420, 370, 0)
+hideturtle()
+tracer(False)
+listen()
+onkey(lambda: move(1, 20), 'w')
+onkey(lambda: move(1, -20), 's')
+onkey(lambda: move(2, 20), 'i')
+onkey(lambda: move(2, -20), 'k')
+draw()
+done()
diff --git a/good binary string.py b/good binary string.py
new file mode 100644
index 00000000..f05c96b2
--- /dev/null
+++ b/good binary string.py	
@@ -0,0 +1,19 @@
+
+def largestMagicalString(n):
+    cnt = 0
+    p = 0
+    res=[]
+    for i in range(len(n)):
+        if n[i] == '0':
+            cnt += 1
+        else:
+            cnt -= 1
+        if cnt == 0:
+            m = largestMagicalString(n[p+1:i])
+            res.append("1"+m+"0")
+            p=p+1
+        res.sort(reverse=True)
+        return "".join(res)
+
+n = input()
+print(largestMagicalString(n))
diff --git a/healthy_programmer.py b/healthy_programmer.py
new file mode 100644
index 00000000..0e8029d8
--- /dev/null
+++ b/healthy_programmer.py
@@ -0,0 +1,62 @@
+from pygame import mixer
+
+from  datetime import  datetime
+import  time
+
+def musiconloop(file, stopper):
+    mixer.init()
+    mixer.music.load(file)
+    mixer.music.play()
+    while True:
+        a = input()
+        if a == stopper:
+            mixer.music.stop()
+            break
+
+def log_now(msg):
+    with open("mylogs.txt", "a") as f:
+         f.write(f"{msg} {datetime.now()}\n")
+
+def IsOfficeTime(currenttime):
+    if currenttime > '09:00:00' and currenttime < '17:00:01':
+        return True
+    else:
+        print("Sorry we only play this application in office hours i.e. in between 9 am to 5 pm ")
+        return False
+
+if __name__ == '__main__':
+    # musiconloop("water.mp3", "stop")
+    init_water = time.time()
+    init_eyes = time.time()
+    init_exercise = time.time()
+    currenttime = time.strftime('%H:%M:%S')
+    watersecs = 20*60 # Every 20 minutes
+    exesecs = 30*60 # Every 30 minutes
+    eyessecs = 45*60 # Every 45 minutes
+    SleepTime = 60 # Time gap of 1 minute after each task is performed
+
+    while (IsOfficeTime(currenttime)):
+
+        if time.time() - init_water > watersecs:
+            print("Water Drinking time. Enter 'D' to stop the alarm.")
+            musiconloop('water.mp3', 'D')
+            init_water = time.time()
+            log_now("Drank water at")
+            time.sleep(SleepTime)
+
+        if time.time() - init_eyes > eyessecs:
+            print("Eyes exercise time. Enter 'E' to stop the alarm.")
+            musiconloop('rush.mp3','E')
+            init_eyes = time.time()
+            log_now("Eyes exercise done at")
+            time.sleep(SleepTime)
+
+        if time.time() - init_exercise > exesecs:
+            print("Body Exercise time. Enter 'B' to stop the alarm.")
+            musiconloop('physical-exercise.mp3','B')
+            init_exercise = time.time()
+            log_now("Body exercise done at")
+            time.sleep(SleepTime)
+
+        time.sleep(SleepTime)
+        currenttime = time.strftime('%H:%M:%S')
diff --git a/heap_short.cpp b/heap_short.cpp
new file mode 100644
index 00000000..38bdfe64
--- /dev/null
+++ b/heap_short.cpp
@@ -0,0 +1,63 @@
+// C++ program for implementation of Heap Sort
+#include <iostream>
+using namespace std;
+
+void heapify(int arr[], int n, int i)
+{
+	int largest = i; // Initialize largest as root
+	int l = 2 * i + 1; // left = 2*i + 1
+	int r = 2 * i + 2; // right = 2*i + 2
+
+
+	if (l < n && arr[l] > arr[largest])
+		largest = l;
+
+
+	if (r < n && arr[r] > arr[largest])
+		largest = r;
+
+
+	if (largest != i) {
+		swap(arr[i], arr[largest]);
+
+
+		heapify(arr, n, largest);
+	}
+}
+
+void heapSort(int arr[], int n)
+{
+
+	for (int i = n / 2 - 1; i >= 0; i--)
+		heapify(arr, n, i);
+
+
+	for (int i = n - 1; i >= 0; i--) {
+	
+		swap(arr[0], arr[i]);
+
+	
+		heapify(arr, i, 0);
+	}
+}
+
+
+void printArray(int arr[], int n)
+{
+	for (int i = 0; i < n; ++i)
+		cout << arr[i] << " ";
+	cout << "\n";
+}
+
+
+int main()
+{
+	int arr[] = { 12, 11, 13, 5, 6, 7 };
+	int n = sizeof(arr) / sizeof(arr[0]);
+
+	heapSort(arr, n);
+
+	cout << "Sorted array is \n";
+	printArray(arr, n);
+}
+
diff --git a/heap_sort.py b/heap_sort.py
new file mode 100644
index 00000000..8da15624
--- /dev/null
+++ b/heap_sort.py
@@ -0,0 +1,48 @@
+# Python program for implementation of heap Sort
+
+# To heapify subtree rooted at index i.
+# n is size of heap
+def heapify(arr, n, i):
+	largest = i # Initialize largest as root
+	l = 2 * i + 1	 # left = 2*i + 1
+	r = 2 * i + 2	 # right = 2*i + 2
+
+	# See if left child of root exists and is
+	# greater than root
+	if l < n and arr[i] < arr[l]:
+		largest = l
+
+	# See if right child of root exists and is
+	# greater than root
+	if r < n and arr[largest] < arr[r]:
+		largest = r
+
+	# Change root, if needed
+	if largest != i:
+		arr[i],arr[largest] = arr[largest],arr[i] # swap
+
+		# Heapify the root.
+		heapify(arr, n, largest)
+
+# The main function to sort an array of given size
+def heapSort(arr):
+	n = len(arr)
+
+	# Build a maxheap.
+	# Since last parent will be at ((n//2)-1) we can start at that location.
+	for i in range(n // 2 - 1, -1, -1):
+		heapify(arr, n, i)
+
+	# One by one extract elements
+	for i in range(n-1, 0, -1):
+		arr[i], arr[0] = arr[0], arr[i] # swap
+		heapify(arr, i, 0)
+
+# Driver code to test above
+arr = [ 122, 141, 213, 35, 64, 27]
+heapSort(arr)
+n = len(arr)
+print ("Sorted array is")
+for i in range(n):
+	print ("%d" %arr[i]),
+# This code is contributed by Nikhar Kesari
diff --git a/howrecursionworks b/howrecursionworks
new file mode 100644
index 00000000..8bcc6d4e
--- /dev/null
+++ b/howrecursionworks
@@ -0,0 +1,23 @@
+// A C++ program to demonstrate working of
+// recursion
+#include <bits/stdc++.h>
+using namespace std;
+
+void printFun(int test)
+{
+	if (test < 1)
+		return;
+	else {
+		cout << test << " ";
+		printFun(test - 1); // statement 2
+		cout << test << " ";
+		return;
+	}
+}
+
+// Driver Code
+int main()
+{
+	int test = 3;
+	printFun(test);
+}
diff --git a/insertion_sort.cpp b/insertion_sort.cpp
new file mode 100644
index 00000000..1a2c6128
--- /dev/null
+++ b/insertion_sort.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+using namespace std;
+
+void inSort(int *arr, int n)
+{
+    int key,j;
+    for (int i=1;i<n;i++)
+    {
+        key=arr[i];
+        j=i-1;
+
+        while(j>=0 && arr[j]>key)
+        {
+            arr[j+1]=arr[j];
+            j=j-1;
+        }
+        arr[j+1]=key;
+
+    }
+
+    for(int i=0;i<n;i++)
+    cout<<arr[i];
+}
+
+
+
+int main() {
+	// your code goes here
+
+	int arr[100];
+	int n;
+    cin>>n;
+    for(int i=0;i<n;i++)
+        cin>>arr[i];
+
+	inSort(arr,n);
+
+
+	return 0;
+}
diff --git a/insertion_sort.py b/insertion_sort.py
new file mode 100644
index 00000000..f2de2d0d
--- /dev/null
+++ b/insertion_sort.py
@@ -0,0 +1,28 @@
+# Python program for implementation of Insertion Sort
+
+# Function to do insertion sort
+def insertionSort(arr):
+
+	# Traverse through 1 to len(arr)
+	for i in range(1, len(arr)):
+
+		key = arr[i]
+
+		# Move elements of arr[0..i-1], that are
+		# greater than key, to one position ahead
+		# of their current position
+		j = i-1
+		while j >=0 and key < arr[j] :
+				arr[j+1] = arr[j]
+				j -= 1
+		arr[j+1] = key
+
+
+# Driver code to test above
+arr = [122, 311, 413, 45, 26]
+insertionSort(arr)
+print ("Sorted array is:")
+for i in range(len(arr)):
+	print ("%d" %arr[i])
+
+# This code is contributed by Nikhar Kesari
diff --git a/insertion_sort_linked_list.cpp b/insertion_sort_linked_list.cpp
new file mode 100644
index 00000000..d49fc2e8
--- /dev/null
+++ b/insertion_sort_linked_list.cpp
@@ -0,0 +1,15 @@
+ListNode* insertionSortList(ListNode* head) {
+    if (head == nullptr || head->next == NULL)
+        return head;
+    ListNode *h = insertionSortList(head->next);
+    if (head->val <= h->val) {  
+        head->next = h;
+        return head;
+    }
+    ListNode *node = h;   
+    while (node->next && head->val > node->next->val)
+        node = node->next;
+    head->next = node->next;
+    node->next = head;
+    return h;
+}
diff --git a/interpolationSEARCH.cpp b/interpolationSEARCH.cpp
new file mode 100644
index 00000000..6a8699b5
--- /dev/null
+++ b/interpolationSEARCH.cpp
@@ -0,0 +1,55 @@
+#include<bits/stdc++.h> 
+using namespace std; 
+int interpolationSearch(int arr[], int n, int x) 
+{ 
+    // Find indexes of two corners 
+    int lo = 0, hi = (n - 1); 
+  
+    // Since array is sorted, an element present 
+    // in array must be in range defined by corner 
+    while (lo <= hi && x >= arr[lo] && x <= arr[hi]) 
+    { 
+        if (lo == hi) 
+        { 
+            if (arr[lo] == x) return lo; 
+            return -1; 
+        } 
+        // Probing the position with keeping 
+        // uniform distribution in mind. 
+        int pos = lo + (((double)(hi - lo) / 
+            (arr[hi] - arr[lo])) * (x - arr[lo])); 
+  
+        // Condition of target found 
+        if (arr[pos] == x) 
+            return pos; 
+  
+        // If x is larger, x is in upper part 
+        if (arr[pos] < x) 
+            lo = pos + 1; 
+  
+        // If x is smaller, x is in the lower part 
+        else
+            hi = pos - 1; 
+    } 
+    return -1; 
+} 
+  
+// Driver Code 
+int main() 
+{ 
+    // Array of items on which search will 
+    // be conducted. 
+    int arr[] = {10, 12, 13, 16, 18, 19, 20, 21, 
+                 22, 23, 24, 33, 35, 42, 47}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+  
+    int x = 18; // Element to be searched 
+    int index = interpolationSearch(arr, n, x); 
+  
+    // If element was found 
+    if (index != -1) 
+        cout << "Element found at index " << index; 
+    else
+        cout << "Element not found."; 
+    return 0; 
+}
diff --git a/interpolation_search.cpp b/interpolation_search.cpp
new file mode 100644
index 00000000..3ef40b8a
--- /dev/null
+++ b/interpolation_search.cpp
@@ -0,0 +1,61 @@
+// C++ program to implement interpolation search 
+#include<bits/stdc++.h> 
+using namespace std; 
+
+// If x is present in arr[0..n-1], then returns 
+// index of it, else returns -1. 
+int interpolationSearch(int arr[], int n, int x) 
+{ 
+	// Find indexes of two corners 
+	int lo = 0, hi = (n - 1); 
+
+	// Since array is sorted, an element present 
+	// in array must be in range defined by corner 
+	while (lo <= hi && x >= arr[lo] && x <= arr[hi]) 
+	{ 
+		if (lo == hi) 
+		{ 
+			if (arr[lo] == x) return lo; 
+			return -1; 
+		} 
+		// Probing the position with keeping 
+		// uniform distribution in mind. 
+		int pos = lo + (((double)(hi - lo) / 
+			(arr[hi] - arr[lo])) * (x - arr[lo])); 
+
+		// Condition of target found 
+		if (arr[pos] == x) 
+			return pos; 
+
+		// If x is larger, x is in upper part 
+		if (arr[pos] < x) 
+			lo = pos + 1; 
+
+		// If x is smaller, x is in the lower part 
+		else
+			hi = pos - 1; 
+	} 
+	return -1; 
+} 
+
+// Driver Code 
+int main() 
+{ 
+	// Array of items on which search will 
+	// be conducted. 
+	int arr[] = {10, 12, 13, 16, 18, 19, 20, 21, 
+				22, 23, 24, 33, 35, 42, 47}; 
+	int n = sizeof(arr)/sizeof(arr[0]); 
+
+	int x = 18; // Element to be searched 
+	int index = interpolationSearch(arr, n, x); 
+
+	// If element was found 
+	if (index != -1) 
+		cout << "Element found at index " << index; 
+	else
+		cout << "Element not found."; 
+	return 0; 
+} 
+
+// This code is contributed by Mukul Singh. 
diff --git a/java multiply 2 numbers in java b/java multiply 2 numbers in java
new file mode 100644
index 00000000..1a875535
--- /dev/null
+++ b/java multiply 2 numbers in java	
@@ -0,0 +1,22 @@
+public class MatrixMultiplicationExample{  
+public static void main(String args[]){  
+//creating two matrices    
+int a[][]={{1,1,1},{2,2,2},{3,3,3}};    
+int b[][]={{1,1,1},{2,2,2},{3,3,3}};    
+    
+//creating another matrix to store the multiplication of two matrices    
+int c[][]=new int[3][3];  //3 rows and 3 columns  
+    
+//multiplying and printing multiplication of 2 matrices    
+for(int i=0;i<3;i++){    
+for(int j=0;j<3;j++){    
+c[i][j]=0;      
+for(int k=0;k<3;k++)      
+{      
+c[i][j]+=a[i][k]*b[k][j];      
+}//end of k loop  
+System.out.print(c[i][j]+" ");  //printing matrix element  
+}//end of j loop  
+System.out.println();//new line    
+}    
+}}  
diff --git a/jump search cpp b/jump search cpp
new file mode 100644
index 00000000..35bc92e6
--- /dev/null
+++ b/jump search cpp	
@@ -0,0 +1,55 @@
+// C++ program to implement Jump Search
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int jumpSearch(int arr[], int x, int n)
+{
+	// Finding block size to be jumped
+	int step = sqrt(n);
+
+	// Finding the block where element is
+	// present (if it is present)
+	int prev = 0;
+	while (arr[min(step, n)-1] < x)
+	{
+		prev = step;
+		step += sqrt(n);
+		if (prev >= n)
+			return -1;
+	}
+
+	// Doing a linear search for x in block
+	// beginning with prev.
+	while (arr[prev] < x)
+	{
+		prev++;
+
+		// If we reached next block or end of
+		// array, element is not present.
+		if (prev == min(step, n))
+			return -1;
+	}
+	// If element is found
+	if (arr[prev] == x)
+		return prev;
+
+	return -1;
+}
+
+// Driver program to test function
+int main()
+{
+	int arr[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21,
+				34, 55, 89, 144, 233, 377, 610 };
+	int x = 55;
+	int n = sizeof(arr) / sizeof(arr[0]);
+	
+	// Find the index of 'x' using Jump Search
+	int index = jumpSearch(arr, x, n);
+
+	// Print the index where 'x' is located
+	cout << "\nNumber " << x << " is at index " << index;
+	return 0;
+}
+
diff --git a/jump_search.cpp b/jump_search.cpp
new file mode 100644
index 00000000..ae62119a
--- /dev/null
+++ b/jump_search.cpp
@@ -0,0 +1,70 @@
+//
+// C++ program to implement Jump Search
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/searches/
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Bharat Reddy
+// Github: @Bharat-Reddy
+//
+#include <bits/stdc++.h>
+using namespace std;
+
+int jumpSearch(int arr[], int x, int n)
+{
+    // Finding block size to be jumped
+    int step = sqrt(n);
+
+    // Finding the block where element is
+    // present (if it is present)
+    int prev = 0;
+    while (arr[min(step, n)-1] < x)
+    {
+        prev = step;
+        step += sqrt(n);
+        if (prev >= n)
+            return -1;
+    }
+
+    // Doing a linear search for x in block
+    // beginning with prev.
+    while (arr[prev] < x)
+    {
+        prev++;
+
+        // If we reached next block or end of
+        // array, element is not present.
+        if (prev == min(step, n))
+            return -1;
+    }
+    // If element is found
+    if (arr[prev] == x)
+        return prev;
+
+    return -1;
+}
+
+// Driver program to test function
+int main()
+{
+    int n,i;
+    cout<<"Eneter size of array : ";
+    cin>>n;
+    cout<<"Enter elements of array"<<endl;
+    int a[n];
+    for(i=0;i<n;i++)
+        cin>>a[i];
+    sort(a,a+n);
+    cout<<"Enter key to be searched : ";
+    int key;
+    cin>>key;
+
+    // Find the index of 'x' using Jump Search
+    int index = jumpSearch(a, key, n);
+
+    // Print the index where 'x' is located
+    cout << "\nNumber " << key << " is at index " << index;
+    return 0;
+}
diff --git a/k largest(or smallest) elements in an array b/k largest(or smallest) elements in an array
new file mode 100644
index 00000000..5bf37268
--- /dev/null
+++ b/k largest(or smallest) elements in an array	
@@ -0,0 +1,26 @@
+//k largest(or smallest) elements in an array
+
+// C++ code for k largest elements in an array
+#include <bits/stdc++.h>
+using namespace std;
+ 
+void kLargest(int arr[], int n, int k)
+{
+    // Sort the given array arr in reverse
+    // order.
+    sort(arr, arr + n, greater<int>());
+ 
+    // Print the first kth largest elements
+    for (int i = 0; i < k; i++)
+        cout << arr[i] << " ";
+}
+ 
+// driver program
+int main()
+{
+    int arr[] = { 1, 23, 12, 9, 30, 2, 50 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+    int k = 3;
+    kLargest(arr, n, k);
+}
+ 
diff --git a/kmp_pattern_matching.cpp b/kmp_pattern_matching.cpp
new file mode 100644
index 00000000..d9082506
--- /dev/null
+++ b/kmp_pattern_matching.cpp
@@ -0,0 +1,88 @@
+// C++ program for implementation of KMP pattern searching 
+// algorithm 
+#include <bits/stdc++.h> 
+
+void computeLPSArray(char* pat, int M, int* lps); 
+
+// Prints occurrences of txt[] in pat[] 
+void KMPSearch(char* pat, char* txt) 
+{ 
+	int M = strlen(pat); 
+	int N = strlen(txt); 
+
+	// create lps[] that will hold the longest prefix suffix 
+	// values for pattern 
+	int lps[M]; 
+
+	// Preprocess the pattern (calculate lps[] array) 
+	computeLPSArray(pat, M, lps); 
+
+	int i = 0; // index for txt[] 
+	int j = 0; // index for pat[] 
+	while (i < N) { 
+		if (pat[j] == txt[i]) { 
+			j++; 
+			i++; 
+		} 
+
+		if (j == M) { 
+			printf("Found pattern at index %d ", i - j); 
+			j = lps[j - 1]; 
+		} 
+
+		// mismatch after j matches 
+		else if (i < N && pat[j] != txt[i]) { 
+			// Do not match lps[0..lps[j-1]] characters, 
+			// they will match anyway 
+			if (j != 0) 
+				j = lps[j - 1]; 
+			else
+				i = i + 1; 
+		} 
+	} 
+} 
+
+// Fills lps[] for given patttern pat[0..M-1] 
+void computeLPSArray(char* pat, int M, int* lps) 
+{ 
+	// length of the previous longest prefix suffix 
+	int len = 0; 
+
+	lps[0] = 0; // lps[0] is always 0 
+
+	// the loop calculates lps[i] for i = 1 to M-1 
+	int i = 1; 
+	while (i < M) { 
+		if (pat[i] == pat[len]) { 
+			len++; 
+			lps[i] = len; 
+			i++; 
+		} 
+		else // (pat[i] != pat[len]) 
+		{ 
+			// This is tricky. Consider the example. 
+			// AAACAAAA and i = 7. The idea is similar 
+			// to search step. 
+			if (len != 0) { 
+				len = lps[len - 1]; 
+
+				// Also, note that we do not increment 
+				// i here 
+			} 
+			else // if (len == 0) 
+			{ 
+				lps[i] = 0; 
+				i++; 
+			} 
+		} 
+	} 
+} 
+
+// Driver program to test above function 
+int main() 
+{ 
+	char txt[] = "ABABDABACDABABCABAB"; 
+	char pat[] = "ABABCABAB"; 
+	KMPSearch(pat, txt); 
+	return 0; 
+} 
diff --git a/knapsackCP.py b/knapsackCP.py
new file mode 100644
index 00000000..da2ada19
--- /dev/null
+++ b/knapsackCP.py
@@ -0,0 +1,33 @@
+
+
+def knapSack(W, wt, val, n):
+
+	# Base Case
+	if n == 0 or W == 0:
+		return 0
+
+	# If weight of the nth item is
+	# more than Knapsack of capacity W,
+	# then this item cannot be included
+	# in the optimal solution
+	if (wt[n-1] > W):
+		return knapSack(W, wt, val, n-1)
+
+	# return the maximum of two cases:
+	# (1) nth item included
+	# (2) not included
+	else:
+		return max(
+			val[n-1] + knapSack(
+				W-wt[n-1], wt, val, n-1),
+			knapSack(W, wt, val, n-1))
+
+# end of function knapSack
+
+
+#Driver Code
+val = [60, 100, 120]
+wt = [10, 20, 30]
+W = 50
+n = len(val)
+print knapSack(W, wt, val, n)
diff --git a/kruskal's.cpp b/kruskal's.cpp
new file mode 100644
index 00000000..4d73eb33
--- /dev/null
+++ b/kruskal's.cpp
@@ -0,0 +1,159 @@
+// C++ program for Kruskal's algorithm to find Minimum
+// Spanning Tree of a given connected, undirected and
+// weighted graph
+#include<bits/stdc++.h>
+using namespace std;
+
+// Creating shortcut for an integer pair
+typedef pair<int, int> iPair;
+
+// Structure to represent a graph
+struct Graph
+{
+	int V, E;
+	vector< pair<int, iPair> > edges;
+
+	// Constructor
+	Graph(int V, int E)
+	{
+		this->V = V;
+		this->E = E;
+	}
+
+	// Utility function to add an edge
+	void addEdge(int u, int v, int w)
+	{
+		edges.push_back({w, {u, v}});
+	}
+
+	// Function to find MST using Kruskal's
+	// MST algorithm
+	int kruskalMST();
+};
+
+// To represent Disjoint Sets
+struct DisjointSets
+{
+	int *parent, *rnk;
+	int n;
+
+	// Constructor.
+	DisjointSets(int n)
+	{
+		// Allocate memory
+		this->n = n;
+		parent = new int[n+1];
+		rnk = new int[n+1];
+
+		// Initially, all vertices are in
+		// different sets and have rank 0.
+		for (int i = 0; i <= n; i++)
+		{
+			rnk[i] = 0;
+
+			//every element is parent of itself
+			parent[i] = i;
+		}
+	}
+
+	// Find the parent of a node 'u'
+	// Path Compression
+	int find(int u)
+	{
+		/* Make the parent of the nodes in the path
+		from u--> parent[u] point to parent[u] */
+		if (u != parent[u])
+			parent[u] = find(parent[u]);
+		return parent[u];
+	}
+
+	// Union by rank
+	void merge(int x, int y)
+	{
+		x = find(x), y = find(y);
+
+		/* Make tree with smaller height
+		a subtree of the other tree */
+		if (rnk[x] > rnk[y])
+			parent[y] = x;
+		else // If rnk[x] <= rnk[y]
+			parent[x] = y;
+
+		if (rnk[x] == rnk[y])
+			rnk[y]++;
+	}
+};
+
+/* Functions returns weight of the MST*/
+
+int Graph::kruskalMST()
+{
+	int mst_wt = 0; // Initialize result
+
+	// Sort edges in increasing order on basis of cost
+	sort(edges.begin(), edges.end());
+
+	// Create disjoint sets
+	DisjointSets ds(V);
+
+	// Iterate through all sorted edges
+	vector< pair<int, iPair> >::iterator it;
+	for (it=edges.begin(); it!=edges.end(); it++)
+	{
+		int u = it->second.first;
+		int v = it->second.second;
+
+		int set_u = ds.find(u);
+		int set_v = ds.find(v);
+
+		// Check if the selected edge is creating
+		// a cycle or not (Cycle is created if u
+		// and v belong to same set)
+		if (set_u != set_v)
+		{
+			// Current edge will be in the MST
+			// so print it
+			cout << u << " - " << v << endl;
+
+			// Update MST weight
+			mst_wt += it->first;
+
+			// Merge two sets
+			ds.merge(set_u, set_v);
+		}
+	}
+
+	return mst_wt;
+}
+
+// Driver program to test above functions
+int main()
+{
+	/* Let us create above shown weighted
+	and unidrected graph */
+	int V = 9, E = 14;
+	Graph g(V, E);
+
+	// making above shown graph
+	g.addEdge(0, 1, 4);
+	g.addEdge(0, 7, 8);
+	g.addEdge(1, 2, 8);
+	g.addEdge(1, 7, 11);
+	g.addEdge(2, 3, 7);
+	g.addEdge(2, 8, 2);
+	g.addEdge(2, 5, 4);
+	g.addEdge(3, 4, 9);
+	g.addEdge(3, 5, 14);
+	g.addEdge(4, 5, 10);
+	g.addEdge(5, 6, 2);
+	g.addEdge(6, 7, 1);
+	g.addEdge(6, 8, 6);
+	g.addEdge(7, 8, 7);
+
+	cout << "Edges of MST are \n";
+	int mst_wt = g.kruskalMST();
+
+	cout << "\nWeight of MST is " << mst_wt;
+
+	return 0;
+}
diff --git a/kruskal.cpp b/kruskal.cpp
new file mode 100644
index 00000000..e6069fc2
--- /dev/null
+++ b/kruskal.cpp
@@ -0,0 +1,68 @@
+#include <iostream>
+#include <tuple>
+#include <queue>
+using namespace std;
+int link[5000];
+int size[5000];
+int fun(int k)
+{
+    while(k!=link[k])
+    {
+        k=link[k];
+    } return k;
+}
+int main()
+{
+    priority_queue<tuple<int,int,int> > q;
+    tuple<int,int,int> t;
+    int N; int M;
+    cin>>N>>M;
+    int x; int y; int z;
+    for(int i=0; i<M; i++)
+    {
+        cin>>x>>y>>z;
+        q.push(make_tuple(-z,x,y));
+    }
+    
+    for(int i=0; i<N+1; i++)
+    {
+        link[i]=i;
+        size[i]=1;
+    }
+    int aa;
+    int bb;
+    int result=0;
+    while(!q.empty())
+    {
+        t=q.top(); q.pop();
+        x=abs(get<0>(t));
+        y=get<1>(t);
+        z=get<2>(t);
+        aa=fun(y);
+        bb=fun(z);
+        if(aa==bb)
+        {
+            continue;
+        }
+        else if(size[aa]>size[bb])
+        {
+            link[bb]=aa;
+        }   
+        else if(size[bb]>size[aa])
+        {
+            link[aa]=bb;
+        }
+        else if(size[bb]==size[aa])
+        {
+            if(aa>bb)
+            {
+                link[bb]=aa;
+            }
+            else if(aa<bb)
+            {
+                link[aa]=bb;
+            }
+        } result+=x;
+    } cout<<result;
+}
+
diff --git a/kth-largestElement/C++ program/kthLargestElement.cpp b/kth-largestElement/C++ program/kthLargestElement.cpp
new file mode 100644
index 00000000..c6ad6921
--- /dev/null
+++ b/kth-largestElement/C++ program/kthLargestElement.cpp	
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+using namespace std;
+ 
+// Function to find the k'th largest element in an array using min-heap
+int findKthLargest(vector<int> const &arr, int k)
+{
+    
+    if (arr.size() < k) {
+        exit(-1);
+    }
+ 
+   
+
+    priority_queue<int, vector<int>, greater<int>> pq(arr.begin(), arr.begin() + k);
+ 
+    // do for remaining array elements
+    for (int i = k; i < arr.size(); i++)
+    {
+        // if the current element is more than the root of the heap
+        if (arr[i] > pq.top())
+        {
+            // Replace root with the current element
+            pq.pop();
+            pq.push(arr[i]);
+        }
+    }
+ 
+   
+    return pq.top();
+}
+ 
+int main()
+{
+    vector<int> arr = { 7, 4, 6, 3, 9, 1 };
+    int k = 2;
+ 
+    cout << "k'th largest array element is " << findKthLargest(arr, k);
+ 
+    return 0;
+}
diff --git a/leap year b/leap year
new file mode 100644
index 00000000..c801fd20
--- /dev/null
+++ b/leap year	
@@ -0,0 +1,24 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+    int year;
+
+    cout << "Enter a year: ";
+    cin >> year;
+
+    if (year % 4 == 0) {
+        if (year % 100 == 0) {
+            if (year % 400 == 0)
+                cout << year << " is a leap year.";
+            else
+                cout << year << " is not a leap year.";
+        }
+        else
+            cout << year << " is a leap year.";
+    }
+    else
+        cout << year << " is not a leap year.";
+
+    return 0;
+}
diff --git a/leap year or not.cpp b/leap year or not.cpp
new file mode 100644
index 00000000..17a4d660
--- /dev/null
+++ b/leap year or not.cpp	
@@ -0,0 +1,18 @@
+
+
+#include<iostream>
+using namespace std;
+int main()
+{
+    int yr;
+    cout<<"Enter the Year: ";
+    cin>>yr;
+    if((yr%4==0) && (yr%100!=0))
+        cout<<"\nIt is a Leap Year";
+    else if(yr%400==0)
+        cout<<"\nIt is a Leap Year";
+    else
+        cout<<"\nIt is not a Leap Year";
+    cout<<endl;
+    return 0;
+}
diff --git a/leetcode_interview_questions/Copy_List_with_Random_Pointer b/leetcode_interview_questions/Copy_List_with_Random_Pointer
new file mode 100644
index 00000000..e34abad7
--- /dev/null
+++ b/leetcode_interview_questions/Copy_List_with_Random_Pointer
@@ -0,0 +1,48 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+    
+    Node(int _val) {
+        val = _val;
+        next = NULL;
+        random = NULL;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* copyRandomList(Node* head) {
+        if(head==NULL)return head;
+    Node *h1=NULL,*tail=head,*t1=NULL;
+	while(tail){
+		Node *temp=new Node(tail->val);
+		temp->next=tail->next;
+		tail->next=temp;
+		tail=temp->next;
+	}       
+	tail=head;
+	t1=head->next;
+	h1=head->next;
+	while(tail){
+		if(tail->random!=NULL){
+			t1->random=tail->random->next;
+		}
+		tail=t1->next;
+		if(tail)
+		t1=tail->next;
+	}
+	t1=head->next,tail=head;
+	while(tail && t1){
+		tail->next=(tail->next)?tail->next->next:tail->next;
+                tail=tail->next;
+		t1->next=(t1->next)?t1->next->next:t1->next;
+		t1=t1->next;
+	}
+	return h1;
+    }    
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Course_Schedule_II b/leetcode_interview_questions/Course_Schedule_II
new file mode 100644
index 00000000..d5e05a1d
--- /dev/null
+++ b/leetcode_interview_questions/Course_Schedule_II
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
+        vector<int>ans;
+        int vis[numCourses];
+        memset(vis,0,sizeof(vis));
+        vector<vector<int>>adj(numCourses);
+        for(int i=0;i<prerequisites.size();i++){
+            adj[prerequisites[i][1]].push_back(prerequisites[i][0]);
+            vis[prerequisites[i][0]]++;
+        }
+        queue<int>q;
+        for(int i=0;i<numCourses;i++){
+            if(vis[i] == 0)q.push(i);
+        }
+        while(!q.empty()){
+            int temp = q.front();
+            ans.push_back(temp);
+            q.pop();
+            for(auto &i:adj[temp]){
+                vis[i]--;
+                if(vis[i] == 0)q.push(i);
+            }
+        }
+        if(ans.size() != numCourses) return {};
+        else
+            return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Friend_Circles b/leetcode_interview_questions/Friend_Circles
new file mode 100644
index 00000000..33cc42b7
--- /dev/null
+++ b/leetcode_interview_questions/Friend_Circles
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int par[209];
+    int find(int x){
+        if(par[x] == x)return x;
+        else return par[x] = find(par[x]);
+    }
+    void unionFind(int a, int b){
+        a = find(a);
+        b = find(b);
+        if(a==b)return;
+        par[a] = b;
+       
+    }
+    int findCircleNum(vector<vector<int>>& isConnected) {
+        int n = isConnected.size();
+        for(int i=0;i<=n;i++){
+            par[i] = i; 
+        }   
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n;j++){
+                if(isConnected[i][j]){
+                    unionFind(i+1,j+1);
+                }
+            }
+        }
+        int ans=0;
+        for(int i=1;i<=n;i++){
+           
+            if(par[i] == i)ans++;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Game_of_Life b/leetcode_interview_questions/Game_of_Life
new file mode 100644
index 00000000..f9515dfa
--- /dev/null
+++ b/leetcode_interview_questions/Game_of_Life
@@ -0,0 +1,40 @@
+class Solution {
+public:
+    int x[8]={-1,-1,-1,1,1,1,0,0};
+    int y[8]={1,0,-1,-1,1,0,-1,1};
+    void dfs(vector<vector<int>>& board, int i ,int j){
+        int c=0,n=board.size(),m=board[0].size();
+        for(int k=0;k<8;k++){
+            int a=x[k]+i;
+            int b=y[k]+j;
+            
+            if(a>=n || a<0 || b>=m|| b<0)continue;
+            if(a==i && b==j)continue;
+            if(board[a][b]==1 || board[a][b]==-1)c++;
+        }
+       
+        if(board[i][j]==1){
+            if(c<2 || c>3)board[i][j]=-1;
+            
+        }
+        else{
+            if(c==3)board[i][j]=2;
+        }
+    }
+    void gameOfLife(vector<vector<int>>& board) {
+        int n=board.size();
+        if(n==0)return ;
+        int m=board[0].size();
+        for(int i=0;i<n;i++){
+            for(int j=0;j<m;j++){
+                dfs(board,i,j);
+            }
+        }
+        for(int i=0;i<n;i++){
+            for(int j=0;j<m;j++){
+                if(board[i][j]==-1)board[i][j]=0;
+                if(board[i][j]==2)board[i][j]=1;
+            }
+        }
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Longest_Consecutive_Sequence b/leetcode_interview_questions/Longest_Consecutive_Sequence
new file mode 100644
index 00000000..535dfa68
--- /dev/null
+++ b/leetcode_interview_questions/Longest_Consecutive_Sequence
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        unordered_set<int>st;
+        for(auto &i:nums){
+            st.insert(i);
+        }
+        int ans = 0;
+        for(auto &i:nums){
+            if(st.find(i-1)!=st.end())continue;
+            else{
+                int c=0;
+                int num = i;
+                while(st.find(num)!=st.end()){
+                    c++;
+                    num = num+1;
+                }
+                ans = max(ans, c);
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Longest_Increasing_Path_in_a_Matrix b/leetcode_interview_questions/Longest_Increasing_Path_in_a_Matrix
new file mode 100644
index 00000000..4858b3e6
--- /dev/null
+++ b/leetcode_interview_questions/Longest_Increasing_Path_in_a_Matrix
@@ -0,0 +1,43 @@
+class Solution {
+public:
+    int x[4]={1,-1,0,0};
+    int y[4]={0,0,1,-1};
+    int dp[1009][1009];
+int solve(vector<vector<int>>&matrix,int i,int j,int n,int m){
+        int ans=0;
+    if(dp[i][j]!=-1)return dp[i][j];
+       for(int k=0;k<4;k++){
+           int a=x[k]+i;
+           int b=y[k]+j;
+            if(a>=n || a<0 || b>=m || b<0)continue;
+            if( matrix[a][b]>matrix[i][j])
+            {   int temp;
+                 if(dp[a][b]!=-1)temp=dp[a][b];
+                else
+                temp=solve(matrix,a,b,n,m);
+               ans=max(ans,temp);
+            }
+       }
+    dp[i][j]=ans+1;
+    return dp[i][j];
+    }
+    int longestIncreasingPath(vector<vector<int>>& matrix) {
+        int n=matrix.size();
+        if(n==0)return 0;
+        int m=matrix[0].size();
+        for(int i=0;i<1009;i++){
+            for(int j=0;j<1009;j++)dp[i][j]=-1;
+        }
+        int ans=0;
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {   
+                int res=0;
+               res=solve(matrix,i,j,n,m);
+                ans=max(ans,res);
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Lowest_Common_Ancestor_of_a_Binary_Tree b/leetcode_interview_questions/Lowest_Common_Ancestor_of_a_Binary_Tree
new file mode 100644
index 00000000..638b1116
--- /dev/null
+++ b/leetcode_interview_questions/Lowest_Common_Ancestor_of_a_Binary_Tree
@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        if(root == NULL || root == p || root == q)
+            return root;
+        TreeNode* left = lowestCommonAncestor(root->left , p,q);
+        TreeNode* right =lowestCommonAncestor(root->right , p,q);
+        if(left && right)return root;
+        if(!left)
+            return right;
+        return left;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Product_of_Array_Except_Self b/leetcode_interview_questions/Product_of_Array_Except_Self
new file mode 100644
index 00000000..82663b61
--- /dev/null
+++ b/leetcode_interview_questions/Product_of_Array_Except_Self
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int n= nums.size();if(n==0)return {};
+        vector<int>ans(n);
+        ans[0]=1;
+        for(int i=1;i<n;i++){
+            ans[i]=ans[i-1]*nums[i-1];
+        }
+        int pro=1;
+        for(int i=n-1;i>=0;i--){
+            ans[i]=ans[i]*pro;
+            pro=pro*nums[i];
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Sliding_Window_Maximum b/leetcode_interview_questions/Sliding_Window_Maximum
new file mode 100644
index 00000000..7ce1567e
--- /dev/null
+++ b/leetcode_interview_questions/Sliding_Window_Maximum
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        deque<int>dq;
+        int n=nums.size();
+        for(int i=0;i<k;i++){
+            while(!dq.empty() && nums[dq.back()]<nums[i])
+                dq.pop_back();
+            dq.push_back(i);
+        }
+        vector<int>ans;
+        for(int i=k;i<n;i++){
+            ans.push_back(nums[dq.front()]);
+            while(!dq.empty() && dq.front()<=i-k)
+                dq.pop_front();
+            while(!dq.empty() && nums[dq.back()]<nums[i])
+                dq.pop_back();
+            dq.push_back(i);
+        }
+        ans.push_back(nums[dq.front()]);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/leetcode_interview_questions/Surrounded_Regions b/leetcode_interview_questions/Surrounded_Regions
new file mode 100644
index 00000000..8b85defa
--- /dev/null
+++ b/leetcode_interview_questions/Surrounded_Regions
@@ -0,0 +1,43 @@
+class Solution {
+public:
+    int x[4]={0,0,-1,1};
+    int y[4]={1,-1,0,0};
+    void dfs(vector<vector<char>>& board,vector<vector<bool>>& visited,int i,int j,int n,int m)
+    {   cout<<i<<" "<<j<<"\n";
+        visited[i][j]=true;
+        board[i][j]='A';
+        for(int k=0;k<4;k++){
+            int a=i+x[k];
+            int b=j+y[k];
+             if(a>=n || a<0 || b>=m ||b<0)continue;
+            if(board[a][b]=='O' || board[a][b]=='A' && !visited[a][b])
+            {
+                board[a][b]='A';
+               
+                dfs(board,visited,a,b,n,m);
+            }
+        }
+    }
+    void solve(vector<vector<char>>& board) {
+        int n=board.size();
+        if(n==0)return;
+        int m=board[0].size();
+        vector<vector<bool>>visited(n,vector<bool>(m,false));
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if((i==0 || j==0|| i==n-1 || j==m-1) && board[i][j]=='O')
+                    dfs(board,visited,i,j,n,m);
+            }
+        }
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if(board[i][j]=='A')board[i][j]='O';
+                else board[i][j]='X';
+            }
+        }
+    }
+};
\ No newline at end of file
diff --git a/lexicographic_ranking.cpp b/lexicographic_ranking.cpp
new file mode 100644
index 00000000..06aee17c
--- /dev/null
+++ b/lexicographic_ranking.cpp
@@ -0,0 +1,64 @@
+//
+// Lexicographic ranking algorithm Implementation
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/strings
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Tushar Kanakagiri
+// Github: @tusharkanakagiri
+//
+#include <stdio.h>
+#include <string.h>
+
+// A utility function to find factorial of n
+int fact(int n)
+{
+    return (n <= 1) ? 1 : n * fact(n - 1);
+}
+
+// A utility function to count smaller characters on right
+// of arr[low]
+int findSmallerInRight(char *str, int low, int high)
+{
+    int countRight = 0, i;
+
+    for (i = low + 1; i <= high; ++i)
+        if (str[i] < str[low])
+            ++countRight;
+
+    return countRight;
+}
+
+// A function to find rank of a string in all permutations
+// of characters
+int findRank(char *str)
+{
+    int len = strlen(str);
+    int mul = fact(len);
+    int rank = 1;
+    int countRight;
+
+    int i;
+    for (i = 0; i < len; ++i)
+    {
+        mul /= len - i;
+
+        // count number of chars smaller than str[i]
+        // fron str[i+1] to str[len-1]
+        countRight = findSmallerInRight(str, i, len - 1);
+
+        rank += countRight * mul;
+    }
+
+    return rank;
+}
+
+// Driver program to test above function
+int main()
+{
+    char str[] = ""; //Enter string here
+    printf("%d", findRank(str));
+    return 0;
+}
diff --git a/lexicographically_kth_ smallest_suffix.cpp b/lexicographically_kth_ smallest_suffix.cpp
new file mode 100644
index 00000000..867cb24c
--- /dev/null
+++ b/lexicographically_kth_ smallest_suffix.cpp	
@@ -0,0 +1,22 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define ll long long
+
+//Print the lexicographically kth smallest suffix of the string S.
+
+int main()
+{
+    ll int i,j,k;
+    string s;
+    cin>>s>>k;
+    string s1[s.size()];
+    for(i=0;i<s.size();i++){                   //Storing all possibe suffix strings in s1
+        for(j=i;j<s.size();j++){
+            s1[i]+=s[j];
+        }
+    }
+    
+    sort(s1,s1+(s.size()));
+    cout<<s1[k-1]<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/linear_search.cpp b/linear_search.cpp
new file mode 100644
index 00000000..3ecdc39f
--- /dev/null
+++ b/linear_search.cpp
@@ -0,0 +1,30 @@
+// C++ code to linearly search x in arr[]. If x
+// is present then return its location, otherwise
+// return -1
+
+#include <iostream>
+using namespace std;
+
+int search(int arr[], int n, int x)
+{
+	int i;
+	for (i = 0; i < n; i++)
+		if (arr[i] == x)
+			return i;
+	return -1;
+}
+
+// Driver code
+int main(void)
+{
+	int arr[] = { 2, 3, 4, 10, 40 };
+	int x = 10;
+	int n = sizeof(arr) / sizeof(arr[0]);
+
+	// Function call
+	int result = search(arr, n, x);
+	(result == -1)
+		? cout << "Element is not present in array"
+		: cout << "Element is present at index " << result;
+	return 0;
+}
diff --git a/linklistpallindrome.cpp b/linklistpallindrome.cpp
new file mode 100644
index 00000000..fb75f312
--- /dev/null
+++ b/linklistpallindrome.cpp
@@ -0,0 +1,85 @@
+#include<bits/stdc++.h>
+using namespace std;
+class node
+{
+    public:
+    int data;
+    node* next;
+    node(){}
+    node(int val)
+    {
+        data=val;
+        next=NULL;
+    }
+};
+node* insertlist(node* head)
+{
+    int c=1,i=1,val;node* temp=head;
+    while(c!=0)
+    {
+        cout<<"ENTER DATA OF NODE "<<i<<" : ";
+        cin>>val;
+        node *newnode=new node(val);
+        temp->next=newnode;
+        temp=newnode;
+        cout<<"ENTER 1 IF YOU WANT MORE NODES ELSE 0: ";
+        cin>>c;
+        i++;
+    }
+    head=head->next;
+    return head;
+}
+node* reverselist(node* head,node* newlist)
+{
+    node* temp=head->next;node* prev=head;
+    while(temp!=NULL)
+    {
+        node* head2=new node();
+        head2->data=prev->data;
+        head2->next=newlist;
+        newlist=head2;
+        prev=temp;
+        temp=temp->next; 
+    }
+    node* head2=new node();
+    head2->data=prev->data;
+    head2->next=newlist;
+    newlist=head2;
+    return newlist;
+}
+void printlist(node* head)
+{
+    node* temp=head;
+    while(temp->next!=NULL)
+    {
+        cout<<temp->data<<"->";
+        temp=temp->next;
+    }
+    cout<<temp->data;
+}
+void pallindromecheck(node* head,node* newlist)
+{
+    node* temp=head;node* temp2=newlist;int c=0;
+    while(temp!=NULL&&c==0)
+    {
+        if(temp->data!=temp2->data)
+        {
+            c++;
+        }
+        temp=temp->next;
+        temp2=temp2->next;
+    }
+    if(c==0)
+    cout<<"THE NUMBER IS PALLINDROME";
+    else
+    cout<<"THE NUMBER IS NOT PALLINDROME";
+}
+int main()
+{
+    node* newlist=NULL;
+    node *head=new node(0);
+    head=insertlist(head);
+    newlist=reverselist(head,newlist);
+    //printlist(head);
+    pallindromecheck(head,newlist);
+}
diff --git a/ll_deletion.cpp b/ll_deletion.cpp
new file mode 100644
index 00000000..03cc3754
--- /dev/null
+++ b/ll_deletion.cpp
@@ -0,0 +1,104 @@
+// A complete working C++ program to
+// demonstrate deletion in singly
+// linked list with class
+#include <bits/stdc++.h>
+using namespace std;
+
+// A linked list node
+class Node{
+public:
+	int data;
+	Node* next;
+};
+
+// Given a reference (pointer to pointer)
+// to the head of a list and an int,
+// inserts a new node on the front of the
+// list.
+void push(Node** head_ref, int new_data)
+{
+	Node* new_node = new Node();
+	new_node->data = new_data;
+	new_node->next = (*head_ref);
+	(*head_ref) = new_node;
+}
+
+// Given a reference (pointer to pointer)
+// to the head of a list and a key, deletes
+// the first occurrence of key in linked list
+void deleteNode(Node** head_ref, int key)
+{
+	
+	// Store head node
+	Node* temp = *head_ref;
+	Node* prev = NULL;
+	
+	// If head node itself holds
+	// the key to be deleted
+	if (temp != NULL && temp->data == key)
+	{
+		*head_ref = temp->next; // Changed head
+		delete temp;		 // free old head
+		return;
+	}
+
+	// Else Search for the key to be deleted,
+	// keep track of the previous node as we
+	// need to change 'prev->next' */
+	else
+	{
+	while (temp != NULL && temp->data != key)
+	{
+		prev = temp;
+		temp = temp->next;
+	}
+
+	// If key was not present in linked list
+	if (temp == NULL)
+		return;
+
+	// Unlink the node from linked list
+	prev->next = temp->next;
+
+	// Free memory
+	delete temp;
+	}
+}
+
+// This function prints contents of
+// linked list starting from the
+// given node
+void printList(Node* node)
+{
+	while (node != NULL)
+	{
+		cout << node->data << " ";
+		node = node->next;
+	}
+}
+
+// Driver code
+int main()
+{
+	
+	// Start with the empty list
+	Node* head = NULL;
+
+	// Add elements in linked list
+	push(&head, 7);
+	push(&head, 1);
+	push(&head, 3);
+	push(&head, 2);
+
+	puts("Created Linked List: ");
+	printList(head);
+
+	deleteNode(&head, 1);
+	puts("\nLinked List after Deletion of 1: ");
+	
+	printList(head);
+	
+	return 0;
+}
+
+// This code is contributed by pathakvsp1
diff --git a/lucas theorem b/lucas theorem
new file mode 100644
index 00000000..ab50f9b9
--- /dev/null
+++ b/lucas theorem	
@@ -0,0 +1,57 @@
+// A Lucas Theorem based solution to compute nCr % p
+#include<bits/stdc++.h>
+using namespace std;
+
+// Returns nCr % p. In this Lucas Theorem based program,
+// this function is only called for n < p and r < p.
+int nCrModpDP(int n, int r, int p)
+{
+	// The array C is going to store last row of
+	// pascal triangle at the end. And last entry
+	// of last row is nCr
+	int C[r+1];
+	memset(C, 0, sizeof(C));
+
+	C[0] = 1; // Top row of Pascal Triangle
+
+	// One by constructs remaining rows of Pascal
+	// Triangle from top to bottom
+	for (int i = 1; i <= n; i++)
+	{
+		// Fill entries of current row using previous
+		// row values
+		for (int j = min(i, r); j > 0; j--)
+
+			// nCj = (n-1)Cj + (n-1)C(j-1);
+			C[j] = (C[j] + C[j-1])%p;
+	}
+	return C[r];
+}
+
+// Lucas Theorem based function that returns nCr % p
+// This function works like decimal to binary conversion
+// recursive function. First we compute last digits of
+// n and r in base p, then recur for remaining digits
+int nCrModpLucas(int n, int r, int p)
+{
+// Base case
+if (r==0)
+	return 1;
+
+// Compute last digits of n and r in base p
+int ni = n%p, ri = r%p;
+
+// Compute result for last digits computed above, and
+// for remaining digits. Multiply the two results and
+// compute the result of multiplication in modulo p.
+return (nCrModpLucas(n/p, r/p, p) * // Last digits of n and r
+		nCrModpDP(ni, ri, p)) % p; // Remaining digits
+}
+
+// Driver program
+int main()
+{
+	int n = 1000, r = 900, p = 13;
+	cout << "Value of nCr % p is " << nCrModpLucas(n, r, p);
+	return 0;
+}
diff --git a/magic_date.cpp b/magic_date.cpp
new file mode 100644
index 00000000..eb492c24
--- /dev/null
+++ b/magic_date.cpp
@@ -0,0 +1,19 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+ 
+int month,day,year;
+cout<<"Enter Month Number :";
+    cin>>month;
+cout<<"Enter day number :";
+    cin>>day;
+cout<<"Enter last two digits of Year :";
+    cin>>year;
+ 
+if(month*day==year)
+    cout<<"This Date is a Magic Date.";
+else
+    cout<<"This date is not a Magic Date.";
+return 0;
+}
diff --git a/merge_sort.cpp b/merge_sort.cpp
new file mode 100644
index 00000000..fe0f8d8e
--- /dev/null
+++ b/merge_sort.cpp
@@ -0,0 +1,85 @@
+//merge sort//
+#include <iostream>
+using namespace std;
+void merge(int a[], int n, int lb, int mid, int ub)
+{
+    int i = lb;
+    int j = mid + 1;
+    int k = lb;
+    int temp[n];
+    while (i <= mid && j <= ub)
+    {
+        if (a[i] <= a[j])
+        {
+            temp[k] = a[i];
+            i++;
+        }
+        else
+        {
+            temp[k] = a[j];
+            j++;
+        }
+        k++;
+    }
+    if (i > mid)
+    {
+        while (j <= ub)
+        {
+
+            temp[k] = a[j];
+            j++;
+            k++;
+        }
+    }
+    else
+    {
+        while (i <= mid)
+        {
+
+            temp[k] = a[i];
+            i++;
+            k++;
+        }
+    }
+    for (int k = lb; k <= ub; k++)
+    {
+        a[k] = temp[k];
+    }
+}
+void mergesort(int a[], int n, int lb, int ub)
+{
+    if (lb < ub)
+    {
+
+        int mid = (lb + ub) / 2;
+        mergesort(a, n, lb, mid);
+        mergesort(a, n, mid + 1, ub);
+        merge(a, n, lb, mid, ub);
+    }
+    else
+        return;
+}
+int main()
+{
+    int n;
+    cout << "ENTER THE SIZE OF AN ARRAY" << endl;
+    cin >> n;
+    int a[n];
+    for (int i = 0; i < n; i++)
+    {
+        cin >> a[i];
+    }
+    cout << "DISPLAYING ORIGINAL ARRAY" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " " << endl;
+    }
+    mergesort(a, n, 0, n - 1);
+    cout << "DISPLAYING SORTED  ARRAY" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " " << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/merge_twosortedll.cpp b/merge_twosortedll.cpp
new file mode 100644
index 00000000..0a56d994
--- /dev/null
+++ b/merge_twosortedll.cpp
@@ -0,0 +1,122 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node *next;
+    node(int data)
+    {
+        this->data = data;
+        next = NULL;
+    }
+};
+node *takeinput_better()
+{
+    int data;
+
+    cin >> data;
+    node *head = NULL;
+    node *tail = NULL;
+
+    while (data != -1)
+    {
+        node *newnode = new node(data);
+        if (head == NULL)
+        {
+            head = newnode;
+            tail = newnode;
+        }
+        else
+        {
+            tail->next = newnode;
+            tail = tail->next;
+        }
+
+        cin >> data;
+    }
+    return head;
+}
+node *merge_twosortedlist(node *x, node *y)
+{
+    node *finalhead = NULL;
+    node *finaltail = NULL;
+   
+    if (x->data < y->data)
+    {
+        finalhead = x;
+        finaltail = x;
+        x = x->next;
+        while (x != NULL && y != NULL)
+        {
+            if (x->data > y->data)
+            {
+                finaltail->next = y;
+                finaltail = finaltail->next;
+
+                y = y->next;
+            }
+            else
+            {
+                finaltail->next = x;
+                finaltail = finaltail->next;
+                x = x->next;
+            }
+        }
+       
+    }
+   
+    else if (x->data > y->data)
+    {
+        finalhead = y;
+        finaltail = y;
+        y = y->next;
+        while (x != NULL && y != NULL)
+        {
+            if (x->data > y->data)
+            {
+                finaltail->next = y;
+                finaltail = finaltail->next;
+
+                y = y->next;
+            }
+            else
+            {
+                finaltail->next = x;
+                finaltail = finaltail->next;
+
+                x = x->next;
+            }
+        }
+    }
+    
+
+    if (y == NULL)
+    {
+        finaltail->next = x;
+    }
+    else
+    {
+        finaltail->next = y;
+    }
+    return finalhead;
+}
+void print(node *head)
+{
+    while (head != NULL)
+    {
+        cout << head->data << " ";
+        head = head->next;
+    }
+}
+int main()
+{
+    node *x = takeinput_better();
+    print(x);
+    cout<<endl;
+    node *y = takeinput_better();
+    print(y);
+    cout<<endl;
+    node *z = merge_twosortedlist(x, y);
+    print(z);
+}
\ No newline at end of file
diff --git a/mergesort.cpp b/mergesort.cpp
new file mode 100644
index 00000000..fe0f8d8e
--- /dev/null
+++ b/mergesort.cpp
@@ -0,0 +1,85 @@
+//merge sort//
+#include <iostream>
+using namespace std;
+void merge(int a[], int n, int lb, int mid, int ub)
+{
+    int i = lb;
+    int j = mid + 1;
+    int k = lb;
+    int temp[n];
+    while (i <= mid && j <= ub)
+    {
+        if (a[i] <= a[j])
+        {
+            temp[k] = a[i];
+            i++;
+        }
+        else
+        {
+            temp[k] = a[j];
+            j++;
+        }
+        k++;
+    }
+    if (i > mid)
+    {
+        while (j <= ub)
+        {
+
+            temp[k] = a[j];
+            j++;
+            k++;
+        }
+    }
+    else
+    {
+        while (i <= mid)
+        {
+
+            temp[k] = a[i];
+            i++;
+            k++;
+        }
+    }
+    for (int k = lb; k <= ub; k++)
+    {
+        a[k] = temp[k];
+    }
+}
+void mergesort(int a[], int n, int lb, int ub)
+{
+    if (lb < ub)
+    {
+
+        int mid = (lb + ub) / 2;
+        mergesort(a, n, lb, mid);
+        mergesort(a, n, mid + 1, ub);
+        merge(a, n, lb, mid, ub);
+    }
+    else
+        return;
+}
+int main()
+{
+    int n;
+    cout << "ENTER THE SIZE OF AN ARRAY" << endl;
+    cin >> n;
+    int a[n];
+    for (int i = 0; i < n; i++)
+    {
+        cin >> a[i];
+    }
+    cout << "DISPLAYING ORIGINAL ARRAY" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " " << endl;
+    }
+    mergesort(a, n, 0, n - 1);
+    cout << "DISPLAYING SORTED  ARRAY" << endl;
+    for (int i = 0; i < n; i++)
+    {
+        cout << a[i] << " " << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/multiply 2 numbers in java b/multiply 2 numbers in java
new file mode 100644
index 00000000..1a875535
--- /dev/null
+++ b/multiply 2 numbers in java	
@@ -0,0 +1,22 @@
+public class MatrixMultiplicationExample{  
+public static void main(String args[]){  
+//creating two matrices    
+int a[][]={{1,1,1},{2,2,2},{3,3,3}};    
+int b[][]={{1,1,1},{2,2,2},{3,3,3}};    
+    
+//creating another matrix to store the multiplication of two matrices    
+int c[][]=new int[3][3];  //3 rows and 3 columns  
+    
+//multiplying and printing multiplication of 2 matrices    
+for(int i=0;i<3;i++){    
+for(int j=0;j<3;j++){    
+c[i][j]=0;      
+for(int k=0;k<3;k++)      
+{      
+c[i][j]+=a[i][k]*b[k][j];      
+}//end of k loop  
+System.out.print(c[i][j]+" ");  //printing matrix element  
+}//end of j loop  
+System.out.println();//new line    
+}    
+}}  
diff --git a/multiply_two_matrices.cpp b/multiply_two_matrices.cpp
new file mode 100644
index 00000000..7c2e0880
--- /dev/null
+++ b/multiply_two_matrices.cpp
@@ -0,0 +1,242 @@
+# include <iostream.h>
+# include <stdlib.h>
+# include <conio.h>
+
+ 
+
+ class Matrix
+ {
+    private:
+       float matrix_a[3][3];
+       float matrix_b[3][3];
+       float matrix_c[3][3];
+
+    public:
+       Matrix( );
+
+       void get_matrix_a( );
+       void get_matrix_b( );
+       void multiply_matrices( );
+       void show_result_Matrix( );
+ };
+
+ 
+
+
+ Matrix::Matrix( )
+ {
+    for(int i=0;i<3;i++)
+    {
+       for(int j=0;j<3;j++)
+       {
+	  matrix_a[i][j]=0;
+	  matrix_b[i][j]=0;
+	  matrix_c[i][j]=0;
+       }
+    }
+
+    gotoxy(1,1);
+    cout<<"*********************************************"<<endl;
+    cout<<" * * * * * * * * * * * * * *  Matrix  Multiplication  * * * * ** * * * * * * *"<<endl;
+    cout<<"********************************************"<<endl;
+
+    gotoxy(1,25);
+    cout<<"*****************************************************";
+ }
+
+
+
+ void Matrix::get_matrix_a( )
+ {
+    gotoxy(1,6);
+    cout<<" Enter the values of the Matrix A row by row :
+ "<<endl;
+
+    cout<<"			 Ú               ¿"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 À               Ù"<<endl;
+
+    gotoxy(18,10);
+    cout<<" A  = "<<endl;
+
+    int x=28;
+    int y=9;
+
+    for(int i=0;i<3;i++)
+    {
+       for(int j=0;j<3;j++)
+       {
+	  gotoxy(x,y);
+	  cin>>matrix_a[i][j];
+
+	  x+=5;
+       }
+
+       x=28;
+       y++;
+    }
+ }
+
+ 
+
+
+ void Matrix::get_matrix_b( )
+ {
+    gotoxy(1,15);
+    cout<<" Enter the values of the Matrix B row by row :
+ "<<endl;
+
+    cout<<"			 Ú               ¿"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 À               Ù"<<endl;
+
+    gotoxy(18,19);
+    cout<<" B  = "<<endl;
+
+    int x=28;
+    int y=18;
+
+    for(int i=0;i<3;i++)
+    {
+       for(int j=0;j<3;j++)
+       {
+	  gotoxy(x,y);
+	  cin>>matrix_b[i][j];
+
+	  x+=5;
+       }
+
+       x=28;
+       y++;
+    }
+ }
+
+ 
+
+
+ void Matrix::multiply_matrices( )
+ {
+    for(int i=0;i<3;i++)
+    {
+       for(int j=0;j<3;j++)
+       {
+	  float value=0;
+	  float sum=0;
+
+	  for(int k=0;k<3;k++)
+	  {
+	     value=matrix_a[j][k]*matrix_b[k][j];
+	     sum+=value;
+	  }
+
+	  matrix_c[i][j]=sum;
+       }
+    }
+ }
+
+ 
+
+ void Matrix::show_result_Matrix( )
+ {
+    clrscr( );
+
+    gotoxy(1,1);
+    cout<<"*********************************************************"<<endl;
+    cout<<" * * * * * * * * * * * * * *  Matrix  Multiplication  * * * * ** * * * * * * *"<<endl;
+    cout<<"*************************************************************"<<endl;
+
+    gotoxy(1,6);
+    cout<<" The values of Matrix A and B are :"<<endl;
+
+    cout<<"		 Ú               ¿  	            Ú               
+¿"<<endl;
+    cout<<"		 ³               ³   	            ³               
+³"<<endl;
+    cout<<"		 ³               ³   	            ³               
+³"<<endl;
+    cout<<"		 ³               ³  	            ³               
+³"<<endl;
+    cout<<"		 À               Ù 		    À               Ù"<<endl;
+
+    gotoxy(45,9);
+    cout<<" B  = "<<endl;
+
+    gotoxy(10,9);
+    cout<<" A  = "<<endl;
+
+    gotoxy(1,15);
+    cout<<" The Product of Matrix A and B is :
+ "<<endl;
+
+    cout<<"			 Ú               ¿"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 ³               ³"<<endl;
+    cout<<"			 À               Ù"<<endl;
+
+    gotoxy(13,19);
+    cout<<" A * B  = "<<endl;
+
+    int x_1=20;
+    int y_1=8;
+
+    int x_2=55;
+    int y_2=8;
+
+    int x_3=28;
+    int y_3=18;
+
+    for(int i=0;i<3;i++)
+    {
+       for(int j=0;j<3;j++)
+       {
+	  gotoxy(x_1,y_1);
+	  cout<<matrix_a[i][j];
+
+	  gotoxy(x_2,y_2);
+	  cout<<matrix_b[i][j];
+
+	  gotoxy(x_3,y_3);
+	  cout<<matrix_c[i][j];
+
+	  x_1+=5;
+	  x_2+=5;
+	  x_3+=5;
+       }
+
+       x_1=20;
+       y_1++;
+
+       x_2=55;
+       y_2++;
+
+       x_3=28;
+       y_3++;
+    }
+
+    gotoxy(1,25);
+    cout<<"*********************************************";
+ }
+
+ 
+
+
+ int main( )
+ {
+    textmode(BW80);
+    clrscr( );
+
+    Matrix Obj;
+
+    Obj.get_matrix_a( );
+    Obj.get_matrix_b( );
+    Obj.multiply_matrices( );
+    Obj.show_result_Matrix( );
+
+    getch( );
+    return 0;
+ }
diff --git a/nextgreaterelementtorightusingstack.cpp b/nextgreaterelementtorightusingstack.cpp
new file mode 100644
index 00000000..86e509f4
--- /dev/null
+++ b/nextgreaterelementtorightusingstack.cpp
@@ -0,0 +1,49 @@
+//this is a program to find the next greater element for every array element(present in same array) via stack in O(n) time complexity.
+#include<bits/stdc++.h>
+using namespace std;
+int main()
+{
+    int n;
+    cout<<"ENTER SIZE OF ARRAY: ";
+    cin>>n;
+    int arr[n];
+    cout<<"ENTER ELEMENTS OF THE ARRAY: ";
+    for(int i=0;i<n;i++)
+    {
+        cin>>arr[i];
+    }
+    vector <int> v;
+    stack <int> s;
+    for(int i=n-1;i>=0;i--)
+    {
+        if(s.size()==0)
+        {
+            v.push_back(-1);
+        }
+        else if(s.size()>0&&s.top()>arr[i])
+        {
+            v.push_back(s.top());
+        }
+        else if(s.size()>0&&s.top()<=arr[i])
+        {
+            while(s.size()>0&&s.top()<=arr[i])
+            {
+                s.pop();
+            }
+            if(s.size()==0)
+            {
+                v.push_back(-1);
+            }
+            else
+            {
+                v.push_back(s.top());
+            }
+        }
+        s.push(arr[i]);
+    }
+    reverse(v.begin(),v.end());
+    for(int i=0;i<n;i++)
+    {
+        cout<<"THE NEXT GREATER ELEMENT FOR "<<arr[i]<<" IS: "<<v[i]<<endl;
+    }
+}
diff --git a/nextsmallerelement.cpp b/nextsmallerelement.cpp
new file mode 100644
index 00000000..3d846479
--- /dev/null
+++ b/nextsmallerelement.cpp
@@ -0,0 +1,64 @@
+//Problem Statement:
+// Given an array, print the Next Smaller Element (NSE) for every element.
+// The NSE for an element x is the first smaller element on the right side of x in array. 
+// Elements for which no smaller element exist (on right side), consider NSE as -1. 
+
+#include <bits/stdc++.h>
+using namespace std;
+ 
+// prints NSE for elements of array arr[] of size n
+ 
+void printNSE(int arr[], int n)
+{
+    stack<pair<int, int> > s;
+    vector<int> ans(n);
+ 
+    // iterate for rest of the elements
+    for (int i = 0; i < n; i++) {
+        int next = arr[i];
+ 
+        // if stack is empty then this element can't be NSE
+        // for any other element, so just push it to stack
+        // so that we can find NSE for it, and continue
+        if (s.empty()) {
+            s.push({ next, i });
+            continue;
+        }
+ 
+        // while stack is not empty and the top element is
+        // greater than next
+        //  a) NSE for top is next, use top's index to
+        //    maintain original order
+        //  b) pop the top element from stack
+ 
+        while (!s.empty() && s.top().first > next) {
+            ans[s.top().second] = next;
+            s.pop();
+        }
+ 
+        // push next to stack so that we can find NSE for it
+ 
+        s.push({ next, i });
+    }
+ 
+    // After iterating over the loop, the remaining elements
+    // in stack do not have any NSE, so set -1 for them
+ 
+    while (!s.empty()) {
+        ans[s.top().second] = -1;
+        s.pop();
+    }
+ 
+    for (int i = 0; i < n; i++) {
+        cout << arr[i] << " ---> " << ans[i] << endl;
+    }
+}
+ 
+// Driver program to test above functions
+int main()
+{
+    int arr[] = { 11, 13, 21, 3 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+    printNSE(arr, n);
+    return 0;
+}
diff --git a/optimizedbubblesort b/optimizedbubblesort
new file mode 100644
index 00000000..78581206
--- /dev/null
+++ b/optimizedbubblesort
@@ -0,0 +1,37 @@
+import java.util.Scanner;
+
+public class BubbleSortOptimized_007 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // int n = a.length;
+        System.out.println("Enter the No. of elements you want to sort : ");
+        int m = sc.nextInt();
+        int a[] = new int[m];
+        System.out.println("Enter the elements :");
+        for (int i = 0; i < m; i++) {
+            a[i] = sc.nextInt();
+        }
+
+        for (int i = 0; i < (m - 1); i++) {
+            boolean sorted = true;// if the elements are already sorted.
+
+            for (int j = 0; j < (m - 1 - i); j++) {// runs last,bit1,bit2...
+                if (a[j + 1] < a[j]) {
+                    int temp = a[j + 1];
+                    a[j + 1] = a[j];
+                    a[j] = temp;
+
+                    sorted = false;
+                }
+            }
+            if (sorted)
+                break;
+        }
+
+        for (int item : a) {
+            System.out.print(item + " ");
+        }
+        sc.close();
+    }
+}
diff --git a/painterpartitionproblem.cpp b/painterpartitionproblem.cpp
new file mode 100644
index 00000000..802807e4
--- /dev/null
+++ b/painterpartitionproblem.cpp
@@ -0,0 +1,72 @@
+//program to find the minimum number of painters required to paint given number of boards
+// complexity: O(log n)
+#include<bits/stdc++.h>
+using namespace std;
+bool isVALID(int *arr,int n,int k,int mid) // function to check validity i.e. checking if no. of painters are equal or not
+{
+    int painter=1;
+    int sum=0;
+    for(int i=0;i<n;i++)
+    {
+        sum=sum+arr[i];
+        if(sum>mid)
+        {
+            painter++;
+            sum=arr[i];
+        }
+        if(painter>k)
+        return false;
+    }
+    return true;
+}
+int maxinarray(int *arr,int n) //returns max element of array
+{
+    int max=arr[0];
+    for(int i=1;i<n;i++)
+    {
+        if(arr[i]>=max)
+        max=arr[i];
+    }
+    return max;
+}
+int sumofallarrayelements(int *arr,int n) //returns sum of all elements of array
+{
+    int sum=0;
+    for(int i=0;i<n;i++)
+    {
+        sum=sum+arr[i];
+    }
+    return sum;
+}
+int main()
+{
+    int n,k,ans;
+    cout<<"ENTER NUMBER OF BOARDS: ";
+    cin>>n;
+    cout<<"ENTER NUMBER OF PAINTERS: ";
+    cin>>k;
+    int arr[n];
+    for(int i=0;i<n;i++)
+    {
+        cout<<"ENTER LENGTH OF BOARD "<<i+1<<" : ";
+        cin>>arr[i];
+    }
+    if(k>n)
+    printf("PAINTING NOT POSSIBLE");
+    else
+    {
+        int start=maxinarray(arr,n),end=sumofallarrayelements(arr,n);
+        while(start<=end) //binary searching for finding the minimum possible number of painters
+        {
+            int mid=start+((end-start)/2);
+            if(isVALID(arr,n,k,mid))
+            {
+                ans=mid;
+                end=mid-1;
+            }
+            else
+            start=mid+1;
+        }
+        cout<<"THE MINIMUM TIME REQUIRED WILL BE: "<<ans<<"units";
+    } 
+}
diff --git a/palindrom.cpp b/palindrom.cpp
new file mode 100644
index 00000000..9d061683
--- /dev/null
+++ b/palindrom.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*10)+r;    
+ n=n/10;    
+}    
+if(temp==sum)    
+cout<<"Number is Palindrome.";    
+else    
+cout<<"Number is not Palindrome.";   
+  return 0;  
+}   
\ No newline at end of file
diff --git a/palindrome.cpp b/palindrome.cpp
new file mode 100644
index 00000000..df77f543
--- /dev/null
+++ b/palindrome.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+	// your code goes here
+	
+	int n,sum=0;
+	cin>>n;
+	int temp=n;
+	while(n>0){
+	    sum=(sum*10)+n%10;
+	    n=n/10;
+	}
+	if (sum==temp)
+	cout<<temp<<" is a Palindrome Number";
+	else
+	cout<<temp<<" is not a Palindrome";
+	return 0;
+}
diff --git a/palindrome.js b/palindrome.js
new file mode 100644
index 00000000..7bf6d25a
--- /dev/null
+++ b/palindrome.js
@@ -0,0 +1,12 @@
+function palindrome(str) {
+ var re = /[^A-Za-z0-9]/g;
+ str = str.toLowerCase().replace(re, '');
+ var len = str.length;
+ for (var i = 0; i < len/2; i++) {
+   if (str[i] !== str[len - 1 - i]) {
+       return false;
+   }
+ }
+ return true;
+}
+palindrome("A man, a plan, a canal. Panama");
diff --git a/peakElement.cpp b/peakElement.cpp
new file mode 100644
index 00000000..d0e518b0
--- /dev/null
+++ b/peakElement.cpp
@@ -0,0 +1,25 @@
+/*
+Find the peak element in the array using binary search
+*/
+
+#include <iostream>
+using namespace std;
+
+int myPeak(int arr[], int low, int high, int n){
+        int mid=low+(high-low)/2;
+        if((mid == 0 or arr[mid-1]<=arr[mid]) and (mid==n-1 or arr[mid+1]<=arr[mid])){
+            return mid;
+        }
+        else if(mid>0 and arr[mid-1]>arr[mid]){
+            return myPeak(arr, low, mid-1, n);
+        }
+        else{
+            return myPeak(arr, mid+1, high, n);
+        }
+}
+
+int main(){
+    int arr[]={1,2,3,4,3};
+    int n=5;
+    cout<<"Index of Peak Element: "<<myPeak(arr, 0, n-1, n);
+}
\ No newline at end of file
diff --git a/perfect_no.cpp b/perfect_no.cpp
new file mode 100644
index 00000000..51cf7a59
--- /dev/null
+++ b/perfect_no.cpp
@@ -0,0 +1,29 @@
+#include<iostream>
+
+using namespace std;
+
+int main()
+{
+	int number, i, sum = 0;
+	
+	cout << "Please Enter the Number to check for Perfect  =  ";
+	cin >> number;
+	
+	for(i = 1 ; i < number ; i++)
+	{
+		if(number % i == 0)
+		{
+			sum = sum + i;
+		}
+	}
+			
+	if(number == sum)
+	{
+		cout << number << " is a Perfect Number";
+	}
+	else
+	{
+		cout << number << " is Not a Perfect Number";
+	}
+ 	return 0;
+}
\ No newline at end of file
diff --git a/perfect_number.cpp b/perfect_number.cpp
new file mode 100644
index 00000000..29f806c1
--- /dev/null
+++ b/perfect_number.cpp
@@ -0,0 +1,20 @@
+#include<iostream>
+
+using namespace std;
+int main()
+{
+   int num, i, sum=0;
+   cout<<"Enter a Number: ";
+   cin>>num;
+   for(i=1; i<num; i++)
+   {
+      if(num%i==0)
+         sum = sum+i;
+   }
+   if(num==sum)
+      cout<<endl<<num<<" is a Perfect Number.";
+   else
+      cout<<endl<<num<<" is not a Perfect Number.";
+   cout<<endl;
+   return 0;
+}
diff --git a/permutations_of_string.cpp b/permutations_of_string.cpp
new file mode 100644
index 00000000..40546409
--- /dev/null
+++ b/permutations_of_string.cpp
@@ -0,0 +1,81 @@
+//
+// C program to print all permutations with repetition
+// of characters
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/strings
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Tushar Kanakagiri
+// Github: @tusharkanakagiri
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Following function is used by the library qsort() function
+  to sort an array of chars */
+int compare(const void *a, const void *b);
+
+/* The main function that recursively prints all repeated
+   permutations of  the given string. It uses data[] to store all
+   permutations one by one */
+void allLexicographicRecur(char *str, char *data, int last, int index)
+{
+    int i, len = strlen(str);
+
+    // One by one fix all characters at the given index and recur for
+    // the/ subsequent indexes
+    for (i = 0; i < len; i++)
+    {
+        // Fix the ith character at index and if this is not the last
+        // index then recursively call for higher indexes
+        data[index] = str[i];
+
+        // If this is the last index then print the string stored in
+        // data[]
+        if (index == last)
+            printf("%s\n", data);
+        else // Recur for higher indexes
+            allLexicographicRecur(str, data, last, index + 1);
+    }
+}
+
+/* This function sorts input string, allocate memory for data (needed
+   for allLexicographicRecur()) and calls allLexicographicRecur() for
+   printing all  permutations */
+void allLexicographic(char *str)
+{
+    int len = strlen(str);
+
+    // Create a temp array that will be used by allLexicographicRecur()
+    char *data = (char *)malloc(sizeof(char) * (len + 1));
+    data[len] = '\0';
+
+    // Sort the input string so that we get all output strings in
+    // lexicographically sorted order
+    qsort(str, len, sizeof(char), compare);
+
+    // Now print all permutaions
+    allLexicographicRecur(str, data, len - 1, 0);
+
+    // Free data to avoid memory leak
+    free(data);
+}
+
+// Needed for library function qsort()
+int compare(const void *a, const void *b)
+{
+    return (*(char *)a - *(char *)b);
+}
+
+// Driver program to test above functions
+int main()
+{
+    char str[] = ""; //Enter character array
+    printf("All permutations with repetition of %s are: \n",
+           str);
+    allLexicographic(str);
+    return 0;
+}
diff --git a/polynomialadditionusinglinkedlist.cpp b/polynomialadditionusinglinkedlist.cpp
new file mode 100644
index 00000000..6572c941
--- /dev/null
+++ b/polynomialadditionusinglinkedlist.cpp
@@ -0,0 +1,131 @@
+// this is a program to add two polynomials using linked list
+#include<bits/stdc++.h>
+using namespace std;
+struct node
+{
+    int coeff;
+    int expo;
+    struct node* next;
+};
+void create(struct node* poly)
+{
+    int data,pow,c;
+    struct node* temp=poly;
+    //int c=1;
+    cout<<"ENTER COEFFICIENT : ";
+    cin>>data;
+    cout<<"ENTER EXPONENT: ";
+    cin>>pow;
+    temp->coeff=data;
+    temp->expo=pow;
+    temp->next=NULL;
+    cout<<"IF THERE ARE MORE TERMS IN POLYNOMIAL ENTER 1 ELSE ENTER 0: ";
+    cin>>c;
+    while(c!=0)
+    {
+        struct node* ptr=(struct node*)malloc(sizeof(struct node));
+        cout<<"ENTER COEFFICIENT : ";
+        cin>>data;
+        cout<<"ENTER EXPONENT: ";
+        cin>>pow;
+        ptr->coeff=data;
+        ptr->expo=pow;
+        temp->next=ptr;
+        ptr->next=NULL;
+        temp=ptr;
+        cout<<"IF THERE ARE MORE TERMS IN POLYNOMIAL ENTER 1 ELSE ENTER 0: ";
+        cin>>c;
+    }
+}
+void addpoly(struct node* poly1,struct node* poly2,struct node* poly3)
+{
+    //struct node* poly3=(struct node*)malloc(sizeof(struct node));
+    struct node* temp1=poly1;struct node* temp2=poly2;struct node* temp3=poly3;
+    while(temp1!=NULL&&temp2!=NULL)
+    {
+        struct node* ptr=(struct node*)malloc(sizeof(struct node));
+        if(temp1->expo>temp2->expo)
+        {
+            temp3->coeff=temp1->coeff;
+            temp3->expo=temp1->expo;
+            temp3->next=ptr;
+            temp3=ptr;
+            temp1=temp1->next;
+        }
+        else if(temp1->expo<temp2->expo)
+        {
+            temp3->coeff=temp2->coeff;
+            temp3->expo=temp2->expo;
+            temp3->next=ptr;
+            temp3=ptr;
+            temp2=temp2->next;
+        }
+        else if(temp1->expo==temp2->expo)
+        {
+            temp3->coeff=temp2->coeff+temp1->coeff;
+            temp3->expo=temp2->expo;
+            temp3->next=ptr;
+            temp3=ptr;
+            temp2=temp2->next;
+            temp1=temp1->next;
+        }
+    }
+    if(temp2==NULL)
+    {
+        temp3->coeff=temp1->coeff;
+        temp3->expo=temp1->expo;
+        temp1=temp1->next;
+        while(temp1!=NULL)
+        {
+            struct node* ptr=(struct node*)malloc(sizeof(struct node));
+            temp3->coeff=temp1->coeff;
+            temp3->expo=temp1->expo;
+            temp1=temp1->next;
+            temp3->next=ptr;
+            temp3=ptr;
+        }
+    }
+    if(temp1==NULL)
+    {
+        temp3->coeff=temp2->coeff;
+        temp3->expo=temp2->expo;
+        temp2=temp2->next;
+        while(temp2!=NULL)
+        {
+            struct node* ptr=(struct node*)malloc(sizeof(struct node));
+            temp3->coeff=temp2->coeff;
+            temp3->expo=temp2->expo;
+            temp2=temp2->next;
+            temp3->next=ptr;
+            temp3=ptr;
+        }
+    }
+    temp3=NULL;
+}
+void display(struct node* poly)
+{
+    struct node* temp=poly;
+    while(temp->next!=NULL)
+    {
+        cout<<temp->coeff<<"x^"<<temp->expo<<"+";
+        temp=temp->next;
+    }
+    cout<<temp->coeff<<"x^"<<temp->expo;
+}
+int main()
+{
+    struct node* poly1=(struct node*)malloc(sizeof(struct node));
+    struct node* poly2=(struct node*)malloc(sizeof(struct node));
+    cout<<"ENTER FIRST POLYNOMIAL:\n";
+    create(poly1);
+    cout<<"ENTER SECOND POLYNOMIAL:\n";
+    create(poly2);
+    cout<<"\nFIRST POLYNOMIAL IS: ";
+    display(poly1);
+    cout<<"\nSECOND POLYNOMIAL IS: ";
+    display(poly2);
+    struct node* poly3=(struct node*)malloc(sizeof(struct node));
+    addpoly(poly1,poly2,poly3);
+    cout<<"\nTHE RESULTANT POLYNOMIAL IS: ";
+    display(poly3);
+}
diff --git a/prim's-algorithm.cpp b/prim's-algorithm.cpp
new file mode 100644
index 00000000..5175c347
--- /dev/null
+++ b/prim's-algorithm.cpp
@@ -0,0 +1,78 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define V 5
+
+int minKey(int key[], bool mstSet[])
+{
+	// Initialize min value
+	int min = INT_MAX, min_index;
+
+	for (int v = 0; v < V; v++)
+		if (mstSet[v] == false && key[v] < min)
+			min = key[v], min_index = v;
+
+	return min_index;
+}
+
+void printMST(int parent[], int graph[V][V])
+{
+	cout<<"Edge \tWeight\n";
+	for (int i = 1; i < V; i++)
+		cout<<parent[i]<<" - "<<i<<" \t"<<graph[i][parent[i]]<<" \n";
+}
+
+
+void primMST(int graph[V][V])
+{
+	int parent[V];
+	int key[V];
+	bool mstSet[V];
+
+	for (int i = 0; i < V; i++)
+		key[i] = INT_MAX, mstSet[i] = false;
+
+	key[0] = 0;
+	parent[0] = -1; // First node is always root of MST
+
+	for (int count = 0; count < V - 1; count++)
+	{
+		int u = minKey(key, mstSet);
+
+		mstSet[u] = true;
+
+		for (int v = 0; v < V; v++)
+
+			if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])
+				parent[v] = u, key[v] = graph[u][v];
+	}
+
+	printMST(parent, graph);
+}
+
+// Driver code
+int main()
+{
+	int graph[V][V] = { { 0, 2, 0, 6, 0 },
+						{ 2, 0, 3, 8, 5 },
+						{ 0, 3, 0, 0, 7 },
+						{ 6, 8, 0, 0, 9 },
+						{ 0, 5, 7, 9, 0 } };
+
+	primMST(graph);
+
+	return 0;
+}
+
+
+/*
+Output: 
+
+Edge   Weight
+0 - 1    2
+1 - 2    3
+0 - 3    6
+1 - 4    5
+
+*/
+
diff --git a/prime.cpp b/prime.cpp
new file mode 100644
index 00000000..9299b76d
--- /dev/null
+++ b/prime.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+    int i, n;
+    bool isPrime = true;
+
+    cout << "Enter a positive integer: ";
+    cin >> n;
+
+    // 0 and 1 are not prime numbers
+    if (n == 0 || n == 1) {
+        isPrime = false;
+    }
+    else {
+        for (i = 2; i <= n / 2; ++i) {
+            if (n % i == 0) {
+                isPrime = false;
+                break;
+            }
+        }
+    }
+    if (isPrime)
+        cout << n << " is a prime number";
+    else
+        cout << n << " is not a prime number";
+
+    return 0;
+}
diff --git a/print_duplicate_string.cpp b/print_duplicate_string.cpp
new file mode 100644
index 00000000..46eacf66
--- /dev/null
+++ b/print_duplicate_string.cpp
@@ -0,0 +1,47 @@
+//
+// C++ program to count all duplicates from string using hashing
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/strings
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Tushar Kanakagiri
+// Github: @tusharkanakagiri
+//
+#include <stdio.h>
+#include <stdlib.h>
+#define NO_OF_CHARS 256
+
+/* Fills count array with frequency of characters */
+void fillCharCounts(char *str, int *count)
+{
+  int i;
+  for (i = 0; *(str + i); i++)
+    count[*(str + i)]++;
+}
+
+/* Print duplicates present in the passed string */
+void printDups(char *str)
+{
+  // Create an array of size 256 and fill count of every character in it
+  int *count = (int *)calloc(NO_OF_CHARS, sizeof(int));
+  fillCharCounts(str, count);
+
+  // Print characters having count more than 0
+  int i;
+  for (i = 0; i < NO_OF_CHARS; i++)
+    if (count[i] > 1)
+      printf("%c,  count = %d \n", i, count[i]);
+
+  free(count);
+}
+
+/* Driver program to test to pront printDups*/
+int main()
+{
+  char str[] = ""; //Enter string here
+  printDups(str);
+  getchar();
+  return 0;
+}
diff --git a/quick sort cpp b/quick sort cpp
new file mode 100644
index 00000000..c077bd4e
--- /dev/null
+++ b/quick sort cpp	
@@ -0,0 +1,73 @@
+/* C implementation QuickSort */
+#include<stdio.h>
+
+// A utility function to swap two elements
+void swap(int* a, int* b)
+{
+	int t = *a;
+	*a = *b;
+	*b = t;
+}
+
+/* This function takes last element as pivot, places
+the pivot element at its correct position in sorted
+	array, and places all smaller (smaller than pivot)
+to left of pivot and all greater elements to right
+of pivot */
+int partition (int arr[], int low, int high)
+{
+	int pivot = arr[high]; // pivot
+	int i = (low - 1); // Index of smaller element
+
+	for (int j = low; j <= high- 1; j++)
+	{
+		// If current element is smaller than or
+		// equal to pivot
+		if (arr[j] <= pivot)
+		{
+			i++; // increment index of smaller element
+			swap(&arr[i], &arr[j]);
+		}
+	}
+	swap(&arr[i + 1], &arr[high]);
+	return (i + 1);
+}
+
+/* The main function that implements QuickSort
+arr[] --> Array to be sorted,
+low --> Starting index,
+high --> Ending index */
+void quickSort(int arr[], int low, int high)
+{
+	if (low < high)
+	{
+		/* pi is partitioning index, arr[p] is now
+		at right place */
+		int pi = partition(arr, low, high);
+
+		// Separately sort elements before
+		// partition and after partition
+		quickSort(arr, low, pi - 1);
+		quickSort(arr, pi + 1, high);
+	}
+}
+
+/* Function to print an array */
+void printArray(int arr[], int size)
+{
+	int i;
+	for (i=0; i < size; i++)
+		printf("%d ", arr[i]);
+	printf("\n");
+}
+
+// Driver program to test above functions
+int main()
+{
+	int arr[] = {10, 7, 8, 9, 1, 5};
+	int n = sizeof(arr)/sizeof(arr[0]);
+	quickSort(arr, 0, n-1);
+	printf("Sorted array: \n");
+	printArray(arr, n);
+	return 0;
+}
diff --git a/quizGame.py b/quizGame.py
new file mode 100644
index 00000000..39cf316c
--- /dev/null
+++ b/quizGame.py
@@ -0,0 +1,32 @@
+print('Welcome to AskPython Quiz')
+answer=input('Are you ready to play the Quiz ? (yes/no) :')
+score=0
+total_questions=3
+ 
+if answer.lower()=='yes':
+    answer=input('Question 1: What is your Favourite programming language?')
+    if answer.lower()=='python':
+        score += 1
+        print('correct')
+    else:
+        print('Wrong Answer :(')
+ 
+ 
+    answer=input('Question 2: Do you follow any author on AskPython? ')
+    if answer.lower()=='yes':
+        score += 1
+        print('correct')
+    else:
+        print('Wrong Answer :(')
+ 
+    answer=input('Question 3: What is the name of your favourite website for learning Python?')
+    if answer.lower()=='askpython':
+        score += 1
+        print('correct')
+    else:
+        print('Wrong Answer :(')
+ 
+print('Thankyou for Playing this small quiz game, you attempted',score,"questions correctly!")
+mark=(score/total_questions)*100
+print('Marks obtained:',mark)
+print('BYE!')
diff --git a/quotient_and_remainder b/quotient_and_remainder
new file mode 100644
index 00000000..628d6fac
--- /dev/null
+++ b/quotient_and_remainder
@@ -0,0 +1,21 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{    
+    int divisor, dividend, quotient, remainder;
+
+    cout << "Enter dividend: ";
+    cin >> dividend;
+
+    cout << "Enter divisor: ";
+    cin >> divisor;
+
+    quotient = dividend / divisor;
+    remainder = dividend % divisor;
+
+    cout << "Quotient = " << quotient << endl;
+    cout << "Remainder = " << remainder;
+
+    return 0;
+}
diff --git a/railreservation.cpp b/railreservation.cpp
new file mode 100644
index 00000000..73ea90ff
--- /dev/null
+++ b/railreservation.cpp
@@ -0,0 +1,688 @@
+#include<stdio.h>
+#include<conio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<iostream.h>
+#include<time.h>
+#include<iomanip.h>
+#include<fstream.h>
+char f[10]="f";
+char s[10]="s";
+int addr,ad,flag,f1,d,m,i,amt;
+float tamt;
+class login
+{
+public:
+char id[100];
+char pass[100];
+char *password;
+void getid()
+{
+cout<<"Enter your id:";gets(id);
+password=getpass("Enter the password:");
+strcpy(pass,password);
+}
+void displayid()
+{
+cout<<"Id:";puts(id);
+cout<<"Password:";puts(pass);
+}
+};
+class detail
+{
+public:
+int tno;
+char tname[100];
+
+char bp[100];
+char dest[100];
+int c1,c1fare;
+int c2,c2fare;
+int d,m,y;
+void getdetail()
+{
+cout<<"Enter the details as follows\n";
+cout<<"Train no:";cin>>tno;
+cout<<"Train name:";gets(tname);
+cout<<"Boarding point:";gets(bp);
+cout<<"Destination pt:";gets(dest);
+cout<<"No of seats in first class & fare per ticket:";
+cin>>c1>>c1fare;
+cout<<"No of seats in second class & fare per ticket:";
+cin>>c2>>c2fare;
+cout<<"Date of travel:";cin>>d>>m>>y;
+}
+void displaydetail()
+{
+cout<<tno<<"\t"<<tname<<"\t"<<bp<<"\t"<<dest<<"\t";
+cout<<c1<<"\t"<<c1fare<<"\t"<<c2<<"\t"<<c2fare<<"\t";
+cout<<d<<"-"<<m<<"-"<<y<<"\t"<<endl;
+}
+};
+class reser
+{
+public:
+int pnr;
+int tno;
+char tname[100];
+char bp[10];
+char dest[100];
+char pname[10][100];
+int age[20];
+char clas[10];
+int nosr;
+int i;
+int d,m,y;
+int con;
+
+
+float amc;
+void getresdet()
+{
+cout<<"Enter the details as follows\n";
+cout<<"Train no:";cin>>tno;
+cout<<"Train name:";gets(tname);
+cout<<"Boarding point:";gets(bp);
+cout<<"Destination pt:";gets(dest);
+cout<<"No of seats required:";cin>>nosr;
+for(i=0;i<nosr;i++)
+{
+cout<<"Passenger name:";gets(pname[i]);
+cout<<"Passenger age:";cin>>age[i];
+}
+cout<<"Enter the class f-first class s-second class:";
+gets(clas);
+cout<<"Date of travel:";cin>>d>>m>>y;
+cout<<"Enter the concession category\n";
+cout<<"1.Military\n2.Senior citizen\n";
+cout<<"3.Children below 5 yrs\n4.None\n";
+cin>>con;
+cout<<"............END OF GETTING DETAILS............\n";
+}
+void displayresdet()
+{
+cout<<"...............................................\n";
+cout<<"...............................................\n";
+cout<<"Pnr no:"<<pnr;
+cout<<"\nTrain no:"<<tno;
+cout<<"\nTrain name:";puts(tname);
+cout<<"Boarding point:";puts(bp);
+cout<<"Destination pt:";puts(dest);
+cout<<"No of seats reserved:"<<nosr;
+for(i=0;i<nosr;i++)
+{
+cout<<"Passenger name:";puts(pname[i]);
+cout<<"Passenger age:"<<age[i];
+}
+
+cout<<"\nYour class:";puts(clas);
+cout<<"\nDate of reservation:"<<d<<"-"<<m<<"-"<<y;
+cout<<"\nYour concession category:"<<con;
+cout<<"\nYou must pay:"<<amc<<endl;
+cout<<"***********************************************\n";
+cout<<".........END OF RESERVATION.................\n";
+cout<<"***********************************************\n";
+}
+};
+class canc
+{
+public:
+int pnr;
+int tno;
+char tname[100];
+char bp[10];
+char dest[100];
+char pname[10][100];
+int age[20];
+int i;
+char clas[10];
+int nosc;
+int d,m,y;
+float amr;
+void getcancdet()
+{
+cout<<"Enter the details as follows\n";
+cout<<"Pnr no:";cin>>pnr;
+cout<<"Date of cancellation:";cin>>d>>m>>y;
+cout<<"...........END OF GETTING DETAILS...........\n";
+}
+void displaycancdet()
+{
+cout<<"...........................................\n";
+cout<<"...........................................\n";
+cout<<"Pnr no:"<<pnr;
+cout<<"\nTrain no:"<<tno;
+cout<<"\nTrain name:";puts(tname);
+cout<<"Boarding point:";puts(bp);
+
+cout<<"Destination pt:";puts(dest);
+cout<<"\nYour class:";puts(clas);
+cout<<"no of seats to be cancelled:"<<nosc;
+for(i=0;i<nosc;i++)
+{
+cout<<"Passenger name:";puts(pname[i]);
+cout<<"passenger age:"<<age[i];
+}
+cout<<"\nDate of cancellation:"<<d<<"-"<<m<<"-"<<y;
+cout<<"\nYou can collect:"<<amr<<"rs"<<endl;
+cout<<"*****************************************\n";
+cout<<".........END OF CANCELLATION.............\n";
+cout<<"*****************************************\n";
+}
+};
+void manage();
+void can();
+void user();
+void database();
+void res();
+void reserve();
+void displaypassdetail();
+void cancell();
+void enquiry();
+void main()
+{
+clrscr();
+int ch;
+cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
+cout<<".......WELCOME TO RAILWAY RESERVATION SYSTEM..........\n";
+cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
+do
+{
+cout<<"^^^^^^^^^^^^^^^^^^^^^^MAIN MENU^^^^^^^^^^^^^^^^^^^^\n";
+cout<<"1.Admin mode\n2.User mode\n3.Exit\n";
+cout<<"Enter your choice:";
+cin>>ch;
+cout<<endl;
+switch(ch)
+
+{
+case 1:
+database();
+break;
+case 2:
+user();
+break;
+case 3:
+exit(0);
+}
+}while(ch<=3);
+getch();
+}
+void database()
+{
+char *password;
+char *pass="12345678";
+password=getpass("Enter the admininistrator password:");
+detail a;
+fstream f;
+int ch;
+char c;
+if(strcmp(pass,password)!=0)
+{
+cout<<"Enter the password correctly \n";
+cout<<"You are not permitted to logon this mode\n";
+goto h;
+}
+if(strcmp(pass,password)==0)
+{
+char c;
+do
+{
+cout<<"...........ADMINISTRATOR MENU...........\n";
+cout<<"1.Create detail data base\n2.Add details\n";
+cout<<"3.Display details\n4.User management\n";
+cout<<"5.Display passenger details\n6.Return to main menu\n";
+cout<<"Enter your choice:";
+cin>>ch;
+
+
+cout<<endl;
+switch(ch)
+{
+case 1:
+f.open("t.txt",ios::out|ios::binary);
+do
+{
+a.getdetail();
+f.write((char *) & a,sizeof(a));
+cout<<"Do you want to add one more record?\n";
+cout<<"y-for Yes\nn-for No\n";
+cin>>c;
+}while(c=='y');
+f.close();
+break;
+case 2:
+f.open("t.txt",ios::in|ios::out|ios::binary|ios::app);
+a.getdetail();
+f.write((char *) & a,sizeof(a));
+f.close();
+break;
+case 3:
+f.open("t.txt",ios::in|ios::out|ios::binary|ios::app);
+f.seekg(0);
+while(f.read((char *) & a,sizeof(a)))
+{
+a.displaydetail();
+}
+f.close();
+break;
+case 4:
+manage();
+break;
+case 5:
+displaypassdetail();
+break;
+}
+}while(ch<=5);
+
+f.close();
+}
+h:
+}
+void reserve()
+{
+int ch;
+do
+{
+cout<<"1.Reserve\n2.Return to the main menu\n";
+cout<<"Enter your choice:";
+cin>>ch;
+cout<<endl;
+switch(ch)
+{
+case 1:
+res();
+break;
+}
+}while(ch==1);
+getch();
+}
+void res()
+{
+detail a;
+reser b;
+fstream f1,f2;
+time_t t;
+f1.open("t.txt",ios::in|ios::out|ios::binary);
+f2.open("p.txt",ios::in|ios::out|ios::binary|ios::app);
+int ch;
+b.getresdet();
+while(f1.read((char *) &a,sizeof(a)))
+{
+if(a.tno==b.tno)
+{
+if(strcmp(b.clas,f)==0)
+{
+if(a.c1>=b.nosr)
+
+{
+amt=a.c1fare;
+addr=f1.tellg();
+ad=sizeof(a.c1);
+f1.seekp(addr-(7*ad));
+a.c1=a.c1-b.nosr;
+f1.write((char *) & a.c1,sizeof(a.c1));
+if(b.con==1)
+{
+cout<<"Concession category:MILITARY PERSONNEL\n";
+
+b.amc=b.nosr*((amt*50)/100);
+}
+else if(b.con==2)
+{
+cout<<"Concession category:SENIOR CITIZEN\n";
+b.amc=b.nosr*((amt*60)/100);
+}
+else if(b.con==3)
+{
+cout<<"Concession category:CHILDERN BELOW FIVE\n";
+b.amc=0.0;
+}
+else if(b.con==4)
+{
+cout<<"You cannot get any concession\n";
+b.amc=b.nosr*amt;
+}
+srand((unsigned) time(&t));
+b.pnr=rand();
+f2.write((char *) & b,sizeof(b));
+b.displayresdet();
+cout<<"------------------------------------------------------\n";
+cout<<"--------------Your ticket is reserved-----------\n";
+cout<<"-----------------End of reservation menu-------\n";
+}
+else
+{
+cout<<"**********Sorry req seats not available********\n";
+
+}
+}
+else if(strcmp(b.clas,s)==0)
+{
+if(a.c2>=b.nosr)
+{
+amt=a.c2fare;
+addr=f1.tellg();
+ad=sizeof(a.c2);
+f1.seekp(addr-(5*ad));
+a.c2=a.c2-b.nosr;
+f1.write((char *) & a.c2,sizeof(a.c2));
+if(b.con==1)
+{
+cout<<"Concession category:MILITARY PRESONNEL\n";
+b.amc=b.nosr*((amt*50)/100);
+}
+else if(b.con==2)
+{
+cout<<"Concession category:SENIOR CITIZEN\n";
+b.amc=b.nosr*((amt*60)/100);
+}
+else if(b.con==3)
+{
+cout<<"Concession category:CHILDERN BELOW FIVE\n";
+b.amc=0.0;
+}
+else if(b.con==4)
+{
+cout<<"You cannot get any concession\n";
+b.amc=b.nosr*amt;
+}
+f2.write((char *) & b,sizeof(b));
+b.displayresdet();
+cout<<"---------------------------------------\n";
+cout<<"--------Your ticket is reserved--------\n";
+cout<<"------------End of reservation---------\n";
+}
+else
+
+
+{
+cout<<"********Sorry req no of seats not available*******\n";
+}
+}
+getch();
+
+goto h;
+}
+else
+{
+flag=0;
+}
+}
+if(flag==0)
+{
+cout<<"............Wrong train no......................\n";
+cout<<"......Enter the train no from the data base.....\n";
+}
+f1.close();
+f2.close();
+getch();
+h:
+}
+void displaypassdetail()
+{
+fstream f;
+reser b;
+f.open("p.txt",ios::in|ios::out|ios::binary);
+f.seekg(0);
+while(f.read((char *) & b,sizeof(b)))
+{
+b.displayresdet();
+}
+f.close();
+getch();
+}
+void enquiry()
+{
+
+fstream f;
+f.open("t.txt",ios::in|ios::out|ios::binary);
+detail a;
+while(f.read((char *) & a,sizeof(a)))
+{
+a.displaydetail();
+}
+getch();
+}
+void cancell()
+{
+detail a;
+reser b;
+canc c;
+fstream f1,f2,f3;
+f1.open("t.txt",ios::in|ios::out|ios::binary);
+f2.open("p.txt",ios::in|ios::out|ios::binary);
+f3.open("cn.txt",ios::in|ios::out|ios::binary);
+cout<<"**********CANCELLATION MENU*********\n";
+c.getcancdet();
+while(f2.read((char *) & b,sizeof(b)))
+{
+if(b.pnr==c.pnr)
+{
+c.tno=b.tno;
+strcpy(c.tname,b.tname);
+strcpy(c.bp,b.bp);
+strcpy(c.dest,b.dest);
+c.nosc=b.nosr;
+for(int j=0;j<c.nosc;j++)
+{
+strcpy(c.pname[j],b.pname[j]);
+c.age[j]=b.age[j];
+}
+strcpy(c.clas,b.clas);
+if(strcmp(c.clas,f)==0)
+{
+while(f1.read((char *) & a,sizeof(a)))
+{
+
+if(a.tno==c.tno)
+{
+a.c1=a.c1+c.nosc;
+d=a.d;
+m=a.m;
+addr=f1.tellg();
+ad=sizeof(a.c1);
+f1.seekp(addr-(7*ad));
+f1.write((char *) & a.c1,sizeof(a.c1));
+tamt=b.amc;
+if((c.d==d)&&(c.m==m))
+{
+cout<<"You are cancelling at the date of departure\n";
+c.amr=tamt-((tamt*60)/100);
+}
+else if(c.m==m)
+{
+cout<<"You are cancelling at the month of departure\n";
+c.amr=tamt-((tamt*50)/100);
+}
+else if(m>c.m)
+{
+cout<<"You are cancelling one month before the date of departure\n";
+c.amr=tamt-((tamt*20)/100);
+}
+else
+{
+cout<<"Cancelling after the departure\n";
+cout<<"Your request cannot be completed\n";
+}
+goto h;
+displaycancdet();
+}
+}
+}
+else if(strcmp(c.clas,s)==0)
+{
+while(f1.read((char *) & a,sizeof(a)))
+{
+
+if(a.tno==c.tno)
+{
+a.c2=a.c2+c.nosc;
+d=a.d;
+m=a.m;
+addr=f1.tellg();
+ad=sizeof(a.c2);
+f1.seekp(addr-(5*ad));
+f1.write((char *) & a.c2,sizeof(a.c2));
+tamt=b.amc;
+if((c.d==d)&&(c.m==m))
+{
+cout<<"You are cancelling at the date of departure\n";
+c.amr=tamt-((tamt*60)/100);
+}
+else if(c.m==m)
+{
+cout<<"You are cancelling at the month of departure\n";
+c.amr=tamt-((tamt*50)/100);
+}
+else if(m>c.m)
+{
+cout<<"You are cancelling one month before the date of departure\n";
+c.amr=tamt-((tamt*20)/100);
+}
+else
+{
+cout<<"Cancelling after the departure\n";
+cout<<"Your request cannot be completed\n";
+}
+goto h;
+displaycancdet();
+}
+}
+}
+}
+else
+{
+flag=0;
+
+}
+}
+h:
+if(flag==0)
+{
+cout<<"Enter the correct pnr no\n";
+}
+f1.close();
+f2.close();
+f3.close();
+getch();
+}
+void can()
+{
+int ch;
+do
+{
+cout<<".................CANCELLATION MENU.........\n";
+cout<<"1.Cancell\n2.Return to the main menu\n";
+cout<<"Enter your choice:";
+cin>>ch;
+cout<<endl;
+switch(ch)
+{
+case 1:
+cancell();
+break;
+}
+}while(ch==1);
+getch();
+}
+void user()
+{
+login a;
+int ch;
+cout<<"*****************************************************\n";
+cout<<"***********WELCOME TO THE USER MENU**\n";
+cout<<"****************************************************\n";
+char *password;
+
+fstream f;
+f.open("id.txt",ios::in|ios::out|ios::binary);
+char id[100];
+puts("Enter your id:");gets(id);
+password=getpass("Enter your password:");
+while(f.read((char *) & a,sizeof(a)))
+{
+if((strcmp(a.id,id)==0)&&(strcmp(a.pass,password)==0))
+{
+do
+{
+cout<<"1.Reserve\n2.Cancell\n3.Enquiry\n4.Return to the main menu\n";
+cout<<"Enter your choice:";
+cin>>ch;
+cout<<endl;
+switch(ch)
+{
+case 1:
+reserve();
+break;
+case 2:
+cancell();
+break;
+case 3:
+enquiry();
+break;
+}
+}while(ch<=3);
+goto j;
+}
+else
+{
+d=1;
+}
+}
+if(d==1)
+{
+cout<<"Enter your user id and password correctly\n";
+}
+
+getch();
+j:
+}
+void manage()
+{
+int ch;
+fstream f;
+char c;
+login a;
+cout<<".........WELCOME TO THE USER MANAGEMENT MENU........\n";
+do
+{
+cout<<"1.Create id data base\n2.Add details\n";
+cout<<"3.Display details\n4.Return to the main menu\n";
+cout<<"Enter your choice:";
+cin>>ch;
+cout<<endl;
+switch(ch)
+{
+case 1:
+f.open("id.txt",ios::out|ios::binary);
+do
+{
+a.getid();
+f.write((char *) & a,sizeof(a));
+cout<<"Do you want to add one more record\n";
+cout<<"y-Yes\nn-No\n";
+cin>>c;
+}while(c=='y');
+f.close();
+break;
+case 2:
+f.open("id.txt",ios::in|ios::out|ios::binary|ios::app);
+a.getid();
+f.write((char *) & a,sizeof(a));
+f.close();
+break;
+case 3:
+f.open("id.txt",ios::in|ios::out|ios::binary);
+
+f.seekg(0);
+while(f.read((char *) & a,sizeof(a)))
+{
+a.displayid();
+}
+f.close();
+break;
+}
+}while(ch<=3);
+getch();
+}
diff --git a/rainwatertrapping.cpp b/rainwatertrapping.cpp
new file mode 100644
index 00000000..0fa63d11
--- /dev/null
+++ b/rainwatertrapping.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        int n=height.size();
+        int left=0,right=n-1;
+        int res=0;
+        int maxleft=0,maxright=0;
+        while(left<=right){
+            if(height[left]<=height[right]){
+                if(height[left]>=maxleft)
+                    maxleft=height[left];
+                else
+                    res+=maxleft-height[left];
+                left++;
+            }else{
+                if(height[right]>=maxright)
+                    maxright=height[right];
+                else
+                    res+=maxright-height[right];
+                right--;
+            }
+        }
+        return res;
+    }
+};
diff --git a/remove nth node from end of the list b/remove nth node from end of the list
new file mode 100644
index 00000000..e6574bf9
--- /dev/null
+++ b/remove nth node from end of the list	
@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode* slow=head;
+        ListNode* fast=head;
+        for(int i=0;i<n;i++)
+            fast=fast->next;
+        if(fast==NULL)
+        {
+            head=head->next;
+            return head;
+        }
+        while(fast->next!=NULL)
+        {
+            fast=fast->next;
+            slow=slow->next;
+        }
+        {
+           
+            slow->next=slow->next->next;
+            
+            return head;
+        }
+        
+    }
+};
diff --git a/remove_adjacent_duplicates.cpp b/remove_adjacent_duplicates.cpp
new file mode 100644
index 00000000..e28ead88
--- /dev/null
+++ b/remove_adjacent_duplicates.cpp
@@ -0,0 +1,75 @@
+//
+// C/C++ program to remove all adjacent duplicates from a string
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/strings
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Tushar Kanakagiri
+// Github: @tusharkanakagiri
+//
+#include <iostream>
+#include <string.h>
+using namespace std;
+
+// Recursively removes adjacent duplicates from str and returns
+// new string. las_removed is a pointer to last_removed character
+char *removeUtil(char *str, char *last_removed)
+{
+    // If length of string is 1 or 0
+    if (str[0] == '\0' || str[1] == '\0')
+        return str;
+
+    // Remove leftmost same characters and recur for remaining
+    // string
+    if (str[0] == str[1])
+    {
+        *last_removed = str[0];
+        while (str[1] && str[0] == str[1])
+            str++;
+        str++;
+        return removeUtil(str, last_removed);
+    }
+
+    // At this point, the first character is definiotely different
+    // from its adjacent. Ignore first character and recursively
+    // remove characters from remaining string
+    char *rem_str = removeUtil(str + 1, last_removed);
+
+    // Check if the first character of the rem_string matches with
+    // the first character of the original string
+    if (rem_str[0] && rem_str[0] == str[0])
+    {
+        *last_removed = str[0];
+        return (rem_str + 1); // Remove first character
+    }
+
+    // If remaining string becomes empty and last removed character
+    // is same as first character of original string. This is needed
+    // for a string like "acbbcddc"
+    if (rem_str[0] == '\0' && *last_removed == str[0])
+        return rem_str;
+
+    // If the two first characters of str and rem_str don't match,
+    // append first character of str before the first character of
+    // rem_str.
+    rem_str--;
+    rem_str[0] = str[0];
+    return rem_str;
+}
+
+char *remove(char *str)
+{
+    char last_removed = '\0';
+    return removeUtil(str, &last_removed);
+}
+
+// Driver program to test above functions
+int main()
+{
+    char str1[] = ""; //Enter string
+    cout << remove(str1) << endl;
+
+    return 0;
+}
diff --git a/remove_duplicates.cpp b/remove_duplicates.cpp
new file mode 100644
index 00000000..4a56d437
--- /dev/null
+++ b/remove_duplicates.cpp
@@ -0,0 +1,48 @@
+//
+// CPP program to remove duplicate character
+// from character array and print in sorted
+// order
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/strings
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Tushar Kanakagiri
+// Github: @tusharkanakagiri
+//
+#include <iostream>
+using namespace std;
+
+char *removeDuplicate(char str[], int n)
+{
+   // Used as index in the modified string
+   int index = 0;
+
+   // Traverse through all characters
+   for (int i = 0; i < n; i++)
+   {
+
+      // Check if str[i] is present before it
+      int j;
+      for (j = 0; j < i; j++)
+         if (str[i] == str[j])
+            break;
+
+      // If not present, then add it to
+      // result.
+      if (j == i)
+         str[index++] = str[i];
+   }
+
+   return str;
+}
+
+// Driver code
+int main()
+{
+   char str[] = ""; //Enter string here
+   int n = sizeof(str) / sizeof(str[0]);
+   cout << removeDuplicate(str, n);
+   return 0;
+}
diff --git a/reverse.cpp b/reverse.cpp
new file mode 100644
index 00000000..4640b014
--- /dev/null
+++ b/reverse.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+using namespace std;
+
+//recursive function
+void reverse(string &str, int i){
+    //Base condition - when index exceeds string length
+    if(i == str.length())
+        return;
+    
+    //extract character
+    char ch = str[i];
+    //recusively call for next character
+    reverse(str, i+1);
+    //reassign in reverse order
+    str[str.length()-i-1] = ch;
+}
+ 
+int main()
+{   
+    //Input string
+    string str = "Pencil Programmer";
+    
+    //start recirsive funtion from first index
+    reverse(str, 0);
+    
+    //output the string
+    cout << str;
+    return 0;
+}
diff --git a/reverseLinkedListIter.cpp b/reverseLinkedListIter.cpp
new file mode 100644
index 00000000..cbc51d6c
--- /dev/null
+++ b/reverseLinkedListIter.cpp
@@ -0,0 +1,79 @@
+// Iterative C++ program to reverse
+// a linked list
+#include <iostream>
+using namespace std;
+
+/* Link list node */
+struct Node {
+	int data;
+	struct Node* next;
+	Node(int data)
+	{
+		this->data = data;
+		next = NULL;
+	}
+};
+
+struct LinkedList {
+	Node* head;
+	LinkedList() { head = NULL; }
+
+	/* Function to reverse the linked list */
+	void reverse()
+	{
+		// Initialize current, previous and
+		// next pointers
+		Node* current = head;
+		Node *prev = NULL, *next = NULL;
+
+		while (current != NULL) {
+			// Store next
+			next = current->next;
+
+			// Reverse current node's pointer
+			current->next = prev;
+
+			// Move pointers one position ahead.
+			prev = current;
+			current = next;
+		}
+		head = prev;
+	}
+
+	/* Function to print linked list */
+	void print()
+	{
+		struct Node* temp = head;
+		while (temp != NULL) {
+			cout << temp->data << " ";
+			temp = temp->next;
+		}
+	}
+
+	void push(int data)
+	{
+		Node* temp = new Node(data);
+		temp->next = head;
+		head = temp;
+	}
+};
+
+/* Driver code*/
+int main()
+{
+	/* Start with the empty list */
+	LinkedList ll;
+	ll.push(20);
+	ll.push(4);
+	ll.push(15);
+	ll.push(85);
+
+	cout << "Given linked list\n";
+	ll.print();
+
+	ll.reverse();
+
+	cout << "\nReversed Linked list \n";
+	ll.print();
+	return 0;
+}
diff --git a/reverse_number.cpp b/reverse_number.cpp
new file mode 100644
index 00000000..51ea4f48
--- /dev/null
+++ b/reverse_number.cpp
@@ -0,0 +1,18 @@
+#include <iostream>
+using namespace std;
+
+
+void reverseNum(int n){
+    while(n>0){
+        cout<<n%10;
+        n=n/10;
+    }
+}
+
+int main() {
+	// your code goes here
+	int n;
+	cin>>n;
+	reverseNum(n);
+	return 0;
+}
diff --git a/reverse_string.py b/reverse_string.py
new file mode 100644
index 00000000..dd96dd23
--- /dev/null
+++ b/reverse_string.py
@@ -0,0 +1,15 @@
+
+s=input("Enter string to be reversed: ")
+def reverse(s):
+    if len(s) == 0:
+        return s
+    else:
+        return reverse(s[1:]) + s[0]
+  
+s = "Geeksforgeeks"
+  
+print ("The original string  is : ",end="")
+print (s)
+  
+print ("The reversed string(using recursion) is : ",end="")
+print (reverse(s))
diff --git a/rotateLinkedList.cpp b/rotateLinkedList.cpp
new file mode 100644
index 00000000..07a3c1f8
--- /dev/null
+++ b/rotateLinkedList.cpp
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    ListNode* rotateRight(ListNode* head, int k) {
+        if(!head){
+            return NULL;
+        }
+        ListNode* temp=head;
+        int count=0;
+        while(temp){
+            temp=temp->next;
+            count++;
+        }
+        k=k%count;
+        if(k==0){
+            return head;
+        }
+        k=count-k;
+        k--;
+        temp=head;
+        ListNode* prev;
+        while(k--){
+            temp=temp->next;
+        }
+        prev=temp->next;
+        temp->next=NULL;
+        ListNode* q=prev;
+        while(prev->next){
+            prev=prev->next;
+        }
+        prev->next=head;
+        return q;
+    }
+};
diff --git a/scientific calculator in python b/scientific calculator in python
new file mode 100644
index 00000000..ff7874db
--- /dev/null
+++ b/scientific calculator in python	
@@ -0,0 +1,368 @@
+          # Scientific Calculator
+
+from tkinter import *
+import math
+import tkinter.messagebox
+
+root = Tk()
+root.title("Scientific Calculator")
+root.configure(background='white')
+root.resizable(width=False, height=False)
+root.geometry("480x568+450+90")
+
+calc = Frame(root)
+calc.grid()
+
+
+class Calc():
+    def __init__(self):
+        self.total = 0
+        self.current = ''
+        self.input_value = True
+        self.check_sum = False
+        self.op = ''
+        self.result = False
+
+    def numberEnter(self, num):
+        self.result = False
+        firstnum = txtDisplay.get()
+        secondnum = str(num)
+        if self.input_value:
+            self.current = secondnum
+            self.input_value = False
+        else:
+            if secondnum == '.':
+                if secondnum in firstnum:
+                    return
+            self.current = firstnum + secondnum
+        self.display(self.current)
+
+    def sum_of_total(self):
+        self.result = True
+        self.current = float(self.current)
+        if self.check_sum == True:
+            self.valid_function()
+        else:
+            self.total = float(txtDisplay.get())
+
+    def display(self, value):
+        txtDisplay.delete(0, END)
+        txtDisplay.insert(0, value)
+
+    def valid_function(self):
+        if self.op == "add":
+            self.total += self.current
+        if self.op == "sub":
+            self.total -= self.current
+        if self.op == "multi":
+            self.total *= self.current
+        if self.op == "divide":
+            self.total /= self.current
+        if self.op == "mod":
+            self.total %= self.current
+        self.input_value = True
+        self.check_sum = False
+        self.display(self.total)
+
+    def operation(self, op):
+        self.current = float(self.current)
+        if self.check_sum:
+            self.valid_function()
+        elif not self.result:
+            self.total = self.current
+            self.input_value = True
+        self.check_sum = True
+        self.op = op
+        self.result = False
+
+    def Clear_Entry(self):
+        self.result = False
+        self.current = "0"
+        self.display(0)
+        self.input_value = True
+
+    def All_Clear_Entry(self):
+        self.Clear_Entry()
+        self.total = 0
+
+    def pi(self):
+        self.result = False
+        self.current = math.pi
+        self.display(self.current)
+
+    def tau(self):
+        self.result = False
+        self.current = math.tau
+        self.display(self.current)
+
+    def e(self):
+        self.result = False
+        self.current = math.e
+        self.display(self.current)
+
+    def mathPM(self):
+        self.result = False
+        self.current = -(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def squared(self):
+        self.result = False
+        self.current = math.sqrt(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def cos(self):
+        self.result = False
+        self.current = math.cos(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def cosh(self):
+        self.result = False
+        self.current = math.cosh(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def tan(self):
+        self.result = False
+        self.current = math.tan(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def tanh(self):
+        self.result = False
+        self.current = math.tanh(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def sin(self):
+        self.result = False
+        self.current = math.sin(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def sinh(self):
+        self.result = False
+        self.current = math.sinh(math.radians(float(txtDisplay.get())))
+        self.display(self.current)
+
+    def log(self):
+        self.result = False
+        self.current = math.log(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def exp(self):
+        self.result = False
+        self.current = math.exp(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def acosh(self):
+        self.result = False
+        self.current = math.acosh(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def asinh(self):
+        self.result = False
+        self.current = math.asinh(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def expm1(self):
+        self.result = False
+        self.current = math.expm1(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def lgamma(self):
+        self.result = False
+        self.current = math.lgamma(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def degrees(self):
+        self.result = False
+        self.current = math.degrees(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def log2(self):
+        self.result = False
+        self.current = math.log2(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def log10(self):
+        self.result = False
+        self.current = math.log10(float(txtDisplay.get()))
+        self.display(self.current)
+
+    def log1p(self):
+        self.result = False
+        self.current = math.log1p(float(txtDisplay.get()))
+        self.display(self.current)
+
+
+added_value = Calc()
+
+
+
+txtDisplay = Entry(calc, font=('Helvetica', 20, 'bold'), bg='black', fg='white', bd=30,
+                   width=28, justify=RIGHT)
+txtDisplay.grid(row=0, column=0, columnspan=4, pady=1)
+txtDisplay.insert(0, "0")
+
+
+
+numberpad = "789456123"
+i = 0
+btn = []
+for j in range(2, 5):
+    for k in range(3):
+        btn.append(Button(calc, width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                          bd=4, text=numberpad[i]))
+        btn[i].grid(row=j, column=k, pady=1)
+        btn[i]["command"] = lambda x=numberpad[i]: added_value.numberEnter(x)
+        i += 1
+
+
+btnClear = Button(calc, text=chr(67), width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold')
+                  , bd=4, command=added_value.Clear_Entry).grid(row=1, column=0, pady=1)
+
+btnAllClear = Button(calc, text=chr(67) + chr(69), width=6, height=2, bg='black', fg='white', font=('Helvetica'
+                                                                                                    , 20, 'bold'), bd=4,
+                     command=added_value.All_Clear_Entry).grid(row=1, column=1, pady=1)
+
+btnsq = Button(calc, text="\u221A", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+               bd=4, command=added_value.squared).grid(row=1, column=2, pady=1)
+
+btnAdd = Button(calc, text="+", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.operation("add")
+                ).grid(row=1, column=3, pady=1)
+
+btnSub = Button(calc, text="-", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.operation("sub")
+                ).grid(row=2, column=3, pady=1)
+
+btnMul = Button(calc, text="x", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.operation("multi")
+                ).grid(row=3, column=3, pady=1)
+
+btnDiv = Button(calc, text="/", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.operation("divide")
+                ).grid(row=4, column=3, pady=1)
+
+btnZero = Button(calc, text="0", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                 bd=4, command=lambda: added_value.numberEnter(0)
+                 ).grid(row=5, column=0, pady=1)
+
+btnDot = Button(calc, text=".", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.numberEnter(".")
+                ).grid(row=5, column=1, pady=1)
+btnPM = Button(calc, text=chr(177), width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+               bd=4, command=added_value.mathPM).grid(row=5, column=2, pady=1)
+
+btnEquals = Button(calc, text="=", width=6, height=2, bg='black', fg='white', font=('Helvetica', 20, 'bold'),
+                   bd=4, command=added_value.sum_of_total).grid(row=5, column=3, pady=1)
+
+
+
+btnPi = Button(calc, text="pi", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+               bd=4, command=added_value.pi).grid(row=1, column=4, pady=1)
+
+btnCos = Button(calc, text="Cos", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.cos).grid(row=1, column=5, pady=1)
+
+btntan = Button(calc, text="tan", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.tan).grid(row=1, column=6, pady=1)
+
+btnsin = Button(calc, text="sin", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.sin).grid(row=1, column=7, pady=1)
+
+
+btn2Pi = Button(calc, text="2pi", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.tau).grid(row=2, column=4, pady=1)
+
+btnCosh = Button(calc, text="Cosh", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                 bd=4, command=added_value.cosh).grid(row=2, column=5, pady=1)
+
+btntanh = Button(calc, text="tanh", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                 bd=4, command=added_value.tanh).grid(row=2, column=6, pady=1)
+
+btnsinh = Button(calc, text="sinh", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                 bd=4, command=added_value.sinh).grid(row=2, column=7, pady=1)
+
+
+btnlog = Button(calc, text="log", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.log).grid(row=3, column=4, pady=1)
+
+btnExp = Button(calc, text="exp", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.exp).grid(row=3, column=5, pady=1)
+
+btnMod = Button(calc, text="Mod", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=lambda: added_value.operation("mod")
+                ).grid(row=3, column=6, pady=1)
+
+btnE = Button(calc, text="e", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+              bd=4, command=added_value.e).grid(row=3, column=7, pady=1)
+
+
+btnlog10 = Button(calc, text="log10", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold')
+                  , bd=4, command=added_value.log10).grid(row=4, column=4, pady=1)
+
+btncos = Button(calc, text="log1p", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.log1p).grid(row=4, column=5, pady=1)
+
+btnexpm1 = Button(calc, text="expm1", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold')
+                  , bd=4, command=added_value.expm1).grid(row=4, column=6, pady=1)
+
+btngamma = Button(calc, text="gamma", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold')
+                  , bd=4, command=added_value.lgamma).grid(row=4, column=7, pady=1)
+
+
+
+btnlog2 = Button(calc, text="log2", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                 bd=4, command=added_value.log2).grid(row=5, column=4, pady=1)
+
+btndeg = Button(calc, text="deg", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                bd=4, command=added_value.degrees).grid(row=5, column=5, pady=1)
+
+btnacosh = Button(calc, text="acosh", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                  bd=4, command=added_value.acosh).grid(row=5, column=6, pady=1)
+
+btnasinh = Button(calc, text="asinh", width=6, height=2, bg='white', fg='black', font=('Helvetica', 20, 'bold'),
+                  bd=4, command=added_value.asinh).grid(row=5, column=7, pady=1)
+
+lblDisplay = Label(calc, text="Scientific Calculator", font=('Helvetica', 30, 'bold'),
+                   bg='black', fg='white', justify=CENTER)
+lblDisplay.grid(row=0, column=4, columnspan=4)
+
+
+
+def iExit():
+    iExit = tkinter.messagebox.askyesno("Scientific Calculator", "Do you want to exit ?")
+    if iExit > 0:
+        root.destroy()
+        return
+
+
+def Scientific():
+    root.resizable(width=False, height=False)
+    root.geometry("944x568+0+0")
+
+
+def Standard():
+    root.resizable(width=False, height=False)
+    root.geometry("480x568+0+0")
+
+
+
+menubar = Menu(calc)
+
+
+filemenu = Menu(menubar, tearoff=0)
+menubar.add_cascade(label='File', menu=filemenu)
+filemenu.add_command(label="Standard", command=Standard)
+filemenu.add_command(label="Scientific", command=Scientific)
+filemenu.add_separator()
+filemenu.add_command(label="Exit", command=iExit)
+
+
+editmenu = Menu(menubar, tearoff=0)
+menubar.add_cascade(label='Edit', menu=editmenu)
+editmenu.add_command(label="Cut")
+editmenu.add_command(label="Copy")
+editmenu.add_separator()
+editmenu.add_command(label="Paste")
+
+root.config(menu=menubar)
+
+root.mainloop()
diff --git a/segmented sieve b/segmented sieve
new file mode 100644
index 00000000..70d5feeb
--- /dev/null
+++ b/segmented sieve	
@@ -0,0 +1,31 @@
+// This functions finds all primes smaller than 'limit'
+// using simple sieve of eratosthenes.
+void simpleSieve(int limit)
+{
+	// Create a boolean array "mark[0..limit-1]" and
+	// initialize all entries of it as true. A value
+	// in mark[p] will finally be false if 'p' is Not
+	// a prime, else true.
+	bool mark[limit];
+	for(int i = 0; i<limit; i++) {
+	mark[i] = true;
+	}
+
+	// One by one traverse all numbers so that their
+	// multiples can be marked as composite.
+	for (int p=2; p*p<limit; p++)
+	{
+		// If p is not changed, then it is a prime
+		if (mark[p] == true)
+		{
+			// Update all multiples of p
+			for (int i=p*p; i<limit; i+=p)
+				mark[i] = false;
+		}
+	}
+
+	// Print all prime numbers and store them in prime
+	for (int p=2; p<limit; p++)
+		if (mark[p] == true)
+			cout << p << " ";
+}
diff --git a/selectionsort.cpp b/selectionsort.cpp
new file mode 100644
index 00000000..94349169
--- /dev/null
+++ b/selectionsort.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n;
+    cin >> n;
+    int arr[n];
+    for (int i = 0; i < n; i++)
+
+    {
+        cin >> arr[i];
+    }
+    for (int i = 0; i < n - 1; i++)
+    {
+        for (int j = i + 1; j < n; j++)
+        {
+            if (arr[j] < arr[i])
+            {
+                /* code */
+                int temp = arr[j];
+                arr[j] = arr[i];
+                arr[i] = temp;
+            }
+        }
+    }
+    for (int i = 0; i < n; i++)
+    {
+        /* code */
+        cout << arr[i] << " ";
+    }cout<<endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/shell short b/shell short
new file mode 100644
index 00000000..15913d14
--- /dev/null
+++ b/shell short	
@@ -0,0 +1,54 @@
+// C++ implementation of Shell Sort
+#include <iostream>
+using namespace std;
+
+/* function to sort arr using shellSort */
+int shellSort(int arr[], int n)
+{
+	// Start with a big gap, then reduce the gap
+	for (int gap = n/2; gap > 0; gap /= 2)
+	{
+		// Do a gapped insertion sort for this gap size.
+		// The first gap elements a[0..gap-1] are already in gapped order
+		// keep adding one more element until the entire array is
+		// gap sorted
+		for (int i = gap; i < n; i += 1)
+		{
+			// add a[i] to the elements that have been gap sorted
+			// save a[i] in temp and make a hole at position i
+			int temp = arr[i];
+
+			// shift earlier gap-sorted elements up until the correct
+			// location for a[i] is found
+			int j;		
+			for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
+				arr[j] = arr[j - gap];
+			
+			// put temp (the original a[i]) in its correct location
+			arr[j] = temp;
+		}
+	}
+	return 0;
+}
+
+void printArray(int arr[], int n)
+{
+	for (int i=0; i<n; i++)
+		cout << arr[i] << " ";
+}
+
+int main()
+{
+	int arr[] = {12, 34, 54, 2, 3}, i;
+	int n = sizeof(arr)/sizeof(arr[0]);
+
+	cout << "Array before sorting: \n";
+	printArray(arr, n);
+
+	shellSort(arr, n);
+
+	cout << "\nArray after sorting: \n";
+	printArray(arr, n);
+
+	return 0;
+}
diff --git a/shell_sort.py b/shell_sort.py
new file mode 100644
index 00000000..d385f17c
--- /dev/null
+++ b/shell_sort.py
@@ -0,0 +1,47 @@
+# Python program for implementation of Shell Sort
+
+def shellSort(arr):
+
+	# Start with a big gap, then reduce the gap
+	n = len(arr)
+	gap = n/2
+
+	# Do a gapped insertion sort for this gap size.
+	# The first gap elements a[0..gap-1] are already in gapped
+	# order keep adding one more element until the entire array
+	# is gap sorted
+	while gap > 0:
+
+		for i in range(gap,n):
+
+			# add a[i] to the elements that have been gap sorted
+			# save a[i] in temp and make a hole at position i
+			temp = arr[i]
+
+			# shift earlier gap-sorted elements up until the correct
+			# location for a[i] is found
+			j = i
+			while j >= gap and arr[j-gap] >temp:
+				arr[j] = arr[j-gap]
+				j -= gap
+
+			# put temp (the original a[i]) in its correct location
+			arr[j] = temp
+		gap /= 2
+
+
+# Driver code to test above
+arr = [ 132, 234, 554, 22, 43]
+
+n = len(arr)
+print ("Array before sorting:")
+for i in range(n):
+	print(arr[i]),
+
+shellSort(arr)
+
+print ("\nArray after sorting:")
+for i in range(n):
+	print(arr[i]),
+
+# This code is contributed by Nikhar Kesari
diff --git a/sieve of eratosthenes b/sieve of eratosthenes
new file mode 100644
index 00000000..ba18e646
--- /dev/null
+++ b/sieve of eratosthenes	
@@ -0,0 +1,49 @@
+// C++ program to print all primes
+// smaller than or equal to
+// n using Sieve of Eratosthenes
+#include <bits/stdc++.h>
+using namespace std;
+
+void SieveOfEratosthenes(int n)
+{
+	// Create a boolean array
+	// "prime[0..n]" and initialize
+	// all entries it as true.
+	// A value in prime[i] will
+	// finally be false if i is
+	// Not a prime, else true.
+	bool prime[n + 1];
+	memset(prime, true, sizeof(prime));
+
+	for (int p = 2; p * p <= n; p++)
+	{
+		// If prime[p] is not changed,
+		// then it is a prime
+		if (prime[p] == true)
+		{
+			// Update all multiples
+			// of p greater than or
+			// equal to the square of it
+			// numbers which are multiple
+			// of p and are less than p^2
+			// are already been marked.
+			for (int i = p * p; i <= n; i += p)
+				prime[i] = false;
+		}
+	}
+
+	// Print all prime numbers
+	for (int p = 2; p <= n; p++)
+		if (prime[p])
+			cout << p << " ";
+}
+
+// Driver Code
+int main()
+{
+	int n = 30;
+	cout << "Following are the prime numbers smaller "
+		<< " than or equal to " << n << endl;
+	SieveOfEratosthenes(n);
+	return 0;
+}
diff --git a/sign in and sign out.py b/sign in and sign out.py
new file mode 100644
index 00000000..d0964137
--- /dev/null
+++ b/sign in and sign out.py	
@@ -0,0 +1,20 @@
+n, maxSpan = map(int, list(input().split()))
+d= {}
+while n>0:
+    i, t, a = map(str, list(input().split()))
+    i = int(i)
+    t = int(t)
+    if i not in d:
+        d[i] = [t, 1]
+    else:
+        x = d[i][0]
+        x = abs(x-t)
+        d[i] = [x, d[i][1]+1]
+    n-=1
+
+l = []
+for j,i in d.items():
+    if i[1]==2 and i[0]<maxSpan:
+        l.append(i[0])
+
+print(l)
diff --git a/sort_a_stack_using_recursion.cpp b/sort_a_stack_using_recursion.cpp
new file mode 100644
index 00000000..9f5ebfcd
--- /dev/null
+++ b/sort_a_stack_using_recursion.cpp
@@ -0,0 +1,106 @@
+// C++ program to sort a stack using recursion
+#include <iostream>
+using namespace std;
+
+struct stack {
+	int data;
+	struct stack* next;
+};
+
+//  initialize stack
+void initStack(struct stack** s) { *s = NULL; }
+
+//  check if stack is empty
+int isEmpty(struct stack* s)
+{
+	if (s == NULL)
+		return 1;
+	return 0;
+}
+
+//  push an item to stack
+void push(struct stack** s, int x)
+{
+	struct stack* p = (struct stack*)malloc(sizeof(*p));
+
+	if (p == NULL) {
+		printf(stderr, "Memory allocation failed.\n");
+		return;
+	}
+
+	p->data = x;
+	p->next = *s;
+	*s = p;
+}
+
+// remove an item from stack
+int pop(struct stack** s)
+{
+	int x;
+	struct stack* temp;
+
+	x = (*s)->data;
+	temp = *s;
+	(*s) = (*s)->next;
+	free(temp);
+
+	return x;
+}
+
+// find top item
+int top(struct stack* s) { return (s->data); }
+
+void sortedInsert(struct stack** s, int x)
+{
+	if (isEmpty(*s) or x > top(*s)) {
+		push(s, x);
+		return;
+	}
+	int temp = pop(s);
+	sortedInsert(s, x);
+	push(s, temp);
+}
+
+// to sort stack
+void sortStack(struct stack** s)
+{
+	if (!isEmpty(*s)) {
+		
+		int x = pop(s);
+		sortStack(s);
+		sortedInsert(s, x);
+	}
+}
+
+//  to print contents of stack
+void printStack(struct stack* s)
+{
+	while (s) {
+		cout << s->data << " ";
+		s = s->next;
+	}
+	cout << "\n";
+}
+
+int main()
+{
+	struct stack* top;
+
+	initStack(&top);
+	push(&top, 30);
+	push(&top, -5);
+	push(&top, 18);
+	push(&top, 14);
+	push(&top, -3);
+
+	cout << "Stack elements before sorting:\n";
+	printStack(top);
+
+	sortStack(&top);
+	cout << "\n";
+
+	cout << "Stack elements after sorting:\n";
+	printStack(top);
+
+	return 0;
+}
diff --git a/sorted array.cpp b/sorted array.cpp
new file mode 100644
index 00000000..49b1eda9
--- /dev/null
+++ b/sorted array.cpp	
@@ -0,0 +1,52 @@
+// C++ program to merge two sorted arrays/
+#include<iostream>
+using namespace std;
+
+// Merge arr1[0..n1-1] and arr2[0..n2-1] into
+// arr3[0..n1+n2-1]
+void mergeArrays(int arr1[], int arr2[], int n1,
+							int n2, int arr3[])
+{
+	int i = 0, j = 0, k = 0;
+
+	// Traverse both array
+	while (i<n1 && j <n2)
+	{
+		// Check if current element of first
+		// array is smaller than current element
+		// of second array. If yes, store first
+		// array element and increment first array
+		// index. Otherwise do same with second array
+		if (arr1[i] < arr2[j])
+			arr3[k++] = arr1[i++];
+		else
+			arr3[k++] = arr2[j++];
+	}
+
+	// Store remaining elements of first array
+	while (i < n1)
+		arr3[k++] = arr1[i++];
+
+	// Store remaining elements of second array
+	while (j < n2)
+		arr3[k++] = arr2[j++];
+}
+
+// Driver code
+int main()
+{
+	int arr1[] = {1, 3, 5, 7};
+	int n1 = sizeof(arr1) / sizeof(arr1[0]);
+
+	int arr2[] = {2, 4, 6, 8};
+	int n2 = sizeof(arr2) / sizeof(arr2[0]);
+
+	int arr3[n1+n2];
+	mergeArrays(arr1, arr2, n1, n2, arr3);
+
+	cout << "Array after merging" <<endl;
+	for (int i=0; i < n1+n2; i++)
+		cout << arr3[i] << " ";
+
+	return 0;
+}
diff --git a/sorting.cpp b/sorting.cpp
new file mode 100644
index 00000000..18be1c6f
--- /dev/null
+++ b/sorting.cpp
@@ -0,0 +1,97 @@
+#include <iostream>
+using namespace std;
+void display(int ar[],int n)
+{
+    for(int i=0;i<n;i++)
+    {
+        cout<<ar[i]<<endl;
+    }
+}
+void Selection(int ar[], int n)
+{   int min=0,temp=0;
+    for( int i=0;i<n;i++)
+    {
+      min=i;
+      for(int j=i+1;j<n;j++)
+        {
+         if(ar[j]<ar[min])
+            {
+              min=j;
+                }
+                 }
+    temp=ar[i];
+    ar[i]=ar[min];
+    ar[min]=temp;
+    }
+}
+void Bubble(int ar[], int n)
+{   int temp=0;
+    for( int i=1;i<n;i++)
+    {
+      for(int j=0;j<n-1;j++)
+        {
+         if(ar[j]>ar[j+1])
+         {
+              temp=ar[j];
+              ar[j]=ar[j+1];
+              ar[j+1]=temp;
+         }}}}
+void Insertion(int ar[], int n)
+{   int key=0;
+    for( int i=1;i<n;i++)
+    {
+      key=ar[i];
+      int j=i-1;
+      while(j>=0&& key<ar[j]){
+          ar[j+1]=ar[j];
+          j--;
+      }
+    ar[j+1]=key;
+}}
+int main()
+{
+    char ch='y';
+    do{
+        cout<<"\n Hi! welcome do you want to continue (Y/N):"<<endl;
+        cin>>ch;
+        if(ch=='Y'||ch=='y')
+        {
+            int i,m,n;
+            cout<<"\n Enter your choice: \n 1.Selection sort\n 2.Bubble sort\n 3.Insertion sort"<<endl;
+            cin>>m;
+            cout<<"\n Enter the size of the array:"<<endl;
+            cin>>n;
+            int ar[n];
+            cout<<"\n Enter the elements:"<<endl;
+            for( i=0;i<n;i++)
+            {
+                cin>>ar[i];
+            }
+            switch(m)
+            {
+                case 1:
+                    Selection(ar,n);
+                    cout<<"\n Sorted array after Selection sort is:"<<endl;
+                    display(ar,n);
+                    break;
+                case 2:
+                    Bubble(ar,n);
+                    cout<<"\n Sorted array after Bubble sort is:"<<endl;
+                    display(ar,n);
+                    break;
+                case 3:
+                    Insertion(ar,n);
+                    cout<<"\n Sorted array after Insertion sort is:"<<endl;
+                    display(ar,n);
+                    break;
+                default:
+                cout<<"invalid choice";
+            }
+        }
+        else{
+            cout<<"\n Thank you program terminated";
+        }
+    }while(ch=='Y'||ch=='y');
+
+    return 0;
+}
diff --git a/sparse_matrix.cpp b/sparse_matrix.cpp
new file mode 100644
index 00000000..ff8b71a7
--- /dev/null
+++ b/sparse_matrix.cpp
@@ -0,0 +1,94 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+    int n,m,i,j,k=1,count=0;
+    cout<<"Enter value of n"<<endl;
+    cin>>n;
+    cout<<"Enter value of m"<<endl;
+    cin>>m;
+    int M1[n][m], M2[10][3];
+    cout<<"Enter the matrix"<<endl;
+    for(i=0;i<n;i++){
+        for(j=0;j<m;j++){
+            cin>>M1[i][j];
+        }
+    }
+
+    for(i=0;i<n;i++){
+        for(j=0;j<m;j++){
+            if(M1[i][j] != 0){
+                M2[k][0] = i;
+                M2[k][1] = j;
+                M2[k][2] = M1[i][j];
+                k++;
+                count++;
+            }
+        }
+    }
+
+    M2[0][0] = n;
+    M2[0][1] = m;
+    M2[0][2] = count;
+
+
+
+    cout<<"Sparse Matrix is:"<<endl;
+
+    for(i=0;i<k;i++){
+        for(j=0;j<3;j++){
+            cout<<M2[i][j]<<" ";
+        }
+        cout<<endl;
+    }
+
+}
+
+
+
+// #include<iostream>
+// using namespace std;
+
+// int main()
+// {
+//     int n,i,j,k=1,count=0;
+//     cout<<"Enter value of n"<<endl;
+//     cin>>n;
+//     int M1[n][n], M2[10][3];
+//     cout<<"Enter the matrix"<<endl;
+//     for(i=0;i<n;i++){
+//         for(j=0;j<n;j++){
+//             cin>>M1[i][j];
+//         }
+//     }
+
+//     for(i=0;i<n;i++){
+//         for(j=0;j<n;j++){
+//             if(M1[i][j] != 0){
+//                 M2[k][0] = i;
+//                 M2[k][1] = j;
+//                 M2[k][2] = M1[i][j];
+//                 k++;
+//                 count++;
+//             }
+//         }
+//     }
+
+//     M2[0][0] = n;
+//     M2[0][1] = n;
+//     M2[0][2] = count;
+
+
+
+//     cout<<"Sparse Matrix is:"<<endl;
+
+//     for(i=0;i<k;i++){
+//         for(j=0;j<3;j++){
+//             cout<<M2[i][j]<<" ";
+//         }
+//         cout<<endl;
+//     }
+
+// }
+
diff --git a/star-patterns.cpp b/star-patterns.cpp
new file mode 100644
index 00000000..6111f5a4
--- /dev/null
+++ b/star-patterns.cpp
@@ -0,0 +1,26 @@
+#include<iostream>
+using namespace std;
+int main()
+{
+int n, s, i, j;
+cout << "Enter number of rows: ";
+cin >> n;
+for(i = 0; i <= n; i++)
+{
+for(s = n; s > i; s--)
+cout << " ";
+for(j=0; j<i; j++)
+cout << "* ";
+cout << "\n";
+}
+for(i = 1; i < n; i++)
+{
+for(s = 0; s < i; s++)
+cout << " ";
+for(j = n; j > i; j--)
+cout << "* ";
+// ending line after each row
+cout << "\n";
+}
+return 0;
+}
diff --git a/stingReverse b/stingReverse
new file mode 100644
index 00000000..7004e99c
--- /dev/null
+++ b/stingReverse
@@ -0,0 +1,15 @@
+public class ReverseString_012 {
+    public static void main(String[] args) {
+        String sentence = "  Java is               oop lang    ";
+        String sen = sentence.trim();
+        String noSpaceStr = sen.replaceAll("\\s+", ",");
+        // using built in method(\s+ will match one or more whitespace characters)
+        String allSen[] = noSpaceStr.split(",");
+
+        for (int i = allSen.length - 1; i >= 0; i--) {
+
+            System.out.print(allSen[i] + " ");
+
+        }
+    }
+}
diff --git a/string subsequence b/string subsequence
new file mode 100644
index 00000000..5708242c
--- /dev/null
+++ b/string subsequence	
@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+#define fst ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+#define ll long long int 
+#include<algorithm>
+
+using namespace std;
+
+int subq(string input,string output[]){
+    if(input.empty()) {
+        output[0]="";
+        return 1;
+    }
+    string smallstring = input.substr(1);
+    int smallOutputsize = subq(smallstring,output);
+    for (int i = 0; i < smallOutputsize; i++)
+    {
+        output[i+smallOutputsize]=input[0]+output[i];
+    }
+    return 2*smallOutputsize;
+}
+
+int main(){
+    string input;
+    cin>>input;
+    string* output = new string[1000];
+    int count=subq(input,output);
+    for (int i = 0; i < count; i++)
+    {
+        cout<<output[i]<<endl;
+    }
+    
+    
+return 0;
+}
diff --git a/stringReversal.js b/stringReversal.js
new file mode 100644
index 00000000..15379d1e
--- /dev/null
+++ b/stringReversal.js
@@ -0,0 +1,5 @@
+describe("String Reversal", () => {
+ it("Should reverse string", () => {
+  assert.equal(reverse("Hello World!"), "!dlroW olleH");
+ });
+});
diff --git a/sudokusolver.cpp b/sudokusolver.cpp
new file mode 100644
index 00000000..9273219e
--- /dev/null
+++ b/sudokusolver.cpp
@@ -0,0 +1,42 @@
+class Solution {
+public:
+    void solveSudoku(vector<vector<char>>& board) {
+        solve(board);
+    }
+    
+    bool solve(vector<vector<char>>& board){
+        for(int i = 0; i < board.size(); i++){
+            for(int j = 0; j < board[0].size(); j++){
+                if(board[i][j] == '.'){
+                    for(char c = '1'; c <= '9'; c++){
+                        if(isValid(board, i, j, c)){
+                            board[i][j] = c; 
+                            
+                            if(solve(board))
+                                return true; 
+                            else
+                                board[i][j] = '.'; 
+                        }
+                    }
+                    
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    
+    bool isValid(vector<vector<char>>& board, int row, int col, char c){
+        for(int i = 0; i < 9; i++) {
+            if(board[i][col] == c) 
+                return false; 
+            
+            if(board[row][i] == c) 
+                return false; 
+            
+            if(board[3 * (row / 3) + i / 3][3 * (col / 3) + i % 3] == c) 
+                return false; 
+        }
+        return true;
+    }
+};
diff --git a/sum of array [Hackererank] b/sum of array [Hackererank]
new file mode 100644
index 00000000..972e73b6
--- /dev/null
+++ b/sum of array [Hackererank]	
@@ -0,0 +1,19 @@
+//This program is impemented in C language.
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#define N 1000
+
+int main() {
+    int x[N],n,i,t;
+        scanf("%d",&n);
+    for(i=0;i<n;i++)
+          if(i==0)    
+    {scanf("%d",&x[i]);t=x[i];}
+               else
+                 if(getchar()==' ')
+                  {scanf("%d",&x[i]);t=t+x[i];}
+    printf("%d",t);
+    return 0;
+}
diff --git a/swap.cpp b/swap.cpp
new file mode 100644
index 00000000..c4703e6a
--- /dev/null
+++ b/swap.cpp
@@ -0,0 +1,31 @@
+#include<iostream>
+using namespace std;
+
+void cyclicSwap(int *a, int *b, int *c);
+
+int main()
+{
+    int a, b, c;
+
+    cout << "Enter value of a, b and c respectively: ";
+    cin >> a >> b >> c;
+
+    cout << "Value before swapping: " << endl;
+    cout << "a, b and c respectively are: " << a << ", " << b << ", " << c << endl;
+
+    cyclicSwap(&a, &b, &c);
+
+    cout << "Value after swapping numbers in cycle: " << endl;
+    cout << "a, b and c respectively are: " << a << ", " << b << ", " << c << endl;
+
+    return 0;
+}
+
+void cyclicSwap(int *a, int *b, int *c)
+{
+    int temp;
+    temp = *b;
+    *b = *a;
+    *a = *c;
+    *c = temp;
+}
diff --git a/swapping b/swapping
new file mode 100644
index 00000000..a956a991
--- /dev/null
+++ b/swapping
@@ -0,0 +1,19 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int a = 5, b = 10, temp;
+
+    cout << "Before swapping." << endl;
+    cout << "a = " << a << ", b = " << b << endl;
+
+    temp = a;
+    a = b;
+    b = temp;
+
+    cout << "\nAfter swapping." << endl;
+    cout << "a = " << a << ", b = " << b << endl;
+
+    return 0;
+}
diff --git a/ternary search b/ternary search
new file mode 100644
index 00000000..8fa17967
--- /dev/null
+++ b/ternary search	
@@ -0,0 +1,14 @@
+double ternary_search(double l, double r) {
+    double eps = 1e-9;              //set the error limit here
+    while (r - l > eps) {
+        double m1 = l + (r - l) / 3;
+        double m2 = r - (r - l) / 3;
+        double f1 = f(m1);      //evaluates the function at m1
+        double f2 = f(m2);      //evaluates the function at m2
+        if (f1 < f2)
+            l = m1;
+        else
+            r = m2;
+    }
+    return f(l);                    //return the maximum of f(x) in [l, r]
+}
diff --git a/thebiggest.c b/thebiggest.c
new file mode 100644
index 00000000..91f1ac4a
--- /dev/null
+++ b/thebiggest.c
@@ -0,0 +1,14 @@
+#include<stdio.h>
+int main(){
+  int a,b,c;
+  scanf("%d%d%d",&a,&b,&c);
+  if (a>=b && a>=c)
+    printf("%d eh o maior\n",a);
+  else if (b>=c && b>=a)
+    printf("%d eh o maior\n",b);
+  else
+    printf("%d eh o maior\n",c);
+
+  
+  
+return 0;}
diff --git a/timer.py b/timer.py
new file mode 100644
index 00000000..b6f1cb13
--- /dev/null
+++ b/timer.py
@@ -0,0 +1,12 @@
+import time
+def countdown(time_sec):
+    while time_sec:
+        mins, secs = divmod(time_sec, 60)
+        timeformat = '{:02d}:{:02d}'.format(mins, secs)
+        print(timeformat, end='\r')
+        time.sleep(1)
+        time_sec -= 1
+    print("🔔 Times Up !!!")
+seconds = int(input("Enter total seconds to count: "))
+print("Timer Started for",seconds,"Seconds⏰")
+countdown(seconds)
diff --git a/transpose_a_matrix.cpp b/transpose_a_matrix.cpp
new file mode 100644
index 00000000..88b3e2e0
--- /dev/null
+++ b/transpose_a_matrix.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+   int a[10][10], transpose[10][10], row, column, i, j;
+
+   cout << "Enter rows and columns of matrix: ";
+   cin >> row >> column;
+
+   cout << "\nEnter elements of matrix: " << endl;
+
+   // Storing matrix elements
+   for (int i = 0; i < row; ++i) {
+      for (int j = 0; j < column; ++j) {
+         cout << "Enter element a" << i + 1 << j + 1 << ": ";
+         cin >> a[i][j];
+      }
+   }
+
+   // Printing the a matrix
+   cout << "\nEntered Matrix: " << endl;
+   for (int i = 0; i < row; ++i) {
+      for (int j = 0; j < column; ++j) {
+         cout << " " << a[i][j];
+         if (j == column - 1)
+            cout << endl << endl;
+      }
+   }
+
+   // Computing transpose of the matrix
+   for (int i = 0; i < row; ++i)
+      for (int j = 0; j < column; ++j) {
+         transpose[j][i] = a[i][j];
+      }
+
+   // Printing the transpose
+   cout << "\nTranspose of Matrix: " << endl;
+   for (int i = 0; i < column; ++i)
+      for (int j = 0; j < row; ++j) {
+         cout << " " << transpose[i][j];
+         if (j == row - 1)
+            cout << endl << endl;
+      }
+
+   return 0;
+}
diff --git a/transposegraph.cpp b/transposegraph.cpp
new file mode 100644
index 00000000..acd5397a
--- /dev/null
+++ b/transposegraph.cpp
@@ -0,0 +1,56 @@
+// CPP program to find transpose of a graph.
+#include <bits/stdc++.h>
+using namespace std;
+  
+// function to add an edge from vertex source to vertex dest
+void addEdge(vector<int> adj[], int src, int dest)
+{
+    adj[src].push_back(dest); 
+}
+  
+// function to print adjacency list of a graph
+void displayGraph(vector<int> adj[], int v)
+{
+    for (int i = 0; i < v; i++) {
+        cout << i << "--> ";
+        for (int j = 0; j < adj[i].size(); j++)
+            cout << adj[i][j] << "  ";
+        cout << "\n";
+    }
+}
+  
+
+void transposeGraph(vector<int> adj[], 
+                     vector<int> transpose[], int v)
+{
+    // traverse the adjacency list of given graph and
+    // for each edge (u, v) add an edge (v, u) in the
+    // transpose graph's adjacency list
+    for (int i = 0; i < v; i++)
+        for (int j = 0; j < adj[i].size(); j++)
+            addEdge(transpose, adj[i][j], i);
+}
+  
+int main()
+{
+    int v = 5;
+    vector<int> adj[v];
+    addEdge(adj, 0, 1);
+    addEdge(adj, 0, 4);
+    addEdge(adj, 0, 3);
+    addEdge(adj, 2, 0);
+    addEdge(adj, 3, 2);
+    addEdge(adj, 4, 1);
+    addEdge(adj, 4, 3);
+  
+    // Finding transpose of graph represented
+    // by adjacency list adj[]
+    vector<int> transpose[v];
+    transposeGraph(adj, transpose, v);
+  
+    // displaying adjacency list of transpose 
+    // graph i.e. b
+    displayGraph(transpose, v);
+  
+    return 0;
+}
\ No newline at end of file
diff --git a/trie_data_structure_String_search.cpp b/trie_data_structure_String_search.cpp
new file mode 100644
index 00000000..89621319
--- /dev/null
+++ b/trie_data_structure_String_search.cpp
@@ -0,0 +1,90 @@
+/*
+
+Author-Krishan singh karki
+Algorithm name-trie tree for seaching a string in n number of string
+this is trie tree data structure implementation in c++. We want to search 
+a string an array of string if string is present or not with trie data structure
+.Trie data structure has less time complexity as compared to linear search for large
+value of n.
+*/
+
+/*
+HACKTOBERFEST
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+struct trie//creating structure name trie
+{
+	struct trie*  m[26];//creating mapping for the 26 small latters alphabet
+	int end=0;//0 means not a leaf node  and 1 means it is a leaf node
+	
+};
+struct trie * BuildtrieTree(struct trie * root,string s, int start, int size){
+	if(start==size&&root==NULL){//cheking if this is last char of string and that node does not exist already
+		struct trie *temp;
+		temp=(struct trie*)malloc(sizeof(struct trie));//dynamically allocating memory
+		temp->end=1;
+		root=temp;
+	}
+	else if(start==size){//cheking if this is last char of string but node exist already 
+
+	}
+	else if(root!=NULL){//cheking for this is not last char in string and node for that char does not exist
+		//cout<<s;
+		root->end=0;
+		root->m[s[start]-'a']=BuildtrieTree( root->m[s[start]-'a'], s, start+1, size );//recursivly calling child node
+
+	}
+	else {// finally cheking for this is not last char but that char node exist already
+		struct trie *temp;
+		temp=(struct trie*)malloc(sizeof(struct trie));
+		temp->end=0;
+		root=temp;
+		root->m[s[start]-'a']=BuildtrieTree( root->m[s[start]-'a'], s, start+1, size );
+
+	}
+	
+	return root;
+}
+void checkString(struct trie *root, string s, int start ,int size){
+	if(start==size&&root->end==1){// if the start pointer has reached to the end and this is a leaf node
+		
+		cout<<"YES this string exist in the array of string ";
+	}
+	else if(root->m[s[start]-'a']!=NULL){//start pointer has not reached to the end and there are more 
+											              	//char left in  string to be searched
+		checkString(root->m[s[start]-'a'],s,start+1,size);//recursivly calling there child node
+	}
+	else{//start pointer has not reached to the end and no strings from all the string has meached to this string
+		cout<<"SORRY, this string does not exist in the array of string";
+	}
+
+}
+int main(){
+	struct trie *root = NULL;
+
+	//dynamcally alocating the first root node
+	root=(struct trie*)malloc(sizeof(struct trie));
+	root->end=1;
+
+	int num;
+	cout<<"Enter the number of strings you want to insert : ";
+	cin>>num;
+
+	string s[num];
+	cout<<endl<<"Enter your  strings : ";
+	for(int i=0;i<num;i++) cin>>s[i];
+
+	for(int i=0;i<num;i++)
+	root=BuildtrieTree(root,s[i],0,s[i].length());
+
+	cout<<endl<<"Enter string you want to search : ";
+	string s2;
+	cin>>s2;
+
+
+	checkString( root, s2, 0, s2.length());
+
+}
diff --git a/twoTreesIdenticalOrNot.java b/twoTreesIdenticalOrNot.java
new file mode 100644
index 00000000..7ead3a6d
--- /dev/null
+++ b/twoTreesIdenticalOrNot.java
@@ -0,0 +1,71 @@
+public class IdenticalTrees {
+
+    // Represent the node of the binary tree
+    public static class Node {
+        int data;
+        Node left;
+        Node right;
+
+        // Assign data to the new node, set left and right children to null
+        public Node(int data) {
+            this.data = data;
+            this.left = null;
+            this.right = null;
+        }
+    }
+
+    // Represent the root of the binary tree
+    public Node root;
+
+    public IdenticalTrees() {
+        root = null;
+    }
+
+    // areIdenticalTrees() finds whether two trees are identical or not
+    public static boolean areIdenticalTrees(Node root1, Node root2) {
+
+        // Checks if both the trees are empty
+        if (root1 == null && root2 == null)
+            return true;
+
+        // Trees are not identical if root of only one tree is null thus, return false
+        if (root1 == null && root2 == null)
+            return true;
+
+        // If both trees are not empty, check whether the data of the nodes is equal
+        // Repeat the steps for left subtree and right subtree
+        if (root1 != null && root2 != null) {
+
+            return ((root1.data == root2.data) && (areIdenticalTrees(root1.left, root2.left))
+                    && (areIdenticalTrees(root1.right, root2.right)));
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        //Example:
+        // Adding nodes to the first binary tree
+        IdenticalTrees bt1 = new IdenticalTrees();
+        bt1.root = new Node(1);
+        bt1.root.left = new Node(2);
+        bt1.root.right = new Node(3);
+        bt1.root.left.left = new Node(4);
+        bt1.root.right.left = new Node(5);
+        bt1.root.right.right = new Node(6);
+
+        // Adding nodes to the second binary tree
+        IdenticalTrees bt2 = new IdenticalTrees();
+        bt2.root = new Node(1);
+        bt2.root.left = new Node(2);
+        bt2.root.right = new Node(3);
+        bt2.root.left.left = new Node(4);
+        bt2.root.right.left = new Node(5);
+        bt2.root.right.right = new Node(6);
+
+        // Displays whether both the trees are identical or not
+        if (areIdenticalTrees(bt1.root, bt2.root))
+            System.out.println("Both the binary trees are identical");
+        else
+            System.out.println("Both the binary trees are not identical");
+    }
+}
diff --git a/two_sum.cpp b/two_sum.cpp
new file mode 100644
index 00000000..8096ce4e
--- /dev/null
+++ b/two_sum.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+vector<int> twoSum(vector<int>& nums, int target) {
+
+
+    unordered_map<int, int> hash;
+    vector<int> result;
+    for (int i = 0; i < nums.size(); i++)
+        if (hash.count(target - nums[i]))
+        {
+            result.push_back(hash[target - nums[i]]);
+            result.push_back(i);
+            return result;
+        }
+        else
+            hash[nums[i]] = i;
+    return result;
+}
+
+
+};
diff --git a/vector_sort.cpp b/vector_sort.cpp
new file mode 100644
index 00000000..75433500
--- /dev/null
+++ b/vector_sort.cpp
@@ -0,0 +1,45 @@
+// A C++ program to demonstrate working of sort(),
+// reverse()
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <numeric> //For accumulate operation
+using namespace std;
+ 
+int main()
+{
+    // Initializing vector with array values
+    int arr[] = {10, 20, 5, 23 ,42 , 15};
+    int n = sizeof(arr)/sizeof(arr[0]);
+    vector<int> vect(arr, arr+n);
+ 
+    cout << "Vector is: ";
+    for (int i=0; i<n; i++)
+        cout << vect[i] << " ";
+ 
+    // Sorting the Vector in Ascending order
+    sort(vect.begin(), vect.end());
+ 
+    cout << "\nVector after sorting is: ";
+    for (int i=0; i<n; i++)
+       cout << vect[i] << " ";
+ 
+    // Reversing the Vector
+    reverse(vect.begin(), vect.end());
+ 
+    cout << "\nVector after reversing is: ";
+    for (int i=0; i<6; i++)
+        cout << vect[i] << " ";
+ 
+    cout << "\nMaximum element of vector is: ";
+    cout << *max_element(vect.begin(), vect.end());
+ 
+    cout << "\nMinimum element of vector is: ";
+    cout << *min_element(vect.begin(), vect.end());
+ 
+    // Starting the summation from 0
+    cout << "\nThe summation of vector elements is: ";
+    cout << accumulate(vect.begin(), vect.end(), 0); 
+ 
+    return 0;
+}
diff --git a/vishss.html b/vishss.html
new file mode 100644
index 00000000..ae84bfa8
--- /dev/null
+++ b/vishss.html
@@ -0,0 +1,429 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>YTS torrent</title>
+    <link rel="stylesheet" href="style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@100;300;400;500;700;900&display=swap"
+        rel="stylesheet">
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Sofia">
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+
+</head>
+
+<body>
+
+    <header class="navbar">
+        <div class="navbar-logo">
+            <a href="/"><img src="icon/logo.png" height="40px" alt="yts torrent"></a>
+
+
+        </div>
+        <div>
+            <span class="header-slogan"> HD movies at the smallest file size</span>
+        </div>
+
+        <div class="wrap">
+            <div class="search">
+
+                <input type="search" class="searchterm " placeholder="        Quick search" />
+            </div>
+        </div>
+
+        <ul class="ul">
+            <li class="li">
+                <a class="a" href="#link">Home</a>
+            </li>
+            <li class="li">
+                <a class="a" href="#link">Browse Movies</a>
+            </li>
+        </ul>
+
+        <ul class="ul">
+            <li class="li">
+                <a class="a2" href="#link">Login</a>
+            </li>
+            |
+            <li class="li">
+                <a class="a2" href="#link">Register</a>
+            </li>
+        </ul>
+
+    </header>
+    <!--     ====================================================================================
+    ==========================================================================================================================================
+    =========================== = Main ----------------------------------------------------------------------------------------
+     -->
+
+
+
+    <div class="background-image">
+
+    </div>
+    <div class="background-overlay"> </div>
+
+
+    <!--  some text
+ -->
+
+ <section class="main-content">
+     <div class="home-content">
+         <div class="some-text">
+             <h1 class="line1">
+                Download YTS YIFY movies: HD smallest size
+
+             </h1>
+             <p class="para">
+                welcome to <b>YTS.MOVIES</b> website. Here you can browse and download YIFY movies in exellent 720p,
+                1080p, 2160p, and 3D quality, all at the smallest file size. YTS movies Torrent.
+
+             </p>
+         </div>
+         <div class="populer">
+            <h2><span class="star">&#9733;</span>
+
+                Popular Downloads</h2>
+             
+         </div>
+     </div>
+
+
+
+     <div class="block">
+        <div class="box"> 
+            <a href="#movie" class="aaa">
+                <img src="data/1.jpg" height="315" width="210" alt="" class="card">
+                
+                <figure class="figure">
+                    <div class="inside">
+                        <div class="r1">
+                            <span class="star">&#9733</span>
+                            <h4 class="rating">4.1/10</h4>
+                        </div>
+                        <div class="r2">
+                            <h4 class="ca">Action</h4>
+                            <h4 class="ca">Horror</h4>
+                        </div>
+                        <div class="r3">
+                            <span class="button1">View Details</span>
+                        </div>
+                    </div>
+                </figure>
+                
+                
+
+           
+            </a>
+
+            
+
+          
+            
+            <div class="card-bottom">
+                
+                <div class="card-title">
+                    Robot Ninja
+                </div>
+                <div class="card-year">
+                    1989
+                </div>
+            </div>
+         </div>
+
+         <div class="box"> 
+            <img src="data/2.jpg" height="315" width="210" alt="" class="card">
+            <div class="card-bottom">
+                <div class="card-title">
+                    Tadpole
+                </div>
+                <div class="card-year">
+                    2002
+                </div>
+            </div>
+         </div>
+
+         <div class="box">
+            <img src="data/3.jpg" height="315" width="210" alt="" class="card">
+            <div class="card-bottom">
+                <div class="card-title">
+                    My uncle is the green..
+                </div>
+                <div class="card-year">
+                    2014
+                </div>
+            </div>
+         </div>
+
+         <div class="box">
+            <img src="data/4.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Barbie video game hero
+                </div>
+                <div class="card-year">
+                    2017
+                </div>
+            </div>   
+     </div>
+     </div>
+
+
+     <div class="block">
+        <div class="box">
+            <img src="data/5.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    The Rise of the Synths
+                </div>
+                <div class="card-year">
+                    1984
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/6.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Disconnected
+                </div>
+                <div class="card-year">
+                    1984
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/7.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Call Him Mr. Shatter
+                </div>
+                <div class="card-year">
+                    1974
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/8.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Once Upon a Time at Christ...
+                </div>
+                <div class="card-year">
+                    2017
+                </div>
+            </div> 
+    </div>
+     </div>
+
+
+     <div class="block2">
+        <h2 class="latest-movies">Latest YIFY Movie Torrent</h2>
+
+        <div class="box">
+
+
+            <img src="data/9.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Radiohead: In Rainbows-Fr..
+                </div>
+                <div class="card-year">
+                    208
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/10.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Passion of Mind
+                </div>
+                <div class="card-year">
+                    2000
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/11.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Bank Robber
+                </div>
+                <div class="card-year">
+                    1993
+                </div>
+            </div>   
+        </div>
+
+        <div class="box">
+            <img src="data/12.jpg" height="315" width="210" alt="" class="card">  
+            <div class="card-bottom">
+                <div class="card-title">
+                    Eega Spoof by Kids
+                </div>
+                <div class="card-year">
+                    2013
+                </div>
+            </div>   
+        </div>
+
+
+        <div class="block2">
+            <div class="box">
+                <img src="data/13.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        Saving Sloane
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/14.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                            Time Now
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/15.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        Sleuth
+                    </div>
+                    <div class="card-year">
+                        1972
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/16.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        Language Lesson
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div>   
+            </div>
+        </div>
+
+        <div class="block">
+            <div class="box">
+                <img src="data/17.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        My Christmas Dream
+                    </div>
+                    <div class="card-year">
+                        2016
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/18.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        CNN Special Report The Tru..
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/19.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        Unzipped
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div>   
+            </div>
+    
+            <div class="box">
+                <img src="data/20.jpg" height="315" width="210" alt="" class="card">  
+                <div class="card-bottom">
+                    <div class="card-title">
+                        Attached: Paranormal    
+                    </div>
+                    <div class="card-year">
+                        2021
+                    </div>
+                </div> 
+            </div>
+        </div>
+
+
+
+        
+
+        
+     </div>
+     
+     <footer class="footer">
+        <div>
+            <ul class="footerlink">
+                <li>YTS @2011 - 2020</li>
+                <li>- </li>
+                <li>
+                    <a href="#home">Home</a>
+                </li>
+                <li> -</li>
+                <li>
+                    <a href="#dcmd">DCMA</a>
+                </li>
+                <li> -</li>
+                <li>
+                    <a href="#contact">Contact</a>
+                </li>
+                <li> </li>
+                <li>
+                    <a href="#rss">RSS feed</a>
+                </li>
+                <li>- </li>
+                <li>
+                    <a href="#blog">Blog</a>
+                </li>
+                <li> -</li>
+                <li>
+                    <a href="#browse movies">Browse movies</a>
+                </li>
+            </ul>
+        </div>
+   
+    </footer>
+
+
+ </section>
+
+
+
+
+</body>
+
+</html>
diff --git a/winexamp.java b/winexamp.java
new file mode 100644
index 00000000..8c42b5d8
--- /dev/null
+++ b/winexamp.java
@@ -0,0 +1,43 @@
+import java.awt.*;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+public class winexamp extends Frame implements WindowListener
+{
+winexamp(){
+addWindowListener(this);
+setSize(400,400);
+setLayout(null);
+setVisible(true);
+}
+public static void main(String args[])
+{
+new winexamp();
+}
+public void windowActivated(WindowEvent arg0)
+{
+System.out.println("Window Activated");
+}
+public void windowClosed(WindowEvent args0)
+{
+System.out.println("Window closed");
+}
+public void windowClosing(WindowEvent arg0)
+{
+System.out.println("Window closing");
+}
+public void windowDeactivated(WindowEvent arg0)
+{
+System.out.println("Window DEActivated");
+}
+public void windowDeiconified(WindowEvent arg0)
+{
+System.out.println("Window Deiconified");
+}
+public void windowIconified(WindowEvent arg0)
+{
+System.out.println("Window iconified");
+}
+public void windowOpened(WindowEvent arg0)
+{
+System.out.println("Window opened");
+}}
diff --git a/yjuyh b/yjuyh
new file mode 100644
index 00000000..28ce6a8b
--- /dev/null
+++ b/yjuyh
@@ -0,0 +1 @@
+m