Prime Factorization added

Author: Mukulbaid63

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.