feat: adds Daniel's prime number checker (#135)

* feat:adds code for checking if a number is prime

* chore:fixes junit imports to j unit 5

* feat:adds code to check prime numbers in pyhton with unit tests

* test:adds more testing functions for java implementation along with readme

* chore:added code for unit testing in readme

* docs:added info of differences to readme

* chore:creates git ignore and adds all target files into it

---------

Co-authored-by: Daniel Boyce <[email protected]>

Author: Boyce007

lesson_04/danielboyce/.gitignore

@@ -0,0 +1,2 @@
+
+target/

lesson_04/danielboyce/README.md

@@ -0,0 +1,120 @@
+## Java Implementation
+```
+public class IsPrime {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+
+    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
+```
+import unittest
+def is_prime(n):
+    """Check if a number is prime."""
+    if n <= 1:
+        return False
+    for i in range(2, int(n**0.5) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+```
+
+## Unit testing
+
+### Pyhton
+```
+class TestIsPrime(unittest.TestCase):
+    def test_is_prime(self):
+        self.assertFalse(is_prime(12))
+        
+    def test_is_prime_negative(self):
+        self.assertFalse(is_prime(-5))
+    def test_is_prime_zero(self):
+        self.assertFalse(is_prime(0))
+    def test_is_prime_two(self):
+        self.assertTrue(is_prime(2))
+        
+       
+if __name__ == '__main__':
+    unittest.main()
+```
+
+### Java
+```
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+import com.primenumbers.IsPrime;
+
+public class IsPrimeTest {
+    
+
+    @Test
+    public void testIsPrime() {
+        assertTrue(IsPrime.isPrime(7));
+    }
+
+
+    @Test
+    public void testIsNotPrime() {
+        assertFalse(IsPrime.isPrime(4));
+    }
+
+
+    @Test
+    public void testIsPrimeEdgeCases() {
+        assertTrue(IsPrime.isPrime(2));
+        assertTrue(IsPrime.isPrime(1));
+        assertFalse(IsPrime.isPrime(0));
+    }
+    
+    @Test
+    public void testNegativeNumbers() {
+        assertFalse(IsPrime.isPrime(-5));
+        assertFalse(IsPrime.isPrime(-1));
+    }
+
+    
+}
+
+```
+
+## Explanation
+The Java implementation uses a function called `IsPrime` that takes in  a single int parameter `n` and then uses a for loop to iterate from every number from 2 to the square root of n then checks any  numbers are divisible by n if the number is then it returns false and if it finished the loop then we return true. Using the square root of n as end condition for the loop allows us to avoid looking at every number from 1-n
+
+The python uses a function called `is_prime` with the same logic as the java implementation
+
+### Differences
+
+1. **Syntax**:  
+   - In Java, methods are defined inside classes using access modifiers like `public static`, and the `main` method is the program’s entry point. In Python, functions are defined with the `def` keyword and don’t need to be wrapped in a class unless desired.  
+   - Java uses curly braces `{}` for code blocks, while Python uses indentation.  
+
+2. **Type System**:  
+   - Java is statically typed, so the parameter `n` in `isPrime` must be declared as `int`. Python is dynamically typed, inferring `n`’s type at runtime without explicit type declarations.  
+
+3. **Testing Frameworks**:  
+   - The Java implementation uses **JUnit 5** with `@Test` annotations and assertion methods like `assertTrue()` and `assertFalse()` from `org.junit.jupiter.api.Assertions`. Python uses the built-in `unittest` framework, where tests are methods in a class extending `unittest.TestCase` and use `self.assertTrue()`/`self.assertFalse()`.  
+   - In Java, test discovery is handled by the build/test runner (e.g., Maven, Gradle), while in Python, `unittest.main()` is explicitly called to run tests.  
+
+4. **Math Operations**:  
+   - Java uses `Math.sqrt(n)` for the square root in its loop condition, while Python uses `n**0.5` (exponentiation) for the same result.  
+
+5. **Boolean Literals**:  
+   - Java uses lowercase `true` and `false`, while Python uses capitalized `True` and `False`.  

lesson_04/danielboyce/java_is_prime/pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.primenumbers</groupId>
+    <artifactId>lesson04</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter</artifactId>
+        <version>5.11.0</version> <!-- Use the latest stable version -->
+        <scope>test</scope>
+    </dependency>
+</dependencies>
+
+</project>

lesson_04/danielboyce/java_is_prime/src/main/java/com/primenumbers/IsPrime.java

@@ -0,0 +1,19 @@
+package com.primenumbers;
+
+public class IsPrime {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+
+    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;
+    }
+}

lesson_04/danielboyce/java_is_prime/src/test/java/IsPrimeTest.java

@@ -0,0 +1,37 @@
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+import com.primenumbers.IsPrime;
+
+public class IsPrimeTest {
+    
+
+    @Test
+    public void testIsPrime() {
+        assertTrue(IsPrime.isPrime(7));
+    }
+
+
+    @Test
+    public void testIsNotPrime() {
+        assertFalse(IsPrime.isPrime(4));
+    }
+
+
+    @Test
+    public void testIsPrimeEdgeCases() {
+        assertTrue(IsPrime.isPrime(2));
+        assertTrue(IsPrime.isPrime(1));
+        assertFalse(IsPrime.isPrime(0));
+    }
+    
+    @Test
+    public void testNegativeNumbers() {
+        assertFalse(IsPrime.isPrime(-5));
+        assertFalse(IsPrime.isPrime(-1));
+    }
+
+    
+}

lesson_04/danielboyce/java_is_prime/target/classes/com/primenumbers/IsPrime.class

@@ -0,0 +1 @@
+/workspaces/code-society-25-2/lesson_04/danielboyce/java_is_prime/src/main/java/com/primenumbers/IsPrime.java

lesson_04/danielboyce/java_is_prime/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

@@ -0,0 +1 @@
+IsPrimeTest.class

lesson_04/danielboyce/java_is_prime/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -0,0 +1 @@
+/workspaces/code-society-25-2/lesson_04/danielboyce/java_is_prime/src/test/java/IsPrimeTest.java