From 5c0cb3f11820c4f1d44be5ea71aa8617c027e19b Mon Sep 17 00:00:00 2001
From: TheCodeyWizard <92143765+TheCodeyWizard@users.noreply.github.com>
Date: Tue, 4 Oct 2022 12:46:27 +0530
Subject: [PATCH 01/48] Add Kevin in Contributing.md

---
 CONTRIBUTING.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a375309..0417e12 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,2 +1,5 @@
 A repo for beginner contributors in hacktober 2022 , you can create a file and upload a new program and pull. MAke sure the program is error free. Multiple languages allowed .
 Happy coding.
+
+
+[Abhishek Kevin Gomes.txt](https://github.com/Anurag2622002/Codefornewccoder/files/9703528/Abhishek.Kevin.Gomes.txt)

From 0e038b7d4f631612898d06f563b012959ba7b5fe Mon Sep 17 00:00:00 2001
From: utksin13 <114904343+utksin13@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:01:33 +0530
Subject: [PATCH 02/48] Create c

---
 c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 c

diff --git a/c b/c
new file mode 100644
index 0000000..d0af7d7
--- /dev/null
+++ b/c
@@ -0,0 +1,65 @@
+#include<stdio.h>
+int removerepeated(int size,int a[]);
+void sort(int size,int a[]);
+main(){
+   int i,size1,size2,size,j=0,k;
+   printf("Enter size of an array1\n");
+   scanf("%d",&size1);
+   printf("Enter size of an array2\n");
+   scanf("%d",&size2);
+   int a[size1],b[size2],uni[size1+size2];
+   printf("Enter numbers for array 1\n");
+   for(i=0;i<size1;i++){
+      scanf("%d",&a[i]);
+   }
+   printf("Enter numbers for array 2\n");
+   for(i=0;i<size2;i++){
+      scanf("%d",&b[i]);
+   }
+   //union start
+   for(i=0;i<size1;i++){
+      uni[j]=a[i];
+      j++;
+   }
+   for(i=0;i<size2;i++){
+      uni[j]=b[i];
+      j++;
+   }
+   //Sorting
+   sort(size1+size2,uni);
+   //Remove repeated elements
+   size=removerepeated(size1+size2,uni);
+   printf("Array afetr Union \n");
+   for(i=0;i<size;i++){
+      printf("%d\n",uni[i]);
+   }
+   //Sorting
+}
+int removerepeated(int size,int a[]){
+   int i,j,k;
+   for(i=0;i<size;i++){
+      for(j=i+1;j<size;){
+         if(a[i]==a[j]){
+            for(k=j;k<size;k++){
+               a[k]=a[k+1];
+            }
+            size--;
+         }else{
+            j++;
+         }
+      }
+   }
+   return(size);
+}
+void sort(int size,int a[]){
+   int i,j,temp;
+   for(i=0;i<size;i++){
+      for(j=i+1;j<size;j++){
+         if(a[i]>a[j]){
+            temp=a[i];
+            a[i]=a[j];
+            a[j]=temp;
+         }
+      }
+   }
+}

From 93e010d427ea08037d98362fe882698d035833ef Mon Sep 17 00:00:00 2001
From: Ayushi Sagar <ayushisagar2000@gmail.com>
Date: Tue, 4 Oct 2022 13:04:09 +0530
Subject: [PATCH 03/48] BellmanFord

---
 BellmanFord.cpp | 56 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 BellmanFord.cpp

diff --git a/BellmanFord.cpp b/BellmanFord.cpp
new file mode 100644
index 0000000..047de33
--- /dev/null
+++ b/BellmanFord.cpp
@@ -0,0 +1,56 @@
+#include "bits/stdc++.h"
+using namespace std;
+
+const int INF = 1e9;
+
+int main(){
+    int n,m;cin>>n>>m;
+    vector<vector<int>> edges;
+    cout<<"u v w"<<endl;
+    for (int i = 0; i < m; i++)
+    {
+        int u,v,w;
+        cin>>u>>v>>w;
+        edges.push_back({u,v,w});
+    }
+    cout<<endl;
+    cout<<"SOURCE : "<<endl;
+    int src; cin>>src;
+    vector<int> dist(n,INF);
+    dist[src] = 0;
+    for (int iter = 0; iter < n-1; iter++)
+    {
+        bool change = false;
+
+        for(auto e : edges){
+            int u = e[0];
+            int v = e[1];
+            int w = e[2];
+
+            //for detection of cycle
+            if(dist[v] > w + dist[u]){
+                change = true;
+            }
+            dist[v] = min(dist[v], w + dist[u]);
+        }
+    }
+    cout<<"VERTEX     DISTANCE FROM SOURCE"<<endl;
+    for(int i=0;i<n;i++){
+        cout<<i<<"              "<<dist[i]<<endl;
+    }
+    cout<<endl;
+    
+    return 0;
+}
+
+// 5 8   
+// 1 2 3
+// 3 2 5
+// 1 3 2
+// 3 1 1
+// 1 4 2
+// 0 2 4
+// 4 3 -3
+// 0 1 -1
+// 0
+// 0 -1 2 -2 1 
\ No newline at end of file

From 04565af2a462bc0dde80ea598822a703669b78dc Mon Sep 17 00:00:00 2001
From: utksin13 <114904343+utksin13@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:04:49 +0530
Subject: [PATCH 04/48] Create create cc

---
 create cc | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 create cc

diff --git a/create cc b/create cc
new file mode 100644
index 0000000..d0af7d7
--- /dev/null
+++ b/create cc	
@@ -0,0 +1,65 @@
+#include<stdio.h>
+int removerepeated(int size,int a[]);
+void sort(int size,int a[]);
+main(){
+   int i,size1,size2,size,j=0,k;
+   printf("Enter size of an array1\n");
+   scanf("%d",&size1);
+   printf("Enter size of an array2\n");
+   scanf("%d",&size2);
+   int a[size1],b[size2],uni[size1+size2];
+   printf("Enter numbers for array 1\n");
+   for(i=0;i<size1;i++){
+      scanf("%d",&a[i]);
+   }
+   printf("Enter numbers for array 2\n");
+   for(i=0;i<size2;i++){
+      scanf("%d",&b[i]);
+   }
+   //union start
+   for(i=0;i<size1;i++){
+      uni[j]=a[i];
+      j++;
+   }
+   for(i=0;i<size2;i++){
+      uni[j]=b[i];
+      j++;
+   }
+   //Sorting
+   sort(size1+size2,uni);
+   //Remove repeated elements
+   size=removerepeated(size1+size2,uni);
+   printf("Array afetr Union \n");
+   for(i=0;i<size;i++){
+      printf("%d\n",uni[i]);
+   }
+   //Sorting
+}
+int removerepeated(int size,int a[]){
+   int i,j,k;
+   for(i=0;i<size;i++){
+      for(j=i+1;j<size;){
+         if(a[i]==a[j]){
+            for(k=j;k<size;k++){
+               a[k]=a[k+1];
+            }
+            size--;
+         }else{
+            j++;
+         }
+      }
+   }
+   return(size);
+}
+void sort(int size,int a[]){
+   int i,j,temp;
+   for(i=0;i<size;i++){
+      for(j=i+1;j<size;j++){
+         if(a[i]>a[j]){
+            temp=a[i];
+            a[i]=a[j];
+            a[j]=temp;
+         }
+      }
+   }
+}

From 4e102de5a318a3b06e14c2aef7314357e6f9b5e3 Mon Sep 17 00:00:00 2001
From: Shivam <shivamvats4321@gmail.com>
Date: Tue, 4 Oct 2022 13:08:52 +0530
Subject: [PATCH 05/48] FloydWarshall Algo

---
 FloydWarshallAlgo.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 FloydWarshallAlgo.cpp

diff --git a/FloydWarshallAlgo.cpp b/FloydWarshallAlgo.cpp
new file mode 100644
index 0000000..f05856f
--- /dev/null
+++ b/FloydWarshallAlgo.cpp
@@ -0,0 +1,47 @@
+#include "bits/stdc++.h"
+using namespace std;
+
+const int INF = 1e9;
+
+int main(){
+    vector<vector<int>> graph = 
+            {   {0,5,INF,10},
+                {INF,0,3,INF},
+                {INF,INF,0,1},
+                {INF,INF,INF,0}
+            };
+
+    int n = graph.size();
+    vector<vector<int>> dist = graph;
+    for(int k=0; k<n; k++){
+        for(int i=0; i<n; i++){
+            for(int j=0; j<n; j++){
+                if(dist[i][j] > dist[i][k] + dist[k][j]){
+                    dist[i][j] = dist[i][k] + dist[k][j];
+                }
+            }
+        }
+    }
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if(dist[i][j] == INF){
+                cout<<"INF ";
+            }
+            else{
+                cout<<dist[i][j]<<" ";
+            }
+        }
+        cout<<endl;
+        //1,3
+        cout<<dist[1][3];
+    }
+    
+    return 0;
+}
+
+// 0 5 8 9 
+// INF 0 3 4
+// INF INF 0 1
+// INF INF INF 0
\ No newline at end of file

From 3b1cc9e090e5aade8d86f388c30d62e9cb04bc45 Mon Sep 17 00:00:00 2001
From: Amritesh <48851357+amriteshgupta@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:28:36 +0530
Subject: [PATCH 06/48] Creating fIle of heap sort program

creating heap sort
---
 heap_Sort.c | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 heap_Sort.c

diff --git a/heap_Sort.c b/heap_Sort.c
new file mode 100644
index 0000000..d17647d
--- /dev/null
+++ b/heap_Sort.c
@@ -0,0 +1,106 @@
+ 
+// HEAP SORT USING ARRAY IMPLEMENTATION 
+
+
+#include<stdio.h>
+int a[20],n;
+
+void display()
+{ 
+int i;
+for(i=0;i<n;i++)
+printf ("%d",a[i]);
+printf ("\n");
+}
+
+void insert(int num,int loc)
+{
+int parent;
+while(loc>0)
+{
+parent=(loc-1)/2;
+if (num<=a[parent])
+{
+a[loc]=num;
+return;
+}
+a[loc]=a[parent];
+loc=parent;
+}
+a[0]=num;
+}
+
+void create_heap()
+{
+int i;
+for(i=0;i<n;i++)
+insert(a[i],i);
+}
+
+void del_root(int last)
+{
+int left,right,i,temp;
+i=0;
+
+temp=a[i];
+a[i]=a[last];
+a[last]=temp;
+left=2*i+1;
+right=2*i+2;
+while( right < last)
+{
+if ( a[i]>=a[left] && a[i]>=a[right] )
+return;
+if ( a[right]<=a[left] )
+{
+temp=a[i];
+a[i]=a[left];
+a[left]=temp;
+i=left;
+}
+else
+{
+temp=a[i];
+a[i]=a[right];
+a[right]=temp;
+i=right;
+}
+left=2*i+1;
+right=2*i+2;
+}
+if ( left==last-1 && a[i]<a[left] )
+{
+temp=a[i];
+a[i]=a[left];
+a[left]=temp;
+}
+}
+
+void heap_sort()
+{
+int last;
+for(last=n-1; last>0; last--)
+del_root(last);
+}
+
+void main()
+{
+int i;
+printf ("\nEnter number of elements :");
+scanf ("%d",&n);
+for(i=0;i<n;i++)
+{
+printf ("\nEnter element %d :",i+1);
+scanf ("%d",&a[i]);
+}
+printf ("\nEntered list is :\n");
+display();
+create_heap();
+printf ("\nHeap is :\n");
+display();
+heap_sort();
+printf ("\nSorted list is :\n");
+display();
+
+}
+

