feat: adds Devyn's custom code samples (#173)

* Created README.md of functions w/test cases

* Added test and more checks for functions JS & Python

Author: dev-benson-03

lesson_04/devynbenson/README.md

@@ -0,0 +1,98 @@
+## Python implementation
+
+```python
+def prime_function(n : int) -> bool:
+    if n <= 1:
+        return False
+
+    if n <= 3:
+        return True
+
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    
+    # Check for divisors from 5 to √n
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    
+    return True
+
+
+
+# Example usage:
+print(prime_function(1))  # Output: False (only one positive divisor)
+print(prime_function(2))  # Output: True (only even prime)
+print(prime_function(4))  # Output: False (4 = 2×2, composite)
+print(prime_function(6))  # Output: False (6 = 2×3, composite)
+print(prime_function(9))  # Output: False (9 = 3×3, composite) 
+```
+
+## JavaScript implementation
+
+```javascript
+function primeFunction(n) {
+    if (!Number.isInteger(n) || n <= 1) 
+        return false;
+   
+    if (n <= 3) 
+        return n >= 2;              
+    
+    if (n % 2 === 0 || n % 3 === 0) 
+        return false;
+
+    // Check for divisors from 5 to √n
+    for (let i = 5; i * i <= n; i += 6) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+// Example usage:
+console.log(primeFunction(1)); // Output: false (only one positive divisor)
+console.log(primeFunction(2)); // Output: true (only even prime)
+console.log(primeFunction(4)); // Output: false (4 = 2×2, composite)
+console.log(primeFunction(6)); // Output: false (6 = 2×3, composite)
+console.log(primeFunction(9)); // Output: false (9 = 3×3, composite) 
+```
+
+## Explanation
+
+The **Python** implementation uses a function named ``prime_function`` that takes a ``single argument`` represented as an ``int`` (for my case) used to store ``whole numbers``, which can be ``positive, negative, or zero,`` ``WITHOUT ANY DECIMAL COMPONENT``. Returns ``True`` if ``n`` is a prime number; otherwise, returns ``False``. The function implements an optimized algorithm that first handles edge cases (``n <= 1`` returns ``False``, ``n <= 3`` returns ``True``), then checks divisibility by 2 and 3. For remaining candidates, it uses a ``while`` loop starting at ``i = 5`` and incrementing by 6 (``i += 6``) to check only numbers of the form ``6k±1``, testing divisors ``i`` and ``i + 2`` up to ``√n`` using the condition ``i * i <= n``.
+
+The **JavaScript** implementation uses a function named ``primeFunction`` that also takes a ``single argument`` represented as a ``number`` (JavaScript's universal numeric type) used to store ``any numeric value``, including ``integers, floating-point numbers, positive, negative, or zero``. Returns ``true`` if ``n`` is a prime number; otherwise, returns ``false``. The function includes ``Number.isInteger(n)`` check to ensure the input is actually an integer before proceeding with prime validation. After handling edge cases with ``n <= 1`` and ``n <= 3`` conditions, it eliminates even numbers and multiples of 3. The core algorithm uses a ``for`` loop (``for (let i = 5; i * i <= n; i += 6)``) to efficiently test only potential divisors of the form ``6k±1``, checking both ``n % i === 0`` and ``n % (i + 2) === 0`` until reaching ``√n``.
+
+
+ ## Differences
+1. **Syntax, Typing, and Coercion**
+   - **Function defs:** Python uses `def`; JavaScript uses `function` (or arrow `() => {}`).
+   - **Booleans:** Python has `True` / `False`; JS has `true` / `false`.
+  
+
+2. **Conditional Logic Differences**
+   - **Edge case handling:** 
+     - Python: ``if n <= 3: return True`` (assumes 2 and 3 are prime after checking n <= 1)
+     - JavaScript: ``if (n <= 3) return n >= 2`` (explicitly checks if n >= 2 for numbers 2 and 3)
+   - **Input validation:**
+     - Python: ``if n <= 1: return False`` (simple boundary check)
+     - JavaScript: ``if (!Number.isInteger(n) || n <= 1) return false`` (combines type and boundary validation)
+
+3. **Function Calls and Output**
+   - **Printing:** Python uses ``print(prime_function(n))``; JavaScript uses ``console.log(primeFunction(n))``.
+
+
+## Similarities
+
+- **Typing vibe:** You **don’t have** to declare argument types in either language.
+- **Core algorithm logic:** Both check divisibility by 2 and 3: ``n % 2 == 0 or n % 3 == 0`` (Python) vs ``n % 2 === 0 || n % 3 === 0`` (JavaScript).
+- **Functions are first-class:** Both languages treat functions as objects that can be passed around, returned, and stored.
+- **Control flow:** Both use identical ``if/else`` structures and early ``return`` statements for efficiency.
+- **Short-circuiting:** Python uses ``or`` operator; JavaScript uses ``||`` for the same logical short-circuit behavior.
+- **Modulo operation:** Both use ``%`` operator for checking divisibility in prime validation.
+- **Same parameter handling:** Both functions accept a ``single argument`` representing the number to test for primality.
+

lesson_04/devynbenson/TEST_INSTRUCTIONS.md

@@ -0,0 +1,47 @@
+# Prime Function Tests
+
+This directory contains unit tests for both Python and JavaScript prime function implementations.
+
+## Running Python Tests
+
+```bash
+# Run the Python unit tests
+python test_prime_function.py
+
+# Or using unittest module
+python -m unittest test_prime_function.py
+```
+
+Expected output should show all tests passing:
+```
+......
+----------------------------------------------------------------------
+Ran 6 tests in 0.001s
+
+OK
+```
+
+## Running JavaScript Tests
+
+```bash
+# Run the JavaScript tests
+node test_prime_function.js
+```
+
+Expected output should show all tests passing with ✅ markers.
+
+## Test Coverage
+
+Both test suites include:
+- Edge cases (negative numbers, 0, 1, non-integers)
+- Small prime numbers (2, 3, 5, 7, 11, 13)
+- Small composite numbers (4, 6, 8, 9, 10, 12, 15)
+- Larger prime numbers (17, 19, 23, 29, 31, 97)
+- Larger composite numbers (21, 25, 49, 77, 91)
+
+The tests verify the specific examples mentioned in the README:
+- 1 returns false (only one positive divisor)
+- 2 returns true (only even prime)  
+- 4 returns false (4 = 2×2, composite)
+- 6 returns false (6 = 2×3, composite)
+- 9 returns false (9 = 3×3, composite)

lesson_04/devynbenson/test_prime_function.js

@@ -0,0 +1,118 @@
+function primeFunction(n) {
+    if (!Number.isInteger(n) || n <= 1) 
+        return false;
+   
+    if (n <= 3) 
+        return n >= 2;              
+    
+    if (n % 2 === 0 || n % 3 === 0) 
+        return false;
+
+    // Check for divisors from 5 to √n
+    for (let i = 5; i * i <= n; i += 6) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+
+// Simple test framework
+function test(description, testFunction) {
+    try {
+        testFunction();
+        console.log(`PASS: ${description}`);
+    } catch (error) {
+        console.log(`FAIL: ${description}`);
+        console.log(`ERROR: ${error.message}`);
+    }
+}
+
+function assertEqual(actual, expected, message = "") {
+    if (actual !== expected) {
+        throw new Error(`Expected ${expected}, but got ${actual}. ${message}`);
+    }
+}
+
+// Test Suite
+console.log("Running JavaScript Prime Function Tests...\n");
+
+// Test edge cases
+test("Edge case: 1 (only one positive divisor)", () => {
+    assertEqual(primeFunction(1), false);
+});
+
+test("Edge case: 0", () => {
+    assertEqual(primeFunction(0), false);
+});
+
+test("Edge case: negative numbers", () => {
+    assertEqual(primeFunction(-1), false);
+    assertEqual(primeFunction(-5), false);
+});
+
+test("Edge case: non-integer input", () => {
+    assertEqual(primeFunction(2.5), false);
+    assertEqual(primeFunction(3.14), false);
+});
+
+// Test small primes
+test("Small prime: 2 (only even prime)", () => {
+    assertEqual(primeFunction(2), true);
+});
+
+test("Small primes: 3, 5, 7, 11, 13", () => {
+    assertEqual(primeFunction(3), true);
+    assertEqual(primeFunction(5), true);
+    assertEqual(primeFunction(7), true);
+    assertEqual(primeFunction(11), true);
+    assertEqual(primeFunction(13), true);
+});
+
+// Test composite numbers
+test("Composite: 4 (4 = 2×2)", () => {
+    assertEqual(primeFunction(4), false);
+});
+
+test("Composite: 6 (6 = 2×3)", () => {
+    assertEqual(primeFunction(6), false);
+});
+
+test("Composite: 9 (9 = 3×3)", () => {
+    assertEqual(primeFunction(9), false);
+});
+
+test("Composite numbers: 8, 10, 12, 15", () => {
+    assertEqual(primeFunction(8), false);
+    assertEqual(primeFunction(10), false);
+    assertEqual(primeFunction(12), false);
+    assertEqual(primeFunction(15), false);
+});
+
+// Test larger primes
+test("Larger primes: 17, 19, 23, 29, 31, 97", () => {
+    assertEqual(primeFunction(17), true);
+    assertEqual(primeFunction(19), true);
+    assertEqual(primeFunction(23), true);
+    assertEqual(primeFunction(29), true);
+    assertEqual(primeFunction(31), true);
+    assertEqual(primeFunction(97), true);
+});
+
+// Test larger composites
+test("Larger composites: 21, 25, 49, 77, 91", () => {
+    assertEqual(primeFunction(21), false); // 3×7
+    assertEqual(primeFunction(25), false); // 5×5
+    assertEqual(primeFunction(49), false); // 7×7
+    assertEqual(primeFunction(77), false); // 7×11
+    assertEqual(primeFunction(91), false); // 7×13
+});
+
+console.log("\nAll tests completed!");
+
+// Export for potential use with other test frameworks
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = primeFunction;
+}

lesson_04/devynbenson/test_prime_function.py

@@ -0,0 +1,71 @@
+import unittest
+
+def prime_function(n: int) -> bool:
+    if n <= 1:
+        return False
+
+    if n <= 3:
+        return True
+
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    
+    # Check for divisors from 5 to √n
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    
+    return True
+
+
+class TestPrimeFunction(unittest.TestCase):
+    
+    def test_edge_cases(self):
+        """Test edge cases: numbers <= 1"""
+        self.assertFalse(prime_function(1))  # only one positive divisor
+        self.assertFalse(prime_function(0))
+        self.assertFalse(prime_function(-1))
+        self.assertFalse(prime_function(-5))
+    
+    def test_small_primes(self):
+        """Test small prime numbers"""
+        self.assertTrue(prime_function(2))   # only even prime
+        self.assertTrue(prime_function(3))
+        self.assertTrue(prime_function(5))
+        self.assertTrue(prime_function(7))
+        self.assertTrue(prime_function(11))
+        self.assertTrue(prime_function(13))
+    
+    def test_composite_numbers(self):
+        """Test composite numbers"""
+        self.assertFalse(prime_function(4))  # 4 = 2×2, composite
+        self.assertFalse(prime_function(6))  # 6 = 2×3, composite
+        self.assertFalse(prime_function(8))
+        self.assertFalse(prime_function(9))  # 9 = 3×3, composite
+        self.assertFalse(prime_function(10))
+        self.assertFalse(prime_function(12))
+        self.assertFalse(prime_function(15))
+    
+    def test_larger_primes(self):
+        """Test larger prime numbers"""
+        self.assertTrue(prime_function(17))
+        self.assertTrue(prime_function(19))
+        self.assertTrue(prime_function(23))
+        self.assertTrue(prime_function(29))
+        self.assertTrue(prime_function(31))
+        self.assertTrue(prime_function(97))
+    
+    def test_larger_composites(self):
+        """Test larger composite numbers"""
+        self.assertFalse(prime_function(21))  # 3×7
+        self.assertFalse(prime_function(25))  # 5×5
+        self.assertFalse(prime_function(49))  # 7×7
+        self.assertFalse(prime_function(77))  # 7×11
+        self.assertFalse(prime_function(91))  # 7×13
+
+
+if __name__ == '__main__':
+    # Run the tests
+    unittest.main()