feat: Add GCDandHCF class with Euclidean algorithm implementation

WHAT the code does:
- Defines `GCDandHCF` class with a static method `gcd(int m, int n)`.
- Uses the **Euclidean algorithm** (via modulus) to compute the Greatest Common Divisor (GCD).
- `main()` demonstrates the method with inputs `35` and `56`.

WHY this matters:
- GCD (also known as HCF: Highest Common Factor) is a fundamental concept in number theory.
- The Euclidean algorithm is one of the most efficient methods to compute GCD.
- Understanding GCD is useful in simplifying fractions, cryptography, and algorithm design.

HOW it works:
1. Start with `(m, n) = (35, 56)`.
2. Repeat until `n == 0`:
   - Store `n` in `temp`.
   - Update `n = m % n`.
   - Update `m = temp`.
3. When `n` becomes `0`, `m` holds the GCD.
4. Output: `"GCD of 35 and 56 is: 7"`.

Tips & gotchas:
- Works for positive integers; behavior undefined for negative inputs without adjustments.
- If one number is `0`, the GCD is the other number.
- Recursive implementation is shorter but iterative avoids stack overhead.
- For Least Common Multiple (LCM), formula is `LCM(a, b) = (a * b) / GCD(a, b)`.

Use-cases:
- Simplifying fractions and ratios.
- Algorithms involving modular arithmetic (e.g., RSA encryption).
- Competitive programming and interview problems.
- Foundation for extended Euclidean algorithm (used in modular inverses).

Short key: algo-gcd-euclidean-modulus.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section10Methods/src/GCDandHCF.java

@@ -1,23 +1,18 @@
-/*
-The Greatest Common Divisor (GCD) is also known as the Highest Common Factor (HCF)12345.
+/* The Greatest Common Divisor (GCD) is also known as the Highest Common Factor (HCF).
 It is the largest positive integer that divides two or more numbers without leaving a remainder.
 */
 
-public class GCDandHCF
-{
-
-    static int gcd(int m, int n)
-    {
-        while(m!=n)
-        {
-            if(m>n)m=m-n;
-            else n=n-m;
-        }
-        return m;
+public class GCDandHCF {
+    // Method to calculate GCD using modulus (faster Euclidean algorithm).
+    static int gcd(int m, int n) {
+        while (n != 0) {
+            int temp = n;
+            n = m % n;
+            m = temp;
+        } return m;
     }
-    public static void main(String[] args)
-    {
-
-        System.out.println(gcd(35,56));
+    public static void main(String[] args) {
+        int a = 35, b = 56;
+        System.out.println("GCD of " + a + " and " + b + " is: " + gcd(a, b));
     }
-}
+}