Merge pull request #1 from Mukulbaid63/new-1

New 1

Author: Mukulbaid63

Java/Euclid's GCD Algorithm/Euclid.java

@@ -0,0 +1,29 @@
+// Java program to demonstrate working of extended 
+import java.util.*; 
+import java.io.*; 
+
+class Euclid 
+{   
+    /*Recursive function to calculate gcd using Euclid's algo*/
+	public static int gcd(int a,int b) 
+	{ 
+		if (a==0) 
+			return b; 
+
+		return gcd(b%a, a); 
+	} 
+
+    public static void main(String[] args) 
+	{ 
+        Scanner sc=new Scanner(System.in);
+
+        /*Taking a & b as user input*/
+		int a=sc.nextInt();
+        int b=sc.nextInt(); 
+		
+		System.out.println("GCD : " + gcd(a,b)); //Output
+
+	} 
+    
+} 
+

Java/Euclid's GCD Algorithm/README.md

@@ -0,0 +1,57 @@
+
+# Sample Input:
+
+10 15
+
+  
+
+# Sample Output:
+
+5
+
+  
+
+# Sample Input:
+
+20 48
+
+  
+
+# Sample Output:
+
+4
+
+  
+
+# Explaination:
+TC 1:         
+ 10 = 2 * 5
+
+15 = 3 * 5
+
+The Greatest common divisor is 5
+
+  
+
+TC 2: 
+20 = 2 * 2 * 5
+
+48 = 2 * 2 * 2 * 2 * 3
+
+The Greatest common divisor is 2 * 2 = 4
+
+  
+
+The algorithm is based on below facts:
+
+  
+
+--If we subtract smaller number from larger (we reduce larger number), GCD doesn’t change. So if we keep subtracting repeatedly the larger of two, we end up with GCD.
+
+--Now instead of subtraction, if we divide smaller number, the algorithm stops when we find remainder 0.
+
+  
+
+# Time Complexity:
+
+<h3>O(log min(a,b))</h3>

Java/Euclid's GCD Algorithm/RelevanceInCryptography.md

@@ -0,0 +1,5 @@
+# Relevance in Cryptography:
+RSA, which based on the great difficulty of integer factorization, is the most widely-used public-key cryptosystem used in electronic commerce. Euclid algorithm and extended Euclid algorithm are the best algorithms to solve the public key and private key in RSA. Extended Euclid algorithm in IEEE P1363 is improved by eliminating the negative integer operation, which reduces the computing resources occupied by RSA, hence has an important application value.
+
+
+

Java/FloydAlgorithm/FloydAlgo.java

@@ -0,0 +1,89 @@
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+//Node of Linked list
+class Node
+{   
+    int data;   //value of the node
+    Node next;  //next node
+    /*Constructor*/
+    Node(int x)
+    {
+        data = x;
+        next = null;
+    }
+}
+public class DetectLoop
+{   //function to create loop in linked list 
+    public static void createLoop(Node head, Node tail, int k){
+        //base case
+        if (x == 0) return;
+        Node curr = head;
+
+        for(int i=1; i<k; i++)
+            curr = curr.next;// traversing the linked list till k
+        tail.next = curr;
+    }
+    // Driver Code 
+    public static void main (String[] args){
+        
+        Scanner sc = new Scanner(System.in);
+        
+        //no. of nodes in linked list
+        int n = sc.nextInt();
+         
+        //head of Linked list
+        int num = sc.nextInt();
+        Node head=new Node(num);
+        
+        Node tail=head;
+
+        //Linked List created
+        for(int i=0; i<n-1; i++)
+        {
+            num = sc.nextInt();
+            tail.next = new Node(num);
+            tail = tail.next;
+        }
+
+        //Node to check if loop exists or not
+        int temp = sc.nextInt();
+        
+        //creating the loop
+        createLoop(head,tail,temp);
+        
+        //creating object of x
+        Solution x = new Solution();
+        
+        //if loop exists
+        if(x.detectLoop(head))
+            System.out.println("Loop exists");
+        else
+            System.out.println("Loop doesn't exists");
+    }
+}
+
+//detecting if the loop exists or not
+class Solution {
+    
+    public static boolean detectLoop(Node head){
+        //base case
+        if(head==null||head.next==null)
+            return false;
+
+        Node slow = head;
+        Node fast = head;
+
+        while(fast != null && fast.next != null) {
+            
+            slow = slow.next;
+            fast = fast.next.next;
+            
+            //if loop exists slow and fast pointer will surely intersect
+            if(slow==fast)
+                return true;
+        }
+         
+        return false;
+    }
+}

Java/FloydAlgorithm/README.md

@@ -0,0 +1,34 @@
+
+# Sample Input:
+
+5
+
+1 6 3 7 8
+
+2
+
+  
+
+# Sample Output:
+
+Loop exists
+
+  
+
+# Explaination:
+
+4--> size of linked list
+
+1-->6-->3-->7-->8 =>nodes of linked list
+
+2---> node to be checked
+
+</br>
+
+after creating the loop the detect loop fuction is called and the two pointer slow and fast meets if loop exists .
+For better understanding,refer <a href="https://media.geeksforgeeks.org/wp-content/cdn-uploads/20190621160855/Detect-loop-in-a-linked-list.png">here:
+  
+
+# Time complexity:
+
+O(n)

