Merge branch 'master' into my-branch

Author: SanjayDevTech

.github/workflows/greet-contributors.yml

@@ -7,9 +7,9 @@ jobs:
   GreetCommitter: 
     runs-on: ubuntu-latest
     steps:
-    - name: "Greet contributor"
+    - name: "Contributors!!!"
       uses: ibakshay/greet-contributors-action@v3
       env: 
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with: 
-        content: "Thank you for taking your time and effort for your contribution..."
+        content: "Thank you for taking your time and effort for your contribution. If you are a new contributor to this repo, kindly add your username in [CONTRIBUTORS.md](https://github.com/SanjayDevTech/Code-with-love/blob/master/CONTRIBUTORS.md)"

CONTRIBUTORS.md

@@ -13,6 +13,7 @@ If you have contributed to this repository, kindly add your username here
 - [afaditya](https://github.com/afaditya)
 - [aaishikasb](https://github.com/aaishikasb)
 - [sam0hack](https://github.com/sam0hack)
+- [shivajipotnuru](https://github.com/shivajipotnuru)
 - [albysabu9](https://github.com/albysabu9)
 - [Jayant-saksham](https://github.com/Jayant-saksham)
 - [Harshit564](https://github.com/Harshit564)

cpp/Unique_Number_III.cpp

@@ -0,0 +1,38 @@
+/*Unique_Number_III
+Given an array that contains all elements occurring 3 times, but one occurs only once. Find that unique element.*/
+#include <iostream>
+using namespace std;
+int main()
+{
+	int cnt[64] = {0};
+	int n, no;
+	cin >> n;
+	for (int i = 0; i < n; i++)
+	{
+		cin >> no;
+
+		int j = 0;
+		while (no > 0)
+		{
+			int last_bit = (no & 1);
+			cnt[j] += last_bit;
+			j++;
+			no = no >> 1;
+		}
+	}
+	int p = 1;
+	int ans = 0;
+	for (int i = 0; i < 64; i++)
+	{
+		cnt[i] %= 3;
+		ans += (cnt[i] * p);
+		p = p << 1;
+	}
+	cout << ans << endl;
+	return 0;
+}
+/*
+Input : arr[] = {6, 2, 5, 2, 2, 6, 6}
+Output : 5	
+Time Complexity:O(n)
+*/

cpp/russian_peasant.cpp

@@ -0,0 +1,35 @@
+/*Russian Reasant Algorithm
+In this algorithm, two numbers are multiplied without using multiplication operator.
+We double the first number and halve the second number repeatedly till the second number doesn’t become 1. 
+In the process, whenever the second number becomes odd, we add the first number to result.
+In the 1800s, Peasants in a remote area of Russia were discovered multiplying numbers using this remarkably unusual process.
+*/
+
+#include <iostream>
+using namespace std;
+int main()
+{
+    int a, b, result = 0;
+
+    cout << "Enter two numbers to multiply: \n";
+    cin >> a >> b;
+    while (b > 0)
+    {
+        if (b % 2 != 0)
+        {
+            result += a;
+        }
+        a = a << 1;
+        b = b >> 1;
+    }
+    cout << "Product: " << result;
+    return 0;
+}
+
+/*Input:
+Enter two numbers to multiply: 
+4 20
+Output:
+Product: 80
+Time complexity: O(1)
+*/

cpp/siddhantmittal02_MergeSort.cpp

@@ -0,0 +1,87 @@
+//ALGO FOR MERGE SORT
+/*
+Declare an array Arr of length N
+If N=1, Arr is already sorted
+If N>1,
+Left = 0, right = N-1
+Find middle = (left + right)/2
+Call merge_sort(Arr,left,middle) =>sort first half recursively
+Call merge_sort(Arr,middle+1,right) => sort second half recursively
+Call merge(Arr, left, middle, right) to merge sorted arrays in above steps.
+Exit
+*/
+
+//CODE
+#include <iostream>
+using namespace std;
+void merge(int *, int, int, int);
+void merge_sort(int *arr, int low, int high)
+{
+    int mid;
+    if (low < high)
+    {
+        //divide the array at mid and sort independently using merge sort
+        mid = (low + high) / 2;
+        merge_sort(arr, low, mid);
+        merge_sort(arr, mid + 1, high);
+        //merge or conquer sorted arrays
+        merge(arr, low, high, mid);
+    }
+}
+// Merge sort
+void merge(int *arr, int low, int high, int mid)
+{
+    int i, j, k, c[50];
+    i = low;
+    k = low;
+    j = mid + 1;
+    while (i <= mid && j <= high)
+    {
+        if (arr[i] < arr[j])
+        {
+            c[k] = arr[i];
+            k++;
+            i++;
+        }
+        else
+        {
+            c[k] = arr[j];
+            k++;
+            j++;
+        }
+    }
+    while (i <= mid)
+    {
+        c[k] = arr[i];
+        k++;
+        i++;
+    }
+    while (j <= high)
+    {
+        c[k] = arr[j];
+        k++;
+        j++;
+    }
+    for (i = low; i < k; i++)
+    {
+        arr[i] = c[i];
+    }
+}
+// read input array and call mergesort
+int main()
+{
+    int myarray[30], num;
+    cout << "Enter number of elements to be sorted:";
+    cin >> num;
+    cout << "Enter " << num << " elements to be sorted:";
+    for (int i = 0; i < num; i++)
+    {
+        cin >> myarray[i];
+    }
+    merge_sort(myarray, 0, num - 1);
+    cout << "Sorted array\n";
+    for (int i = 0; i < num; i++)
+    {
+        cout << myarray[i] << "\t";
+    }
+}

html/Kshitij9896_HelloWorld.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<title>Hello World</title>
+</head>
+<body>
+<h1>Simple HTML Program</h1>
+<h1>Hello World</h1>
+
+</body>
+</html>

java/[shivajipotnuru]_Queue Using LL.java

@@ -0,0 +1,130 @@
+import java.io.*;
+/***************
+	public static void main(String[] args) {
+		Scanner s = new Scanner(System.in);
+
+		Queue<Integer> st = new Queue<Integer>();
+
+		int choice = s.nextInt();
+		int input;
+
+		while (choice !=-1) {
+			if(choice == 1) {
+				input = s.nextInt();
+				st.enqueue(input);
+			}
+			else if(choice == 2) {
+				try {
+					System.out.println(st.dequeue());
+				} catch (QueueEmptyException e) {
+					System.out.println(-1);
+				}
+			}
+			else if(choice == 3) {
+				try {
+					System.out.println(st.front());
+				} catch (QueueEmptyException e) {
+					System.out.println(-1);
+				}
+			}
+			else if(choice == 4) {
+				System.out.println(st.size());
+			}
+			else if(choice == 5) {
+				System.out.println(st.isEmpty());
+			}
+			choice = s.nextInt();
+		}
+	}
+}
+
+class Node<T> {
+	T data;
+	Node<T> next;
+
+	public Node(T data) {
+		this.data = data;
+        
+	}
+}
+
+
+ ***********/
+
+
+
+class QueueEmptyException extends Exception {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+
+}
+
+
+
+public class Queue<T> {
+    private Node<T> rear;
+        private Node <T> front;
+        int size;
+
+	public Queue() {
+        rear=null;
+        front =null;
+        size=0;
+
+	}
+
+	public void enqueue(T data) {
+        
+       Node<T> curr = new Node<> (data);
+        size++;
+        if(rear==null){
+            front=curr;
+        	rear=curr;
+            
+        }
+            
+        else{
+            rear.next=curr;
+        	rear=curr;
+        }
+        // size++;
+
+	}
+
+	public int size() {
+       return size;
+
+	}
+
+	public boolean isEmpty() {
+       return size==0;
+	}
+
+	public T dequeue() throws QueueEmptyException {
+        if(front==null){
+            throw new QueueEmptyException();
+        }
+        T temp= front.data;
+        front=front.next;
+        if(front ==null){
+            rear=null;
+        }
+        size--;
+        return temp;
+        
+
+	}
+
+	public T front() throws QueueEmptyException {
+        if(front==null){
+            throw new QueueEmptyException();
+        }
+        return front.data;
+
+	}
+   
+}