feat: adds Xavier's writeup for Prime number algo in python and java (#133)

* feat: Created writeup python/java

* update: updated writeup

* hotfix: misread problem. fixed using prime number algo

Author: XavierCruz5106

lesson_04/xaviercruz/README.md

@@ -0,0 +1,92 @@
+## Java Implementation
+
+```java
+
+public class Main{    
+    public static void main(String args[]){   
+        
+        System.out.println(isPrime(3)); // Output: true
+        System.out.println(isPrime(4)); // Output: false;
+    }   
+    
+    
+    public static boolean isPrime(int n){
+        if (n <= 1) {  
+                return false;  
+        }  
+        for (int i = 2; i < Math.sqrt(n); i++) {  
+            if (n % i == 0) {  
+                return false;  
+            }  
+        }  
+        return true;  
+    }
+} 
+
+
+```
+
+## Python Implementation
+
+```python
+
+def is_prime(n: int) -> bool:
+    if n <= 1:
+        return False
+    for i in range(2, int(math.sqrt(n)) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+print(is_prime(3))  # Output: true
+print(is_prime(4))  # Output: false
+
+```
+
+## Explanation
+
+### Core Differences
+
+**Syntax**:
+
+- Java: Java requires explicit class definitions, and all code must reside within a class. The main method is the entry point of the application. Java uses semicolons to terminate statements and curly braces to define blocks of code.
+    
+- Python: Python has a more concise and readable syntax, using indentation to define blocks of code without the need for curly braces or semicolons. There is no need for an explicit main method; you can simply write functions at the top level.
+
+**Type Declaration**:
+
+- Java: It is a statically typed language, meaning variable types must be declared explicitly (e.g., `int n`). This can help catch type-related errors at compile time.
+
+- Python: Python is dynamically typed, allowing variables to be assigned without explicit type declarations. Type hints can be used (as seen in `n: int`), but they are not enforced at runtime.
+
+**Libraries and Imports**:
+
+- Java: You need to import specific libraries (e.g., `Math` for square root calculations) explicitly.
+
+- Python: The math library needs to be imported, as shown in the Python implementation. However, the import syntax is simple (`import math`), and Python's built-in functions often eliminate the need for additional libraries.
+
+**Boolean Representation**:
+
+- Java: Uses `true` and `false` (with a lowercase 'T' and 'F') for boolean values.
+
+- Python: Uses `True` and `False` (with a capital 'T' and 'F') but it’s more flexible with types and doesn’t require strict boolean checks.
+
+### Core Similarities
+
+**Logic of Prime Detection**:
+
+-  Both implementations use a similar logic to determine if a number is prime:
+    - A number less than or equal to 1 is not prime.
+    - The algorithm checks for divisibility from 2 up to the square root of the number.
+    - If any divisor is found, the number is not prime; otherwise, it is prime.
+
+**Control Structures**:
+
+- Both languages employ similar control structures such as if statements and for loops. The iteration over possible divisors is done using a loop, and the logic to return a boolean value is consistent.
+
+**Functionality**:
+
+- Both implementations return a boolean value indicating whether the input number is prime. 
+
+## Conclusion
+Both Java and Python successfully implement a prime number detection algorithm with logical similarities and notable differences in syntax, type handling, and structure. The choice between the two languages often comes down to the specific use case, existing codebase, or personal preference, as each offers unique advantages. Java's robustness and performance are great for large-scale applications, while Python's simplicity and readability are ideal for rapid development and scripting.