From 379d3277de7ae4d5d966cc21e6939d65a408a5bf Mon Sep 17 00:00:00 2001
From: Rudra Sharma <94120092+rudra016@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:29:32 +0530
Subject: [PATCH 07/48] MergeSort & MergeSortInPlace in JAVA

---
 mergeSort.java | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 mergeSort.java

diff --git a/mergeSort.java b/mergeSort.java
new file mode 100644
index 0000000..ea621df
--- /dev/null
+++ b/mergeSort.java
@@ -0,0 +1,88 @@
+import java.util.Arrays;
+
+public class mergeSort {
+    public static void main(String[] args) {
+    int[] arr = {5,32,12,31,2};
+     mergeSortInp(arr,0,arr.length);
+        System.out.println(Arrays.toString(arr));
+    }
+
+    static int[] mergesort(int[] arr) {
+        if (arr.length == 1) {
+            return arr;
+        }
+        int mid = arr.length / 2;
+        int[] left = mergesort(Arrays.copyOfRange(arr, 0, mid));
+        int[] right = mergesort(Arrays.copyOfRange(arr, mid, arr.length));
+        return merge(left, right);
+    }
+
+    private static int[] merge(int[] first, int[] second) {
+        int[] mix = new int[first.length + second.length];
+        int i = 0;
+
+        int j = 0;
+        int k = 0;
+        while (i < first.length && j < second.length) {
+            if (first[i] < second[j]) {
+                mix[k] = first[i];
+                i++;
+            } else {
+                mix[k] = second[j];
+                j++;
+            }
+            k++;
+        }
+        while (i < first.length) {
+            mix[k] = first[i];
+            i++;
+            k++;
+        }
+        while (j < second.length) {
+            mix[k] = second[j];
+            j++;
+            k++;
+        }
+        return mix;
+    }
+
+    static void mergeSortInp(int[] arr, int s, int e) {
+        if (e-s == 1) {
+            return;
+        }
+        int mid = (s+e)/2;
+        mergeSortInp(arr,s,mid);
+         mergeSortInp(arr,mid,e);
+         mergeInp(arr,s,mid,e);
+
+    }
+    private static void mergeInp(int[] arr,int s,int m,int e){
+        int[] mix = new int[e-s];
+        int i =s;
+        int j=m;
+        int k=0;
+        while(i<m&&j<e){
+            if(arr[i]<arr[j]){
+                mix[k]=arr[i];
+                i++;
+            }else{
+                mix[k]=arr[j];
+                j++;
+            }
+            k++;
+        }
+        while(i<m){
+            mix[k]=arr[i];
+            i++;
+            k++;
+        }
+        while(j<e){
+            mix[k]=arr[j];
+            j++;
+            k++;
+        }
+        System.arraycopy(mix, 0, arr, s + 0, mix.length);
+
+    }
+
+}

From 7ba3a5fcdbeffef9e89afbc005a72a8e2c220e77 Mon Sep 17 00:00:00 2001
From: Rudra Sharma <94120092+rudra016@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:34:46 +0530
Subject: [PATCH 08/48] Updated QuickSort by adding Recusion.

*Added Recursion.
---
 Quicksort.java | 80 ++++++++++++++++++++++++--------------------------
 1 file changed, 39 insertions(+), 41 deletions(-)

diff --git a/Quicksort.java b/Quicksort.java
index d2da1fa..4e11a35 100644
--- a/Quicksort.java
+++ b/Quicksort.java
@@ -1,47 +1,45 @@
 import java.io.*;
-class GFG {
-	static void swap(int[] arr, int i, int j)
-	{
-		int temp = arr[i];
-		arr[i] = arr[j];
-		arr[j] = temp;
-	}static int partition(int[] arr, int low, int high)
-	{
-	int pivot = arr[high];
-	int i = (low - 1);
+import java.util.Arrays;
 
-		for (int j = low; j <= high - 1; j++) {
-	if (arr[j] < pivot) {
-			i++;
-				swap(arr, i, j);
-			}
-		}
-		swap(arr, i + 1, high);
-		return (i + 1);
-	}
-	static void quickSort(int[] arr, int low, int high)
-	{
-		if (low < high) {
-		int pi = partition(arr, low, high);
-			quickSort(arr, low, pi - 1);
-			quickSort(arr, pi + 1, high);
-		}
-	}
-static void printArray(int[] arr, int size)
-	{
-		for (int i = 0; i < size; i++)
-			System.out.print(arr[i] + " ");
+public class QuickSort {
+    public static void main(String[] args) {
+        int[] arr = {5, 4, 3, 2, 1};
+//        sort(arr, 0, arr.length - 1);
+//        System.out.println(Arrays.toString(arr));
+        Arrays.sort(arr);
+    }
 
-		System.out.println();
-	}
+    static void sort(int[] nums, int low, int hi) {
+        if (low >= hi) {
+            return;
+        }
 
-	public static void main(String[] args)
-	{
-		int[] arr = { 10, 7, 8, 9, 1, 5 };
-		int n = arr.length;
+        int s = low;
+        int e = hi;
+        int m = s + (e - s) / 2;
+        int pivot = nums[m];
 
-		quickSort(arr, 0, n - 1);
-		System.out.println("Sorted array: ");
-		printArray(arr, n);
-	}
+        while (s <= e) {
+
+            // also a reason why if its already sorted it will not swap
+            while (nums[s] < pivot) {
+                s++;
+            }
+            while (nums[e] > pivot) {
+                e--;
+            }
+
+            if (s <= e) {
+                int temp = nums[s];
+                nums[s] = nums[e];
+                nums[e] = temp;
+                s++;
+                e--;
+            }
+        }
+
+        // now my pivot is at correct index, please sort two halves now
+        sort(nums, low, e);
+        sort(nums, s, hi);
+    }
 }

From 1215b87baedd9ef04b4e6bb4acd7126a2ed6b747 Mon Sep 17 00:00:00 2001
From: sahanmndl <mondalsahan053@gmail.com>
Date: Tue, 4 Oct 2022 13:35:22 +0530
Subject: [PATCH 09/48] Topological Sort CPP

---
 TopologicalSort.cpp | 75 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 TopologicalSort.cpp

diff --git a/TopologicalSort.cpp b/TopologicalSort.cpp
new file mode 100644
index 0000000..1ab6248
--- /dev/null
+++ b/TopologicalSort.cpp
@@ -0,0 +1,75 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+	public:
+    void dfs(int node, int vis[], stack<int> &st, vector<int> adj[]) {
+        vis[node] = 1;
+        
+        for(auto x : adj[node]) {
+            if(!vis[x]) {
+                dfs(x, vis, st, adj);
+            }
+        }
+        
+        st.push(node);
+    }
+	
+	vector<int> topoSort(int V, vector<int> adj[]) 
+	{
+	    int vis[V] = {0};
+	    stack<int> st;
+	    
+	    for(int i = 0; i < V; i++) {
+	        if(!vis[i]) {
+	            dfs(i, vis, st, adj);
+	        }
+	    }
+	    
+	    vector<int> ans;
+	    while(!st.empty()) {
+	        ans.push_back(st.top());
+	        st.pop();
+	    }
+	    
+	    return ans;
+	}
+};
+
+int check(int V, vector <int> &res, vector<int> adj[]) {
+    vector<int> map(V, -1);
+    for (int i = 0; i < V; i++) {
+        map[res[i]] = i;
+    }
+    for (int i = 0; i < V; i++) {
+        for (int v : adj[i]) {
+            if (map[i] > map[v]) return 0;
+        }
+    }
+    return 1;
+}
+
+int main() {
+    int T;
+    cin >> T;
+    while (T--) {
+        int N, E;
+        cin >> E >> N;
+        int u, v;
+
+        vector<int> adj[N];
+
+        for (int i = 0; i < E; i++) {
+            cin >> u >> v;
+            adj[u].push_back(v);
+        }
+        
+        Solution obj;
+        vector <int> res = obj.topoSort(N, adj);
+
+        cout << check(N, res, adj) << endl;
+    }
+    
+    return 0;
+}
\ No newline at end of file

From 96528d79adca8f985a13f9f22bee6951bf53ebb9 Mon Sep 17 00:00:00 2001
From: TheCodeyWizard <92143765+TheCodeyWizard@users.noreply.github.com>
Date: Tue, 4 Oct 2022 13:37:55 +0530
Subject: [PATCH 10/48] Create Diamond Pattern in Python

---
 Diamond Pattern in Python | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 Diamond Pattern in Python

diff --git a/Diamond Pattern in Python b/Diamond Pattern in Python
new file mode 100644
index 0000000..6be8698
--- /dev/null
+++ b/Diamond Pattern in Python	
@@ -0,0 +1,12 @@
+#Diamond Pattern in Python by Kevin
+
+n = 5
+print("Pattern 1")
+for a1 in range (0,n):
+    for a2 in range (a1):
+        print("*", end="")
+    print()
+for a1 in range (n,0,-1):
+    for a2 in range (a1):
+        print("*", end="")
+    print()

From 95fb189ee96b53e2c93d062b1eb78811446bf370 Mon Sep 17 00:00:00 2001
From: aarushiksk <aarushiksk@gmail.com>
Date: Tue, 4 Oct 2022 16:39:56 +0530
Subject: [PATCH 11/48] Display Affirmation

---
 AffirmationsInPython.py | 77 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 AffirmationsInPython.py