Java/NthDigitMaxPrime/MaxPrime.java

@@ -0,0 +1,54 @@
+imjort java.util.*; 
+
+class MaxPrime
+{ 
+static int limit = 100000000; 
+static boolean[] sieve = new boolean[limit + 1]; 
+
+/*The Sieve of Eratosthenes marks all the no.s except 
+primes to false in the bool arr in most optimal way.*/
+static void SieveOfEratosthenes() 
+{ 
+	for (int i=0;i<limit+1;i++) 
+	{ //setting all values to true 
+		sieve[i]=true; 
+	} 
+	for (int j=2;j*j<=limit;j++) 
+	{ 
+		if(sieve[j]==true) 
+		{   //setting all the multiples of j as false
+			for (int i=j*j;i<=limit;i+=j) 
+				sieve[i]=false; 
+		} 
+	} 
+} 
+
+static int maxPrime(int d) 
+{ 
+	int l=(int)Math.pow(10,d-1); //lowest d digit number 
+	int r=(int)Math.pow(10,d)-1; //highest d digit number
+	for (int i=r;i>=l;i--) 
+	{   /**The first index with true value in sieve[] will be 
+        the answer as we are traversing in decreasing order */
+		if(sieve[i]) 
+		{ 
+			return i; 
+		} 
+	} 
+    
+	return -1; 
+} 
+
+
+public static void main(String[] args) 
+{ 
+	SieveOfEratosthenes(); 
+
+    Scanner sc=new Scanner(System.in);
+    int n=sc.nextInt();//Input
+    
+	System.out.println(maxPrime(n)); //Output
+	
+} 
+} 
+ 

Java/NthDigitMaxPrime/README.md

@@ -0,0 +1,35 @@
+# Sample Input:
+
+2
+
+  
+
+# Sample Output:
+
+97
+
+  
+
+# Sample Input:
+
+6
+
+  
+
+# Sample Output:
+
+999983
+
+  
+
+# Explaination:
+TC 1:         
+l=10^(2-1)=10
+r=10^2-1=99
+
+After checking in the sieve[] in decreasing order,the first time comes out to be 97
+
+
+# Time Complexity:
+
+<h3>O(limit log(log limit))</h3>,where limit is the size of the sieve[].This is the most optimal way to find out the  required solution.

Java/PrimeFactorization/PrimeFactorization.java

@@ -0,0 +1,43 @@
+import java.io.*; 
+import java.util.*; 
+
+class PrimeFactorization
+{ 
+    public static void main(String[] args) 
+	{   
+        Scanner sc=new Scanner(System.in); //Scanner class
+
+        int n=sc.nextInt();   //Raeding user input
+
+		primeFactorization(n); 
+	} 
+	public static void primeFactorization(int n) 
+	{   
+        /*If n is a factor of 2,we print 2 and
+         then check whether (n/2)%2 is zero or not*/
+		while (n%2==0) 
+		{ 
+			System.out.print(2+" "); 
+			n=n/2; 
+		} 
+
+        /*Above loop exits only when n becomes odd,so now n is odd,
+        so we can skip all the even elements in the for loop i.e i=i+2*/
+		for (int i=3;i<=Math.sqrt(n);i+=2) 
+		{ 
+            /*if i is a factor of n,then print i and then
+             divide n by i till i is not a factor of i*/
+			while (n%i==0) 
+			{ 
+				System.out.print(i+" "); 
+				n/=i; 
+			} 
+		} 
+        /*condition for the prime numbers 
+        greater than 2,we directly print n*/
+		if (n>2) 
+			System.out.print(n); 
+	} 
+
+	
+} 

Java/PrimeFactorization/README.md

@@ -0,0 +1,22 @@
+# Sample Input:
+36
+
+# Sample Output:
+2 2 3 3
+
+# Sample Input:
+11
+
+# Sample Output:
+11
+
+# Explaination:
+<h3>TC 1: 2 * 2 * 3 * 3 =36</h3>
+<h3>TC 2: 11 , since 11 itself is a prime number and a prime factor of itself.</h3>
+
+<p>The while loop and for loop take care of composite numbers and last condition takes care of prime numbers. To prove that the complete algorithm works, we need to prove that steps 1 and 2 actually take care of composite numbers. This is clear that step 1 takes care of even numbers. And after step 1, all remaining prime factor must be odd (difference of two prime factors must be at least 2), this explains why i is incremented by 2.</p>
+
+
+# Time Complexity:
+<h3>O(sqrt(n))</h3>
+

Java/PrimeFactorization/RelevanceInCryptography.md

@@ -0,0 +1,5 @@
+# Relevance in Cryptography:
+
+Cryptography is all about number theory, and all integer numbers (except 0 and 1) are made up of primes, so you deal with primes a lot in number theory.
+
+More specifically, some important cryptographic algorithms such as RSA critically depend on the fact that prime factorization of large numbers takes a long time. Basically you have a "public key" consisting of a product of two large primes used to encrypt a message, and a "secret key" consisting of those two primes used to decrypt the message. You can make the public key public, and everyone can use it to encrypt messages to you, but only you know the prime factors and can decrypt the messages. Everyone else would have to factor the number, which takes too long to be practical, given the current state of the art of number theory.