diff --git a/AffirmationsInPython.py b/AffirmationsInPython.py
new file mode 100644
index 0000000..02d4e9f
--- /dev/null
+++ b/AffirmationsInPython.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Oct  4 15:32:00 2022
+
+@author: aarus
+"""
+
+# Import turtle package
+import turtle
+  
+# Creating a turtle object(pen)
+pen = turtle.Turtle()
+  
+# Defining a method to draw curve
+def curve():
+    for i in range(200):
+  
+        # Defining step by step curve motion
+        pen.right(1)
+        pen.forward(1)
+  
+# Defining method to draw a full heart
+def heart():
+  
+    # Set the fill color to red
+    pen.fillcolor('red')
+  
+    # Start filling the color
+    pen.begin_fill()
+  
+    # Draw the left line
+    pen.left(140)
+    pen.forward(113)
+  
+    # Draw the left curve
+    curve()
+    pen.left(120)
+  
+    # Draw the right curve
+    curve()
+  
+    # Draw the right line
+    pen.forward(112)
+  
+    # Ending the filling of the color
+    pen.end_fill()
+  
+# Defining method to write text
+def txt():
+  
+    # Move turtle to air
+    pen.up()
+  
+    # Move turtle to a given position
+    pen.setpos(-68, 95)
+  
+    # Move the turtle to the ground
+    pen.down()
+  
+    # Set the text color to lightgreen
+    pen.color('black')
+  
+    # Write the specified text in 
+    # specified font style and size
+    pen.write("YOU MATTER!!", font=(
+      "Andada Pro", 15, "bold"))
+  
+
+    
+# Draw a heart
+heart()
+  
+# Write text
+txt()
+  
+# To hide turtle
+pen.ht()
\ No newline at end of file

From 7da735eecfdc0dccf0adf33b764a058c457d6fc5 Mon Sep 17 00:00:00 2001
From: Rishabh Jha <rishabhjha018@gmail.com>
Date: Tue, 4 Oct 2022 17:22:18 +0530
Subject: [PATCH 12/48] Tower of Hanoi using c

---
 TowerOfHanoi.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 TowerOfHanoi.c

diff --git a/TowerOfHanoi.c b/TowerOfHanoi.c
new file mode 100644
index 0000000..35359a0
--- /dev/null
+++ b/TowerOfHanoi.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <conio.h>
+
+void move(int n, char source, char dest, char spare)
+{
+  if (n == 1)
+    printf("\n Move from %c to %c", source, dest);
+  else
+  {
+    move(n - 1, source, spare, dest);
+    move(1, source, dest, spare);
+    move(n - 1, spare, dest, source);
+  }
+}
+int main()
+{
+  int n;
+  printf("\n Enter the number of rings: ");
+  scanf("%d", &n);
+  move(n, 'a', 'c', 'b');
+  return 0;
+}

From ce00ad586e8a439bacabc80b8160dc33e9fe1837 Mon Sep 17 00:00:00 2001
From: yashgoel2211 <114853033+yashgoel2211@users.noreply.github.com>
Date: Tue, 4 Oct 2022 17:30:28 +0530
Subject: [PATCH 13/48] Add files via upload

---
 hoursToWeek.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 hoursToWeek.java

diff --git a/hoursToWeek.java b/hoursToWeek.java
new file mode 100644
index 0000000..0c332d8
--- /dev/null
+++ b/hoursToWeek.java
@@ -0,0 +1,13 @@
+import java.util.*;
+public class Main 
+{
+   public static void main(String args[])
+   {
+        Scanner sc=new Scanner(System.in);
+
+        double hour = 450;
+        double week = 3.5;
+        double wk = hour / 168;
+        System.out.println("Value of "+hour+" hour in week: "+ wk);  
+   }
+}
\ No newline at end of file

From dbc5ea26a8f977391556130c2c8c323ee53f110c Mon Sep 17 00:00:00 2001
From: bhavy007 <44473716+bhavy007@users.noreply.github.com>
Date: Tue, 4 Oct 2022 17:45:35 +0530
Subject: [PATCH 14/48] added insertionSort

---
 insertionSort.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 insertionSort.py

diff --git a/insertionSort.py b/insertionSort.py
new file mode 100644
index 0000000..864bad9
--- /dev/null
+++ b/insertionSort.py
@@ -0,0 +1,23 @@
+# creating a function for insertion  
+def insertion_sort(list1):  
+  
+        # Outer loop to traverse through 1 to len(list1)  
+        for i in range(1, len(list1)):  
+  
+            value = list1[i]  
+  
+            # Move elements of list1[0..i-1], that are  
+            # greater than value, to one position ahead  
+            # of their current position  
+            j = i - 1  
+            while j >= 0 and value < list1[j]:  
+                list1[j + 1] = list1[j]  
+                j -= 1  
+            list1[j + 1] = value  
+        return list1  
+            # Driver code to test above  
+  
+list1 = [10, 5, 13, 8, 2]  
+print("The unsorted list is:", list1)  
+  
+print("The sorted list1 is:", insertion_sort(list1))  
\ No newline at end of file

From eb9eb84a80a0d9afca7d0823d0378fb57f60a068 Mon Sep 17 00:00:00 2001
From: chir263 <31371125+chir263@users.noreply.github.com>
Date: Tue, 4 Oct 2022 17:47:42 +0530
Subject: [PATCH 15/48] Longest increasing subsequence

---
 longest_increasing_subsequence.cpp | 56 ++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 longest_increasing_subsequence.cpp

diff --git a/longest_increasing_subsequence.cpp b/longest_increasing_subsequence.cpp
new file mode 100644
index 0000000..0cbd974
--- /dev/null
+++ b/longest_increasing_subsequence.cpp
@@ -0,0 +1,56 @@
+/* C++ implementation of LIS problem */
+#include <bits/stdc++.h>
+using namespace std;
+
+/* lis prints the length and the longest
+  increasing subsequence in arr[] of size n */
+void lis_and_print(int arr[], int n)
+{
+    int lis[n];
+
+    lis[0] = 1;
+
+    /* Compute optimized LIS values in
+       bottom up manner */
+    for (int i = 1; i < n; i++)
+    {
+        lis[i] = 1;
+        for (int j = 0; j < i; j++)
+            if (arr[i] > arr[j] && lis[i] < lis[j] + 1)
+                lis[i] = lis[j] + 1;
+    }
+
+    // maximum value in lis
+    int length = *max_element(lis, lis + n);
+
+    cout << "Length of LIS is " << length << "\n";
+
+    // Prints Longest increasing subsequence in arr[]
+
+    cout << "LIS is ";
+
+    vector<int> longest_inc_sub;
+    for (int i = n - 1; i >= 0; i--)
+    {
+        if (lis[i] == length)
+        {
+            longest_inc_sub.push_back(arr[i]);
+            length--;
+        }
+    }
+
+    reverse(longest_inc_sub.begin(), longest_inc_sub.end());
+
+    for (auto elem : longest_inc_sub)
+        cout << elem << " ";
+    cout << "\n";
+}
+
+/* Driver program to test above function */
+int main()
+{
+    int arr[] = {20, 32, 19, 43, 31, 60, 51, 70};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    lis_and_print(arr, n);
+    return 0;
+}
\ No newline at end of file

From 1549514fae0c14de8bb46104303a7097ae3c6b0b Mon Sep 17 00:00:00 2001
From: bhavy007 <44473716+bhavy007@users.noreply.github.com>
Date: Tue, 4 Oct 2022 17:57:35 +0530
Subject: [PATCH 16/48] added heapSort

---
 heapSort.cpp | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 heapSort.cpp

diff --git a/heapSort.cpp b/heapSort.cpp
new file mode 100644
index 0000000..36e3d94
--- /dev/null
+++ b/heapSort.cpp
@@ -0,0 +1,71 @@
+#include <iostream>
+ 
+using namespace std;
+ 
+// A function to heapify the array.
+void MaxHeapify(int a[], int i, int n)
+{
+	int j, temp;
+	temp = a[i];
+	j = 2*i;
+ 
+ 	while (j <= n)
+	{
+		if (j < n && a[j+1] > a[j])
+		j = j+1;
+		// Break if parent value is already greater than child value.
+		if (temp > a[j])
+			break;
+		// Switching value with the parent node if temp < a[j].
+		else if (temp <= a[j])
+		{
+			a[j/2] = a[j];
+			j = 2*j;
+		}
+	}
+	a[j/2] = temp;
+	return;
+}
+void HeapSort(int a[], int n)
+{
+	int i, temp;
+	for (i = n; i >= 2; i--)
+	{
+		// Storing maximum value at the end.
+		temp = a[i];
+		a[i] = a[1];
+		a[1] = temp;
+		// Building max heap of remaining element.
+		MaxHeapify(a, 1, i - 1);
+	}
+}
+void Build_MaxHeap(int a[], int n)
+{
+	int i;
+	for(i = n/2; i >= 1; i--)
+		MaxHeapify(a, i, n);
+}
+int main()
+{
+	int n, i;
+	cout<<"\nEnter the number of data element to be sorted: ";
+	cin>>n;
+	n++;
+	int arr[n];
+	for(i = 1; i < n; i++)
+	{
+		cout<<"Enter element "<<i<<": ";
+		cin>>arr[i];
+	}
+	// Building max heap.
+	Build_MaxHeap(arr, n-1);
+	HeapSort(arr, n-1);
+ 
+	// Printing the sorted data.
+	cout<<"\nSorted Data ";
+ 
+	for (i = 1; i < n; i++)
+		cout<<"->"<<arr[i];
+ 
+	return 0;
+}
\ No newline at end of file

From bb7b12d16ea1f1cb7c0c562eed2063647bb53f16 Mon Sep 17 00:00:00 2001
From: Vishal35679 <104795331+Vishal35679@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:10:32 +0530
Subject: [PATCH 17/48] Alternate element swap of an array

---
 AlternateSwap.cpp | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 AlternateSwap.cpp

diff --git a/AlternateSwap.cpp b/AlternateSwap.cpp
new file mode 100644
index 0000000..52a3211
--- /dev/null
+++ b/AlternateSwap.cpp
@@ -0,0 +1,35 @@
+#include <iostream>
+using namespace std;
+
+void swapAlternate(int arr[], int size)
+{
+    for (int i = 0; i < size; i += 2)
+    {
+        if (i + 1 < size)
+        {
+            swap(arr[i], arr[i + 1]);
+        }
+    }
+}
+
+void printArray(int arr[], int n)
+{
+    for (int i = 0; i < n; i++)
+    {
+        cout << arr[i] << " ";
+    }
+    cout << endl;
+}
+
+int main()
+{
+    int arr[8] = {1, 3, 5, 7, 9, 2, 6, 0};
+    int brr[5] = {1, 3, 5, 7, 9};
+
+    swapAlternate(arr, 8);
+    printArray(arr, 8);
+
+    swapAlternate(brr, 5);
+    printArray(brr, 5);
+    return 0;
+}
\ No newline at end of file

From 2b77079e9843e9be4d9b93520b9e77bd5186d945 Mon Sep 17 00:00:00 2001
From: Vishal35679 <104795331+Vishal35679@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:11:29 +0530
Subject: [PATCH 18/48] Simple atm program using switch

---
 atm.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 atm.c

diff --git a/atm.c b/atm.c
new file mode 100644
index 0000000..9fbf149
--- /dev/null
+++ b/atm.c
@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <conio.h>
+
+int currentbal,initialbal,withdraw,deposit,choice,i,pin;
+float principal, t, rate, SI;
+char transaction ='y';
+
+int main()
+{
+    while (pin != 3579)
+{
+    printf("ENTER YOUR PIN NUMBER: ");
+    scanf("%d", &pin);
+    if (pin != 3579)
+    printf("PLEASE ENTER VALID PASSWORD\n");
+}
+  
+printf("Enter initial balance:\n");
+scanf("%d",&initialbal);
+do{
+    printf("Select your choice:");
+    printf("*********Welcome to ATM Service*********\n");
+       printf("1. Check Balance\n");
+       printf("2. Deposit Cash\n");
+       printf("3. Withdraw Cash\n");
+       printf("4. View previous transaction\n");
+       printf("5. Calculate interest accrued in the account\n");
+       printf("6. Exit the application\n");
+       printf("Enter your choice: \n");
+       scanf("%d", &choice);
+  
+switch(choice)
+{
+    case 1:
+    printf("The current balance is Rs.%d", currentbal );
+    break;
+  
+    case 2:
+    printf("Enter the amount to deposit in the account: \n");
+    scanf("%d", &deposit);
+    currentbal = initialbal + deposit;
+    break;
+  
+    case 3:
+    printf("Enter the amount to withdraw from the account: \n");
+    scanf("%d", &withdraw);
+    currentbal = currentbal - withdraw;
+    break;
+  
+    case 4:
+    if(currentbal>initialbal)
+    printf("The overall deposit is made of Rs. %d\n", currentbal - initialbal);
+    else
+    printf("The overall withdrawal is made of Rs. %d\n", initialbal - currentbal);
+    break;
+  
+    case 5:
+    printf("Enter the principal amount: ");
+    scanf("%f", &principal);
+    printf("Enter the time period: ");
+    scanf("%f", &t);
+    printf("Enter the rate of interest: ");
+    scanf("%f", &rate);
+    SI = (principal * t * rate) / 100;
+    printf("Simple Interest for Principal Amount %.2f is %.2f", principal, SI);
+    break;
+  
+    case 6:
+    printf("Exiting Program\n");
+    break;
+  
+    default:
+    printf("\n INVALID CHOICE");
+}
+
+printf("\n\n\n DO U WISH TO HAVE ANOTHER TRANSCATION?(y/n): ");
+fflush(stdin);
+scanf("%c", &transaction);
+if (transaction == 'n'|| transaction == 'N')
+i = 0;
+} while (!i);
+
+printf("\n\n THANKS FOR USING OUR ATM SERVICE");
+}
\ No newline at end of file

From c6e1d42c0bc52281ee9204c0e193644b068e9a0d Mon Sep 17 00:00:00 2001
From: Vishal35679 <104795331+Vishal35679@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:12:27 +0530
Subject: [PATCH 19/48] nCr problem

---
 nCrProblem.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 nCrProblem.cpp

diff --git a/nCrProblem.cpp b/nCrProblem.cpp
new file mode 100644
index 0000000..0e83ad9
--- /dev/null
+++ b/nCrProblem.cpp
@@ -0,0 +1,30 @@
+#include <iostream>
+using namespace std;
+
+int factorial(int n)
+{
+    int fact=1;
+    for(int i=1; i<=n; i++)
+    {
+        fact = fact * i;
+    }
+    return fact;
+}
+
+int nCr(int n, int r)
+{
+    int num=factorial(n);
+    int den= factorial(r) * factorial(n-r);
+    int ans = num/den;
+    return ans;
+
+}
+
+int main()
+{
+    int n,r;
+    cin >> n >> r;
+    cout<< nCr(n,r) << endl;
+
+    return 0;
+}
\ No newline at end of file

From eeeff2e8b913323af90f57e6822d4afe228d6c8b Mon Sep 17 00:00:00 2001
From: Vishal35679 <104795331+Vishal35679@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:13:54 +0530
Subject: [PATCH 20/48] Decimal to Binary conversion code

---
 DecToBin.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 DecToBin.cpp

diff --git a/DecToBin.cpp b/DecToBin.cpp
new file mode 100644
index 0000000..81f6798
--- /dev/null
+++ b/DecToBin.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+#include <math.h>
+using namespace std;
+
+int main()
+{
+    int n;
+    cin >> n;
+    int ans=1; //0 to run in online compiler
+    int i=0;
+    while(n!=0)
+    {
+        int bit = n & 1;
+        ans = (bit * pow(10,i)) + ans;
+        n = n >> 1;
+        i++;
+    }
+    cout<< "Answer is " << ans <<endl;
+}
\ No newline at end of file

From b800abc5e209a4e19d37366395d1702180330d4b Mon Sep 17 00:00:00 2001
From: Vishal35679 <104795331+Vishal35679@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:14:27 +0530
Subject: [PATCH 21/48] Binary to Decimal Conversion code

---
 BinToDec.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 BinToDec.cpp

diff --git a/BinToDec.cpp b/BinToDec.cpp
new file mode 100644
index 0000000..e1d6475
--- /dev/null
+++ b/BinToDec.cpp
@@ -0,0 +1,19 @@
+#include <iostream>
+#include <math.h>
+using namespace std;
+
+int main()
+{
+    int n;
+    cin >> n;
+    int ans=0; 
+    int i=0;
+    while(n!=0)
+    {
+        int bit = n%10;
+        n/=10;
+        ans = (bit * pow(2,i)) + ans;
+        i++;
+    }
+    cout<< "Answer is " << ans <<endl;
+}
\ No newline at end of file

From 4ecdc21895e7297764c8250de771b265c04b1e37 Mon Sep 17 00:00:00 2001
From: kiranmayek <lcs2021022@iiitl.ac.in>
Date: Tue, 4 Oct 2022 18:39:35 +0530
Subject: [PATCH 22/48] added selection sort

---
 selection_sort.cpp | 76 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 selection_sort.cpp

diff --git a/selection_sort.cpp b/selection_sort.cpp
new file mode 100644
index 0000000..4e5eba9
--- /dev/null
+++ b/selection_sort.cpp
@@ -0,0 +1,76 @@
+/*
+Algorithm
+Step 1 − Set MIN to location 0
+Step 2 − Search the minimum element in the list
+Step 3 − Swap with value at location MIN
+Step 4 − Increment MIN to point to next element
+Step 5 − Repeat until list is sorted
+
+Pseudocode
+procedure selection sort 
+   list  : array of items
+   n     : size of list
+
+   for i = 1 to n - 1
+    set current element as minimum
+      min = i    
+  
+      check the element to be minimum 
+
+      for j = i+1 to n 
+         if list[j] < list[min] then
+            min = j;
+         end if
+      end for
+
+      swap the minimum element with the current element
+      if indexMin != i  then
+         swap list[min] and list[i]
+      end if
+   end for
+	
+end procedure
+
+Time Complexity = O(n^2);
+Space Complexity = O(1);
+*/
+
+#include<iostream>
+using namespace std;
+
+void readArray(int array[], int size){
+    for(int i = 0 ; i < size; i++){
+        cin >> array[i];
+    }
+}
+
+void printArray(int array[], int size){
+        for(int i = 0 ; i < size; i++){
+            cout << array[i] << " ";
+        }
+}
+
+void selectionSort(int array[], int size){
+    for(int i = 0; i < size - 1; i++){
+        int minIndex = i;
+
+        for(int j = i + 1; j < size; j++){
+            if(array[j] < array[minIndex]){
+                minIndex = j;
+            }
+        }
+        swap(array[minIndex], array[i]);
+    }
+}
+
+int main(){
+    int size;
+    cin >> size;
+    int array[size];
+    cout << "Enter the Elements of the Array. " << endl;
+    readArray(array, size);
+    selectionSort(array, size);
+    printArray(array, size);
+
+
+}
\ No newline at end of file

From 78ed0704461f02e333d34cebb5ceeb80363b6f81 Mon Sep 17 00:00:00 2001
From: Kamana54855 <114852248+Kamana54855@users.noreply.github.com>
Date: Tue, 4 Oct 2022 18:44:44 +0530
Subject: [PATCH 23/48] Add files via upload

---
 fibonacci.java | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 fibonacci.java

diff --git a/fibonacci.java b/fibonacci.java
new file mode 100644
index 0000000..c05978e
--- /dev/null
+++ b/fibonacci.java
@@ -0,0 +1,44 @@
+// Program to print fibonacci series followed by giver number by user...
+
+import java.util.Scanner;
+
+public class fibonacci {
+	
+	static int fib(int no)
+    {
+        if(no <= 1) {
+        	return no;
+        }
+        else {
+        	return fib(no - 1) + fib(no - 2);
+        }
+        
+    }
+	
+	//-------------------MAIN------------------------
+
+	public static void main(String[] args) {
+		
+		Scanner inp = new Scanner(System.in);
+		
+		while(true){
+			
+			System.out.print("Enter Number : ");
+			int no = inp.nextInt();
+			int stop = 000;
+			if(no == stop) {                    // If user enter 000 process will stop..
+				break;
+			}
+			else {
+				for (int i = 0; i < no; i++) {
+					System.out.print(fib(i) + " ");
+		        }
+				System.out.println(" ");
+				}
+			}
+			
+	}
+}
+
+
+//exit is a string , but we are taking input as integer ( int no = inp.nextInt(); ) , how to break while loop ?

From ba68ec69b785a501d6f6f1636d1d670481e22908 Mon Sep 17 00:00:00 2001
From: kiranmayek <lcs2021022@iiitl.ac.in>
Date: Tue, 4 Oct 2022 18:57:30 +0530
Subject: [PATCH 24/48] added binary search and counting frequency of each
 element in array using c++

---
 binary_search.cpp                            | 41 ++++++++++++++++++++
 count_frequency_of_each_element_in_array.cpp | 32 +++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 binary_search.cpp
 create mode 100644 count_frequency_of_each_element_in_array.cpp

diff --git a/binary_search.cpp b/binary_search.cpp
new file mode 100644
index 0000000..4ccae5d
--- /dev/null
+++ b/binary_search.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+using namespace std;
+
+int BinarySearch(int n, int search, int arr[])
+{
+    int s = 0;
+    int e = n;
+    int mid = (s + e) / 2;
+    while (s <= e)
+    {
+        if (arr[mid] == search)
+        {
+            return mid;
+        }
+        else if (arr[mid] < search)
+        {
+            s = mid + 1;
+        }
+        else{
+            e=mid-1;
+        }
+    }
+    return -1;
+}
+
+int main()
+{
+    int n;
+    cin >> n;
+    int arr[n];
+    for (int i = 0; i < n; i++)
+    {
+        cin >> arr[i];
+    }
+
+    int number;
+    cin >> number;
+    cout << BinarySearch(n, number, arr);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/count_frequency_of_each_element_in_array.cpp b/count_frequency_of_each_element_in_array.cpp
new file mode 100644
index 0000000..7b2f640
--- /dev/null
+++ b/count_frequency_of_each_element_in_array.cpp
@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+ 
+void countFreq(int arr[], int n)
+{
+    vector<bool> visited(n, false);
+ 
+    for (int i = 0; i < n; i++) {
+ 
+        // Skip this element if already processed
+        if (visited[i] == true)
+            continue;
+ 
+        // Count frequency
+        int count = 1;
+        for (int j = i + 1; j < n; j++) {
+            if (arr[i] == arr[j]) {
+                visited[j] = true;
+                count++;
+            }
+        }
+        cout << arr[i] << " " << count << endl;
+    }
+}
+ 
+int main()
+{
+    int arr[] = {10,5,10,15,10,5};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    countFreq(arr, n);
+    return 0;
+}
\ No newline at end of file

From d08c184a1966612439213edb06212555cae78a94 Mon Sep 17 00:00:00 2001
From: palak <palakhandelwalgp2gmail.com>
Date: Tue, 4 Oct 2022 19:15:57 +0530
Subject: [PATCH 25/48] added bfs and dfs in C

---
 BreadthFirstSearch.c | 37 +++++++++++++++++++++++++++++++++++++
 DepthFirstSearch.c   | 29 +++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+)
 create mode 100644 BreadthFirstSearch.c
 create mode 100644 DepthFirstSearch.c

diff --git a/BreadthFirstSearch.c b/BreadthFirstSearch.c
new file mode 100644
index 0000000..cdd3f72
--- /dev/null
+++ b/BreadthFirstSearch.c
@@ -0,0 +1,37 @@
+#include <stdio.h>
+void BFS(int a[10][10], int n, int src, int s[10])
+{
+    int f = 0, r = -1, q[20], i, v;
+    printf("Source Node: %d\n", src);
+    s[src] = 1;
+    q[++r] = src;
+    printf("Visited Nodes using BFS:\n");
+    while (f <= r)
+    {
+        v = q[f++];
+        for (i = 1; i <= n; i++)
+            if (s[i] == 0 && a[v][i])
+            {
+                q[++r] = i;
+                printf("%d\t", i);
+                s[i] = 1;
+            }
+    }
+}
+int main()
+{
+    int a[10][10], n, i, j, s[20], src;
+    printf("Enter no. of Nodes in Graph\n");
+    scanf("%d", &n);
+    printf("Enter the connections of Graph in Adjacency Matrix\n");
+    for (i = 1; i <= n; i++)
+        for (j = 1; j <= n; j++)
+            scanf("%d", &a[i][j]);
+    printf("Enter the Source Node\n");
+    scanf("%d", &src);
+    for (i = 1; i <= n; i++)
+        s[i] = 0;
+    BFS(a, n, src, s);
+    printf("\n");
+    return 0;
+}
diff --git a/DepthFirstSearch.c b/DepthFirstSearch.c
new file mode 100644
index 0000000..0bde005
--- /dev/null
+++ b/DepthFirstSearch.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+void DFS(int a[10][10], int n, int src, int s[10])
+{
+    int i;
+    s[src] = 1;
+    printf("%d\t", src);
+    for (i = 1; i <= n; i++)
+        if (s[i] == 0 && a[src][i])
+            DFS(a, n, i, s);
+}
+int main()
+{
+    int a[10][10], n, i, j, s[20], src;
+    printf("Enter no. of Nodes in Graph\n");
+    scanf("%d", &n);
+    printf("Enter the connections of Graph in Adjacency Matrix\n");
+    for (i = 1; i <= n; i++)
+        for (j = 1; j <= n; j++)
+            scanf("%d", &a[i][j]);
+    printf("Enter the Source Node\n");
+    scanf("%d", &src);
+    printf("Source Node = %d\n", src);
+    for (i = 1; i <= n; i++)
+        s[i] = 0;
+    printf("Visited Nodes using DFS:\n");
+    DFS(a, n, src, s);
+    printf("\n");
+    return 0;
+}
\ No newline at end of file

From 307a46ae2842a761995cd3d1787c06dbef80fc68 Mon Sep 17 00:00:00 2001
From: Sumit <sumitrauniyar03@gmail.com>
Date: Tue, 4 Oct 2022 19:42:25 +0530
Subject: [PATCH 26/48] My Commit

---
 decimaltobinary.c   |  29 +++++++++++++++++++++++++++++
 decimaltobinary.exe | Bin 0 -> 41446 bytes
 2 files changed, 29 insertions(+)
 create mode 100644 decimaltobinary.c
 create mode 100644 decimaltobinary.exe

diff --git a/decimaltobinary.c b/decimaltobinary.c
new file mode 100644
index 0000000..e1c082f
--- /dev/null
+++ b/decimaltobinary.c
@@ -0,0 +1,29 @@
+#include<stdio.h>
+#include<math.h>
+
+int main(){
+
+    int decimal_num,remainder,binary_num=0;
+    int i = 0;
+    
+   
+
+   printf("\n Enter The Decimal No: ");
+   scanf("%d", &decimal_num);
+   
+
+   while (decimal_num != 0)
+   {
+    remainder= decimal_num%2;
+    binary_num += remainder*pow(10,i);
+    decimal_num = decimal_num/2;
+    i++;
+}
+
+
+printf("\n The Binary Equivalent = %d",binary_num);
+
+return 0;
+
+}
+   
diff --git a/decimaltobinary.exe b/decimaltobinary.exe
new file mode 100644
index 0000000000000000000000000000000000000000..5b794e6e9b086035f2c7679d911e48424c2f2bd4
GIT binary patch
literal 41446
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
OrY_r&x#-#+_WuH<$*o%e

literal 0
HcmV?d00001


From 207015246418ad0be91dcd19885a3e05b6ea7ed6 Mon Sep 17 00:00:00 2001
From: bilwa496 <66560100+bilwa496@users.noreply.github.com>
Date: Tue, 4 Oct 2022 20:01:11 +0530
Subject: [PATCH 27/48] Created longest_palindromic_subsequence.cpp

Dynamic Programming based C++ program for LPS problem
---
 longest_palindromic_subsequence.cpp | 44 +++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 longest_palindromic_subsequence.cpp

diff --git a/longest_palindromic_subsequence.cpp b/longest_palindromic_subsequence.cpp
new file mode 100644
index 0000000..2ecc7b4
--- /dev/null
+++ b/longest_palindromic_subsequence.cpp
@@ -0,0 +1,44 @@
+// A Dynamic Programming based C++ program for LPS problem
+// Returns the length of the longest palindromic subsequence in seq
+#include<stdio.h>
+#include<string.h>
+
+int max (int x, int y) { return (x > y)? x : y; }
+
+int lps(char *str)
+{
+int n = strlen(str);
+int i, j, cl;
+int L[n][n]; 
+
+
+// Strings of length 1 are palindrome of length 1
+for (i = 0; i < n; i++)
+	L[i][i] = 1;
+
+	for (cl=2; cl<=n; cl++)
+	{
+		for (i=0; i<n-cl+1; i++)
+		{
+			j = i+cl-1;
+			if (str[i] == str[j] && cl == 2)
+			L[i][j] = 2;
+			else if (str[i] == str[j])
+			L[i][j] = L[i+1][j-1] + 2;
+			else
+			L[i][j] = max(L[i][j-1], L[i+1][j]);
+		}
+	}
+
+	return L[0][n-1];
+}
+
+/* Driver program to test above functions */
+int main()
+{
+	char seq[] = "GEEKS FOR GEEKS";
+	int n = strlen(seq);
+	printf ("The length of the LPS is %d", lps(seq));
+	getchar();
+	return 0;
+}

From 958cc2afa553af7d24c0a983c61cad3142927fe2 Mon Sep 17 00:00:00 2001
From: SouravSingh49 <89247293+darklordhere@users.noreply.github.com>
Date: Tue, 4 Oct 2022 20:02:01 +0530
Subject: [PATCH 28/48] Create Hollow_Rectangle_Pattern.cpp

---
 Hollow_Rectangle_Pattern.cpp | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 Hollow_Rectangle_Pattern.cpp

diff --git a/Hollow_Rectangle_Pattern.cpp b/Hollow_Rectangle_Pattern.cpp
new file mode 100644
index 0000000..c91c02f
--- /dev/null
+++ b/Hollow_Rectangle_Pattern.cpp
@@ -0,0 +1,32 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+
+    int rows, cols;
+    // Getting dimensions of rectangle
+    cout << "Enter the number of rows in rectangle - ";
+    cin >> rows;
+
+    cout << "Enter the number of columns in rectangle - ";
+    cin >> cols;
+
+
+    cout << "Rectangle of dimensions " << rows << "*" << cols << endl;
+
+    // Main logic to print hollow rectangle. 
+    for( int i = 0; i < rows; i++ ) {
+        for( int j = 0; j < cols; j++ ){
+
+            // If the index is at the border, then 
+            // print *. 
+            if( i == 0 || i == rows - 1 || j == 0 || j == cols -1 )
+                cout<<"* ";
+            else 
+                cout<<"  ";
+        }
+        cout<<endl;
+    }
+
+    return 0;
+}

From e9db3ae7e87ce4b9b694207e993a530d1a08b279 Mon Sep 17 00:00:00 2001
From: Ayush1347 <75846927+Ayush1347@users.noreply.github.com>
Date: Tue, 4 Oct 2022 20:08:44 +0530
Subject: [PATCH 29/48] Create Fibonnaci.py

---
 Fibonnaci.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 Fibonnaci.py

diff --git a/Fibonnaci.py b/Fibonnaci.py
new file mode 100644
index 0000000..fe666f3
--- /dev/null
+++ b/Fibonnaci.py
@@ -0,0 +1,17 @@
+#Fibonacci series in Python
+
+def recur_fibo(n):
+   if n <= 1:
+       return n
+   else:
+       return(recur_fibo(n-1) + recur_fibo(n-2))
+
+nterms = 10
+
+# checking number is negative or positive if negative then enter positive number and if positive then print series
+if nterms <= 0:
+   print("Plese enter a positive integer")
+else:
+   print("Fibonacci sequence:")
+   for i in range(nterms):
+       print(recur_fibo(i))

From 226e746c1302b145fe97827da93203ff77bdb041 Mon Sep 17 00:00:00 2001
From: Ayush1347 <75846927+Ayush1347@users.noreply.github.com>
Date: Tue, 4 Oct 2022 20:24:14 +0530
Subject: [PATCH 30/48] Create Tower of Hanoi.py

---
 Tower of Hanoi.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 Tower of Hanoi.py

diff --git a/Tower of Hanoi.py b/Tower of Hanoi.py
new file mode 100644
index 0000000..cbf4246
--- /dev/null
+++ b/Tower of Hanoi.py	
@@ -0,0 +1,14 @@
+#Tower of Hanoi
+def tower_of_hanoi(disks, source, auxiliary, target):  
+    if(disks == 1):  
+        print('Move disk 1 from rod {} to rod {}.'.format(source, target))  
+        return  
+    # function call itself  
+    tower_of_hanoi(disks - 1, source, target, auxiliary)  
+    print('Move disk {} from rod {} to rod {}.'.format(disks, source, target))  
+    tower_of_hanoi(disks - 1, auxiliary, source, target)  
+  
+  
+disks = int(input('Enter the number of disks: '))  
+# We are referring source as A, auxiliary as B, and target as C  
+tower_of_hanoi(disks, 'A', 'B', 'C')

From 68370170942d7fc161d66ab18d8a1cff82296f59 Mon Sep 17 00:00:00 2001
From: borkarSahil <officialsahilborkar@gmail.com>
Date: Tue, 4 Oct 2022 20:34:15 +0530
Subject: [PATCH 31/48] Reverse the K group in Linked List

---
 reverseKgrpLinkedList.cpp | 86 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 reverseKgrpLinkedList.cpp

diff --git a/reverseKgrpLinkedList.cpp b/reverseKgrpLinkedList.cpp
new file mode 100644
index 0000000..d7a5d38
--- /dev/null
+++ b/reverseKgrpLinkedList.cpp
@@ -0,0 +1,86 @@
+#include <iostream>
+using namespace std ;
+
+class Node{
+    public:
+    int data;
+    Node* next;
+
+// CONSTRUCTOR    
+Node(int data){
+    this -> data = data ;
+    this -> next = NULL;
+}
+};
+
+void insertAtHead( Node* &head,int data){
+    Node* New = new Node(data);
+    New -> next = head ;
+    head = New ;
+};
+
+void print(Node* head){
+  Node* New = head ;
+  while (New != NULL)
+  {
+    cout << New -> data << " ";
+    New = New -> next ;
+  }
+  cout << endl ;
+};
+
+Node* reversekGroup(Node* head,int k){
+
+    if (head == NULL )
+    {
+        return NULL ;
+    }
+    
+
+  Node* forward = NULL ;
+  Node* prev = NULL ;
+  Node* current = head ;
+  int count = 0;
+
+  while (current != NULL && count < k)
+  {
+    forward = current -> next ;
+    current -> next = prev ;
+    prev = current ;
+    current = forward ;
+    count++;
+  }
+
+     if (forward != NULL )
+    {
+       head -> next = reversekGroup(forward,k);
+    }    
+
+  return prev ;
+
+};
+
+int main(){
+    
+    Node* head = NULL ;
+
+    insertAtHead(head,10);
+    print(head);
+
+     insertAtHead(head,20);
+    print(head);
+
+ insertAtHead(head,30);
+    print(head);
+
+ insertAtHead(head,40);
+    print(head);
+
+   insertAtHead(head,50);
+    print(head);
+cout << " REVERSE "<<endl;
+int k; cin >> k ;
+head = reversekGroup(head,k);
+print(head);
+    return 0;
+}
\ No newline at end of file

From 63158d826c473ba2d3c0f0ce82ad8afb62e07a72 Mon Sep 17 00:00:00 2001
From: Rashmi Kumari <76115061+thakurRashmi@users.noreply.github.com>
Date: Tue, 4 Oct 2022 22:13:48 +0530
Subject: [PATCH 32/48] Create BubbleSort_OptimisedCode.cpp

This is an optimized code for implementing Bubble Sort in C++ language. The time complexities in the best and worst cases will be O(n) and O(n^2) respectively.
---
 BubbleSort_OptimisedCode.cpp | 63 ++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 BubbleSort_OptimisedCode.cpp

diff --git a/BubbleSort_OptimisedCode.cpp b/BubbleSort_OptimisedCode.cpp
new file mode 100644
index 0000000..ce4b3e5
--- /dev/null
+++ b/BubbleSort_OptimisedCode.cpp
@@ -0,0 +1,63 @@
+// Optimized implementation of Bubble sort to avoid extra spaces.
+
+#include <iostream>
+#include <bits/stdc++.h>
+using namespace std;
+
+
+void bubbleSort(int arr[], int n)
+{
+    int i, j, flag, temp;
+
+   for (i = 0; i < n-1; i++)
+  {
+	flag=0;
+	for (j = 0; j < n-1-i; j++)
+	{
+		if (arr[j] > arr[j+1])
+		{
+		   temp=arr[j];
+		   arr[j]=arr[j+1];
+		   arr[j+1]=temp;
+		   flag=1;
+		}
+	}
+
+	// IF no two elements were swapped
+	// by inner loop, then break
+	if (flag==0)
+		break;
+  }
+}
+
+// Function to print an array
+void printArray(int arr[], int size)
+{
+	    for (int i = 0; i < size; i++)
+            {
+		cout <<" "<< arr[i];
+            }
+}
+
+// Driver program to test above functions
+int main()
+{
+        int n;// size of the array
+	cout<<"Enter the size of Array"<<endl;
+	cin>>n;
+	
+	int arr[n];
+	cout<<"Enter the elements of the Array"<<endl;
+	for(int i=0; i<n; i++)
+	{
+	    cin>>arr[i];
+	}
+	
+	bubbleSort(arr, n);
+	cout <<"Sorted array: \n";
+	printArray(arr, n);
+	return 0;
+}
+// Time Complexity:
+// Best Case: O(n)
+// Worst case: O(n^2)

From c6c703d8d99ccb1328d6f1780005202c40c9a07f Mon Sep 17 00:00:00 2001
From: Nishant Rathore <74294802+RinzlerN26@users.noreply.github.com>
Date: Tue, 4 Oct 2022 22:23:49 +0530
Subject: [PATCH 33/48] Added Shell Sort Code

---
 ShellSort.cpp | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 ShellSort.cpp

diff --git a/ShellSort.cpp b/ShellSort.cpp
new file mode 100644
index 0000000..7f7df39
--- /dev/null
+++ b/ShellSort.cpp
@@ -0,0 +1,41 @@
+#include  <iostream>
+using namespace std;
+
+// shell sort implementation
+int shellSort(int arr[], int N)
+{
+    for (int gap = N/2; gap > 0; gap /= 2)
+       {
+    for (int i = gap; i < N; i += 1)
+       {
+            //sort sub lists created by applying gap
+int temp = arr[i];
+
+int j;
+for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
+arr[j] = arr[j - gap];
+
+arr[j] = temp;
+        }
+    }
+    return 0;
+}
+
+int main()
+{
+    int arr[] = {45,23,53,43,18,24,8,95,101}, i;
+    //Calculate size of array
+    int N = sizeof(arr)/sizeof(arr[0]);
+
+    cout << "Array to be sorted: \n";
+    for (int i=0; i<N; i++)
+        cout << arr[i] << " ";
+
+    shellSort(arr, N);
+
+    cout << "\nArray after shell sort: \n";
+    for (int i=0; i<N; i++)
+        cout << arr[i] << " ";
+
+    return 0;
+}

From aa063859b58573013fced9417132df06cebc31c7 Mon Sep 17 00:00:00 2001
From: ankitb2023 <105578036+ankitb2023@users.noreply.github.com>
Date: Tue, 4 Oct 2022 22:44:06 +0530
Subject: [PATCH 34/48] Create generateparantheses.cpp

---
 generateparantheses.cpp | 42 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 generateparantheses.cpp

diff --git a/generateparantheses.cpp b/generateparantheses.cpp
new file mode 100644
index 0000000..b0af342
--- /dev/null
+++ b/generateparantheses.cpp
@@ -0,0 +1,42 @@
+/*
+
+22. Generate Parentheses
+Medium
+15.4K
+588
+Companies
+Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+*/
+
+class Solution {
+public:
+    vector<string>result;
+    
+    void helper(int open,int close,int n,string current)
+    {
+        if(current.length()==n*2)
+        {
+            result.push_back(current);
+            return;
+        }
+        if(open<n)  helper(open+1,close,n,current+"(");
+        if(close<open)  helper(open,close+1,n,current+")");
+    }
+    vector<string> generateParenthesis(int n) {
+        helper(0,0,n,"");
+        return result;
+    }
+};
+// Intuition: Since we are asked to calculate all the possible permutations of brackets , hence we have to use backtracking
+
+// Concept: In every backtracking problem , there are two things to keep in mind , which we will explore here as well :
+
+// Base Case: Every problem of backtracking has some base case which tells us at which point we have to stop with the recursion process. In our case, when the length of our string has reached the maximum length(n*2), we stop with the recursion for that case and that is our base case.
+
+// Conditions: On observing carefully we find that there are two conditions present:
+
+// For adding (: If number of opening brackets(open) is less than the the given length(n) i.e.
+// if max<n, then we can add (,else not.
+// For adding ): If number of close brackets(close) is less than the opening brackets(open), i.e.
+// if open<close, we can add ), else not
+// And thats it!!! Keeping these two things in mind here is the code:

From b8b384d66a394851c49c1edbd9224fe9463396ab Mon Sep 17 00:00:00 2001
From: Shubham Gaur <94301988+404shubham@users.noreply.github.com>
Date: Tue, 4 Oct 2022 22:56:50 +0530
Subject: [PATCH 35/48] Binary search algorithim in C

Binary search requires an sorted array, traversing though it, the algorithim finds the matching given element in the array, and returns the index of the element.
---
 Binary Search | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 Binary Search

diff --git a/Binary Search b/Binary Search
new file mode 100644
index 0000000..97bc87d
--- /dev/null
+++ b/Binary Search	
@@ -0,0 +1,31 @@
+//code for binnary search algorithim in C
+
+#include <stdio.h>
+
+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 = binarySearch(arr, 0, n - 1, x);
+	(result == -1)
+		? printf("Element is not present in array")
+		: printf("Element is present at index %d", result);
+	return 0;
+}

From 3f3cc6e08be01baaafbb7163849b8e370fee444b Mon Sep 17 00:00:00 2001
From: Shubham Gaur <94301988+404shubham@users.noreply.github.com>
Date: Tue, 4 Oct 2022 23:20:37 +0530
Subject: [PATCH 36/48] Insertion sort algorithims

Insertion sort algorithim works by  comparing every key to it's predecessor, elements are compared multiple times though the algorithim.
---
 Insertion Sort | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 Insertion Sort

diff --git a/Insertion Sort b/Insertion Sort
new file mode 100644
index 0000000..1103315
--- /dev/null
+++ b/Insertion Sort	
@@ -0,0 +1,36 @@
+#include <math.h>
+#include <stdio.h>
+
+void insertionSort(int arr[], int n)
+{
+	int i, key, j;
+	for (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;
+	}
+}
+
+void printArray(int arr[], int n)
+{
+	int i;
+	for (i = 0; i < n; i++)
+		printf("%d ", arr[i]);
+	printf("\n");
+}
+
+int main()
+{
+	int arr[] = { 12, 11, 13, 5, 6 };
+	int n = sizeof(arr) / sizeof(arr[0]);
+
+	insertionSort(arr, n);
+	printArray(arr, n);
+
+	return 0;
+}

From 40627b95f04adf24919131768a581dc8ecfb4063 Mon Sep 17 00:00:00 2001
From: Shivam Chopra <60386222+imshivam18@users.noreply.github.com>
Date: Tue, 4 Oct 2022 23:34:56 +0530
Subject: [PATCH 37/48] Tower of Hanoi Problem using Recursion in C++

---
 TowerogHanoi | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 TowerogHanoi

diff --git a/TowerogHanoi b/TowerogHanoi
new file mode 100644
index 0000000..d123643
--- /dev/null
+++ b/TowerogHanoi
@@ -0,0 +1,24 @@
+#include<iostream> 
+using namespace std;
+
+//  Tower of Hanoi
+
+ void TowerOfHanoi(int n, char source, char destiny, char helper)
+{
+	if(n==0)
+	{
+		return ;
+	}
+
+	TowerOfHanoi(n-1,source,helper,destiny);
+	cout << "Moving from " << source << " to " << destiny << endl ;
+	TowerOfHanoi(n-1,helper,destiny,source);
+}
+
+int main()
+{
+	int n;
+	cin >> n;
+	TowerOfHanoi(n,'A','C','B');
+	return 0;
+}

From 5431089d4998238dce95bd46367429efd9477191 Mon Sep 17 00:00:00 2001
From: shrutij1247 <114980144+shrutij1247@users.noreply.github.com>
Date: Tue, 4 Oct 2022 23:36:33 +0530
Subject: [PATCH 38/48] Create Cocktail Sort.cpp

---
 Cocktail Sort.cpp | 72 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 Cocktail Sort.cpp

diff --git a/Cocktail Sort.cpp b/Cocktail Sort.cpp
new file mode 100644
index 0000000..5e39ace
--- /dev/null
+++ b/Cocktail Sort.cpp	
@@ -0,0 +1,72 @@
+// C++ implementation of Cocktail Sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// Sorts array a[0..n-1] using Cocktail sort
+void CocktailSort(int a[], int n)
+{
+bool swapped = true;
+int start = 0;
+int end = n - 1;
+
+while (swapped) {
+// reset the swapped flag on entering
+// the loop, because it might be true from
+// a previous iteration.
+swapped = false;
+
+// loop from left to right same as
+// the bubble sort
+for (int i = start; i < end; ++i) {
+if (a[i] > a[i + 1]) {
+	swap(a[i], a[i + 1]);
+	swapped = true;
+}
+}
+
+// if nothing moved, then array is sorted.
+if (!swapped)
+break;
+
+// otherwise, reset the swapped flag so that it
+// can be used in the next stage
+swapped = false;
+
+// move the end point back by one, because
+// item at the end is in its rightful spot
+--end;
+
+// from right to left, doing the
+// same comparison as in the previous stage
+for (int i = end - 1; i >= start; --i) {
+if (a[i] > a[i + 1]) {
+	swap(a[i], a[i + 1]);
+	swapped = true;
+}
+}
+
+// increase the starting point, because
+// the last stage would have moved the next
+// smallest number to its rightful spot.
+++start;
+}
+}
+
+/* Prints the array */
+void printArray(int a[], int n)
+{
+for (int i = 0; i < n; i++)
+printf("%d ", a[i]);
+printf("\n");
+}
+
+// Driver code
+int main()
+{
+int arr[] = { 5, 1, 4, 2, 8, 0, 2 };
+int n = sizeof(arr) / sizeof(arr[0]);
+CocktailSort(arr, n);
+printf("Sorted array :\n");
+printArray(arr, n);
+return 0;
+}

From 3faeab70510bff78e130b09d954df9812b9b2bd7 Mon Sep 17 00:00:00 2001
From: Shivam Chopra <60386222+imshivam18@users.noreply.github.com>
Date: Tue, 4 Oct 2022 23:38:51 +0530
Subject: [PATCH 39/48] Backtracking Problem Rat in Maze using C++

---
 Rat in Maze | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 Rat in Maze

diff --git a/Rat in Maze b/Rat in Maze
new file mode 100644
index 0000000..963c73d
--- /dev/null
+++ b/Rat in Maze	
@@ -0,0 +1,81 @@
+#include<iostream> 
+
+using namespace std;
+
+bool isSafe(int** arr,int x,int y,int n)
+	{
+		if(x<n && y<n && arr[x][y]==1)
+		{
+			return true;
+		}
+		return false;
+	}
+
+bool ratinMaze(int** arr,int x,int y,int n,int** solArr)
+	{
+		if(isSafe(arr,x,y,n))
+		{
+			if(x==n-1 && y==n-1)
+			{
+				solArr[x][y]=1;
+				return true;
+			}
+
+			solArr[x][y]=1;
+
+			if(ratinMaze(arr,x+1,y,n,solArr))
+			{
+				return true;
+			}
+			if(ratinMaze(arr,x,y+1,n,solArr))
+			{
+				return true;
+			}
+			solArr[x][y]=0;  // Backtracking
+			return false;
+		}
+		return false;
+	}
+
+int main()
+{
+	int n;
+	cin >> n;
+
+	int** arr = new int*[n];
+	for(int i=0;i<n;i++)
+	{
+		arr[i] = new int[n];
+	}
+
+	for(int i=0;i<n;i++)
+	{
+		for(int j=0;j<n;j++)
+		{
+			cin>>arr[i][j];
+		}
+	}
+
+	int** solArr = new int*[n];
+	for(int i=0;i<n;i++)
+	{
+		solArr[i] = new int[n];
+		for(int j=0;j<n;j++)
+		{
+			solArr[i][j]=0;
+		}
+	}
+		cout << endl;
+		 
+	if(ratinMaze(arr,0,0,n,solArr))
+	{
+		for(int i=0;i<n;i++)
+		{
+			for(int j=0;j<n;j++)
+			{
+				cout << solArr[i][j] << " ";
+			}	cout << endl;
+		}
+	}
+	return 0;
+}

From f25b97b9ef95be00b02d9d0ce0e264a44cb58958 Mon Sep 17 00:00:00 2001
From: Shubham Kumar <shkumar1154@gmail.com>
Date: Wed, 5 Oct 2022 00:21:29 +0530
Subject: [PATCH 40/48] Create lengthOfLongestSubstring.java

---
 lengthOfLongestSubstring.java | 58 +++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 lengthOfLongestSubstring.java

diff --git a/lengthOfLongestSubstring.java b/lengthOfLongestSubstring.java
new file mode 100644
index 0000000..9376bb9
--- /dev/null
+++ b/lengthOfLongestSubstring.java
@@ -0,0 +1,58 @@
+// Java program to find the length of the
+// longest substring without repeating
+// characters
+import java.io.*;
+import java.util.*;
+ 
+class sk{
+ 
+// This function returns true if all characters in
+// str[i..j] are distinct, otherwise returns false
+public static Boolean areDistinct(String str,
+                                  int i, int j)
+{
+     
+    // Note : Default values in visited are false
+    boolean[] visited = new boolean[26];
+ 
+    for(int k = i; k <= j; k++)
+    {
+        if (visited[str.charAt(k) - 'a'] == true)
+            return false;
+             
+        visited[str.charAt(k) - 'a'] = true;
+    }
+    return true;
+}
+ 
+// Returns length of the longest substring
+// with all distinct characters.
+public static int longestUniqueSubsttr(String str)
+{
+    int n = str.length();
+     
+    // Result
+    int res = 0;
+     
+    for(int i = 0; i < n; i++)
+        for(int j = i; j < n; j++)
+            if (areDistinct(str, i, j))
+                res = Math.max(res, j - i + 1);
+                 
+    return res;
+}
+ 
+// Driver code
+public static void main(String[] args)
+{
+    String str = "geeksforgeeks";
+    System.out.println("The input string is " + str);
+ 
+    int len = longestUniqueSubsttr(str);
+     
+    System.out.println("The length of the longest " +
+                       "non-repeating character " +
+                       "substring is " + len);
+}
+}
+ 
\ No newline at end of file

From 6703979e1dd9b9bb2a63793b872f3df5a5d31e30 Mon Sep 17 00:00:00 2001
From: Rashmi Kumari <76115061+thakurRashmi@users.noreply.github.com>
Date: Wed, 5 Oct 2022 00:37:23 +0530
Subject: [PATCH 41/48] Create Median_of_TwoSortedArrays_OptimisedCode.cpp

This is an implementation of the most efficient approach to finding the median value of two sorted Arrays of different sizes.
Time Complexity is O(min(log n1, log n2)) while Space Complexity is O(1).
---
 Median_of_TwoSortedArrays_OptimisedCode.cpp | 83 +++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 Median_of_TwoSortedArrays_OptimisedCode.cpp

diff --git a/Median_of_TwoSortedArrays_OptimisedCode.cpp b/Median_of_TwoSortedArrays_OptimisedCode.cpp
new file mode 100644
index 0000000..a3c6967
--- /dev/null
+++ b/Median_of_TwoSortedArrays_OptimisedCode.cpp
@@ -0,0 +1,83 @@
+// Most Optimised and Efficient approach to find the median of Two sorted Arrays of different sizes
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// Binary Search Method to find median
+double MedianOfSortedArrays(vector<int>& nums1, vector<int>& nums2)
+{
+        if(nums2.size() < nums1.size())      return  MedianOfSortedArrays(nums2,nums1);
+        // Swapping to make first array i.e. nums1 smaller
+        
+    	int n1 = nums1.size();
+    	int n2 = nums2.size();
+
+	    int low = 0;
+    	int high= n1;
+
+	       while (low <= high)
+         {
+	            	int cut1 = (low+high) >> 1; //   (low+high)/2
+                int cut2 = (n1+n2+1) / 2 - cut1;
+                
+                int left1=cut1==0 ? INT_MIN : nums1[cut1-1];
+                int left2=cut2==0 ? INT_MIN : nums2[cut2-1];
+                
+	            	int right1=cut1==n1 ? INT_MAX : nums1[cut1];
+                int right2=cut2==n2 ? INT_MAX : nums2[cut2];
+                
+
+		   // if correct partition is done
+		   if (left1<= right2 and left2<=right1)
+       {
+			        if((n1+n2)%2 ==0 )     return (max(left1,left2)+ min(right1,right2))/2.0;
+              else                   return max(left1,left2);
+		   }
+		   else if (left1 > right2)
+       {
+			       high = cut1-1;
+       }
+		 	else
+      {
+		       	low = cut1 + 1;
+       }
+	}
+	return 0.0;
+}
+
+// Driver code
+int main()
+{
+        cout<<"Enter the size of first array"<<endl;
+        int n1;
+        cin>>n1;
+	      vector<int> arr1 ;
+        int a;
+        cout<<"Enter the elements of First array"<<endl;
+        for(int i=0; i<n1; i++)
+        {
+                cin>>a;
+                arr1.push_back(a);
+        }
+        
+        cout<<"Enter the size of second array"<<endl;
+        int n2;
+        cin>>n2;
+        vector<int> arr2;
+        
+        cout<<"Enter the elements of Second array"<<endl;
+        for(int i=0; i<n2; i++)
+        {
+                cin>>a;
+                arr2.push_back(a);
+        }
+	
+	     cout << "Median of the two arrays are" << endl;
+	     cout << MedianOfSortedArrays(arr1, arr2);
+	     return 0;
+  
+  // Time Complexity: O(min(log n1, log n2))    [Since binary search is being applied on the smaller of the 2 arrays]
+  // Auxiliary Space: O(1)                      [ As no extra space is used ]
+  
+	
+}

From 83aed4bc8c2227b7c5e70f6f05578b652c5ca88e Mon Sep 17 00:00:00 2001
From: Rashmi Kumari <76115061+thakurRashmi@users.noreply.github.com>
Date: Wed, 5 Oct 2022 01:20:27 +0530
Subject: [PATCH 42/48] Create
 SumOfElements_between_k1Smallest_and_k2SmallestElements.cpp

This is a program implementation to find the sum of elements of the Array between k1 Smallest and k2 Smallest elements in the Array.
Time Complexity: O(n logk) + O(n) .
  [ O(n logk) to find the kth Smallest element and O(n) to find the sum of in between elements in the array]
---
 ...ween_k1Smallest_and_k2SmallestElements.cpp | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 SumOfElements_between_k1Smallest_and_k2SmallestElements.cpp

diff --git a/SumOfElements_between_k1Smallest_and_k2SmallestElements.cpp b/SumOfElements_between_k1Smallest_and_k2SmallestElements.cpp
new file mode 100644
index 0000000..bb150af
--- /dev/null
+++ b/SumOfElements_between_k1Smallest_and_k2SmallestElements.cpp
@@ -0,0 +1,52 @@
+
+// Program to find the sum of all elements of the array between k1 smallest and k2 smallest element of the Array.
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// This function will return the K_th smallest element in the array 
+int kth_Smallest(int arr[], int k, int size)
+{
+    priority_queue<int> maxh; // max heap initialisation
+    for(int i=0; i<size; i++)
+    {
+        maxh.push(arr[i]); // pushing the array elements into the max heap
+        
+        if(maxh.size()>k) // if the size of the max heap exceeds k , it will remove the top element of the max heap
+        {
+            maxh.pop();
+        }
+    }
+    return maxh.top(); // top element of the max heap will be the k_th smallest element of the array
+}
+
+
+// Driver Code
+int main()
+{
+    int k1,k2;
+    cin>>k1>>k2;
+    
+    int n;
+    cin>>n;
+    int arr[n];
+    for(int i=0; i<n; i++)
+    {
+        cin>>arr[i];
+    }
+    
+    int first = kth_Smallest(arr,k1,n); // k1 smallest element in the array
+    int second = kth_Smallest(arr,k2,n);// k2 smallest element in the array
+    int sum=0;
+    
+    for(int i=0; i<n; i++)
+    {
+        if(arr[i]>first and arr[i]<second)
+        {
+            sum=sum+arr[i]; // sum will store the sum of all elements of the array between k1 and k2 smallest elemenets of the array
+        }
+    }
+    cout<<"The sum is "<<sum<<endl;
+}
+
+// Time Complexity: O(n logk) + O(n)   [O(nlogk) to find the kth Smallest element and O(n) to find the sum of in between elements in the array]

From 14583f62fb860b71b2c0d4a2390c0d0cfa9e34f0 Mon Sep 17 00:00:00 2001
From: Rashmi Kumari <76115061+thakurRashmi@users.noreply.github.com>
Date: Wed, 5 Oct 2022 01:57:33 +0530
Subject: [PATCH 43/48] Create PeakElement_of_an_Array.cpp

This is a program implementation in C++ to find the peak element in an Array. If the array contains more than one peak element then this program will return any of the peak elements present in the Array.
Time Complexity: O(log n), where n is the number of elements in the Array.
Space Complexity: O(1), as no extra space is used.
---
 PeakElement_of_an_Array.cpp | 52 +++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 PeakElement_of_an_Array.cpp

diff --git a/PeakElement_of_an_Array.cpp b/PeakElement_of_an_Array.cpp
new file mode 100644
index 0000000..83cf0d9
--- /dev/null
+++ b/PeakElement_of_an_Array.cpp
@@ -0,0 +1,52 @@
+// C++ program to find a peak element in an array using iterative Binary Search
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// A binary search based function that returns index of a peak element in an array
+
+int PeakElement(int arr[], int size)
+{
+	int start = 0;
+	int end = size-1;
+	while(start <= end)
+	{
+	    // finding mid element
+	    int mid= start + (end - start)/2;
+	    
+	    if(mid>0 and mid <size-1)
+	    {
+	        if(arr[mid]>arr[mid-1] and arr[mid] >arr[mid+1])    return mid;
+	        else if(arr[mid-1] > arr[mid])                      end=mid-1;
+	        else                                                start=mid+1;
+	    }
+	    else if(mid==0)
+	    {
+	        if(arr[0]>arr[1])    return 0;
+	        else                 return 1;
+	    }
+	    else if(mid == size-1)
+	    {
+	        if(arr[size-1]>arr[size-2])     return size-1;
+	        else                            return size -2;
+	    }
+		
+	}
+
+	return -1;
+}
+
+// Driver Code
+int main()
+{
+	int arr[] = { 10, 20, 15, 2, 23, 90, 67 };
+	int N = sizeof(arr) / sizeof(arr[0]);
+	cout << "Index of a peak point is " << PeakElement(arr, N);
+	return 0;
+}
+
+/* Time Complexity: O(log n), Where n is the number of elements in the input array
+[ In each step our search becomes half,hence we can compare it to Binary search.So, The time complexity is O(log n) ]
+
+  Space Complexity: O(1)  [ Since no extra space is required ]
+ */

From ae25e9dd20db3fb6aa9787de5e7f034f0c9728c0 Mon Sep 17 00:00:00 2001
From: Guilherme Bernardo <bguilherme51@gmail.com>
Date: Tue, 4 Oct 2022 16:55:27 -0400
Subject: [PATCH 44/48] print rax in assembly language

---
 print_rax.asm | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 print_rax.asm

diff --git a/print_rax.asm b/print_rax.asm
new file mode 100644
index 0000000..719e4f3
--- /dev/null
+++ b/print_rax.asm
@@ -0,0 +1,44 @@
+section .data
+codes:
+	db '0123456789ABCDEF'
+
+
+section .text
+global _start
+_start:
+	; number 1122... in hexadecimal format
+	mov rax, 0x1122334455667788
+
+	mov rdi, 1
+	mov rdx, 1
+	mov rcx, 64
+	; Each 4 bits should be output as one hexadecimal digit
+	; Use shift and bitwise AND to isolate them
+	; the result is the offset in 'codes' array
+.loop:
+	push rax
+	sub  rcx, 4
+	
+	; cl is a register, smallest part of rcx
+	; rax -- eax -- ax -- ah + al
+	; rcx -- ecx -- cx -- ch + cl
+	sar rax, cl
+	
+	and rax, 0xf
+	lea rsi, [codes + rax]
+	mov rax, 1
+	
+	; syscall leaves rcx and r11 changed
+	push rcx
+	syscall
+	pop rcx
+
+	pop rax
+	; test can be used for the fastest 'is it a zero?' check
+	; see docs for 'test' command
+	test rcx, rcx
+	jnz .loop
+	
+	mov rax, 60 ; invoke 'exit' system call
+	xor rdi, rdi
+	syscall
\ No newline at end of file

From 97c1c43564b1395b6a7706a5d05b898c8230fe62 Mon Sep 17 00:00:00 2001
From: Rashmi Kumari <76115061+thakurRashmi@users.noreply.github.com>
Date: Wed, 5 Oct 2022 03:07:51 +0530
Subject: [PATCH 45/48] Create Top_k_Frequent_Numbers_InAnArray.cpp

This is an implementation program in C++ to print the Top k frequent Numbers in a given array.
Time Complexity: O( k logd + d logd)
[ To remove the top of the priority queue O(log d) time is required, so if k elements are removed then O(k log d) time is required, and
To construct a priority queue with d elements, O(d logd) time is required]

Space Complexity: O(d), where d is the count of distinct elements in the Array.
---
 Top_k_Frequent_Numbers_InAnArray.cpp | 58 ++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 Top_k_Frequent_Numbers_InAnArray.cpp

diff --git a/Top_k_Frequent_Numbers_InAnArray.cpp b/Top_k_Frequent_Numbers_InAnArray.cpp
new file mode 100644
index 0000000..2694251
--- /dev/null
+++ b/Top_k_Frequent_Numbers_InAnArray.cpp
@@ -0,0 +1,58 @@
+// C++ Program to print Top k Frequent Numbers in a given Array
+
+#include <bits/stdc++.h>
+using namespace std;
+
+void Top_K_FrequentNumbers(int arr[], int n, int k)
+{
+    priority_queue <pair<int,int>, vector<pair<int,int>>, greater< pair<int,int>> > minh;
+    unordered_map<int,int> mp;
+    for(int i=0; i<n; i++)
+    {
+        mp[arr[i]]++;
+    }
+    
+    for(auto i=mp.begin(); i!=mp.end(); i++)
+    {
+        minh.push({i->second, i->first});
+        
+        if(minh.size()>k)
+        {
+            minh.pop();
+        }
+    }
+    
+    while(minh.size()>0)
+    {
+        cout<<minh.top().second<<" ";
+        minh.pop();
+    }
+}
+
+int main()
+{
+    int n;
+    cout<<"Enter the size of Array"<<endl;
+    cin>>n;
+    
+    int k;
+    cin>>k; 
+    
+    int arr[n];
+    cout<<"Enter the elements of the Array"<<endl;
+    for(int i=0; i<n; i++)
+    {
+        cin>>arr[i];
+    }
+   
+    Top_K_FrequentNumbers(arr,n,k);
+    
+    return 0;
+}
+
+/* Time Complexity: O(K logd + d logd)
+  [ To remove the top of the priority queue O(log d) time is required, so if k elements are removed then O(k log d) time is required, and 
+    To construct a priority queue with d elements, O(d logd) time is required]
+    
+   Space Complexity: O(d), where d is the count of distinct elements in the array. 
+ */  

From 20406bbefc93e8629e477ec57e028492c7ffd421 Mon Sep 17 00:00:00 2001
From: Akshay Khatter <30326830+akshaykhatter@users.noreply.github.com>
Date: Wed, 5 Oct 2022 03:33:15 +0530
Subject: [PATCH 46/48] added balancedParenthesis

---
 balancedParenthesis.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 balancedParenthesis.cpp

diff --git a/balancedParenthesis.cpp b/balancedParenthesis.cpp
new file mode 100644
index 0000000..2ef3cd6
--- /dev/null
+++ b/balancedParenthesis.cpp
@@ -0,0 +1,28 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+int st[16], i, j, k, temp;
+cout<<"enter 5 elements only to sort n:-";
+for (i = 0; i < 5; i++)
+{
+cin>>st[i];
+}
+for (i = 1; i < 5; i++)
+{
+for (j = i; j >= 1; j--)
+{
+if (st[j] < st[j-1])
+{
+temp = st[j];
+st[j] = st[j-1];
+st[j-1] = temp;
+}
+else
+break;
+}
+}
+cout<<"sorted array n "<<endl;
+for (k = 0; k < 5; k++)
+cout<<st[k]<<endl;
+}
\ No newline at end of file

From 0ade402ad849aa884739742c3a424396e735169b Mon Sep 17 00:00:00 2001
From: Abhishek <abhirjaiswal621@gmail.com>
Date: Wed, 5 Oct 2022 13:18:35 +0530
Subject: [PATCH 47/48]  added program to sort an input array in wave form

---
 sort_array_waveform.cpp | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 sort_array_waveform.cpp

diff --git a/sort_array_waveform.cpp b/sort_array_waveform.cpp
new file mode 100644
index 0000000..3179464
--- /dev/null
+++ b/sort_array_waveform.cpp
@@ -0,0 +1,35 @@
+// program to sort an input array in wave form
+
+#include <iostream>
+using namespace std;
+
+void swap(int *x, int *y)
+{
+    int temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+void sortInWave(int arr[], int n)
+{
+
+    for (int i = 0; i < n; i += 2)
+    {
+
+        if (i > 0 && arr[i - 1] > arr[i])
+            swap(&arr[i], &arr[i - 1]);
+
+        if (i < n - 1 && arr[i] < arr[i + 1])
+            swap(&arr[i], &arr[i + 1]);
+    }
+}
+
+int main()
+{
+    int arr[] = {10, 90, 49, 2, 1, 5, 23};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    sortInWave(arr, n);
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+    return 0;
+}

From e4570cfb7be05fae42e4acde8a71c61b9a8183cc Mon Sep 17 00:00:00 2001
From: gaurav <gauravagarwal091@gmail.com>
Date: Wed, 12 Oct 2022 18:37:32 +0530
Subject: [PATCH 48/48] heapSort in python

---
 heapSort.py | 61 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 heapSort.py

diff --git a/heapSort.py b/heapSort.py
new file mode 100644
index 0000000..69a44eb
--- /dev/null
+++ b/heapSort.py
@@ -0,0 +1,61 @@
+# 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 = [12, 11, 13, 5, 6, 7, ]
+heapSort(arr)
+n = len(arr)
+print('Sorted array is')
+for i in range(n):
+	print(arr[i])
+
+# This code is contributed by Gaurav Agarwal