feat: adds Jared's code samples (#185)

* feat: adds is_prime implementations in Python, JS, and TS

* feat:adds reafactored .py, .js, .ts files to reduce the logic per function

* feat: adds test_is_prime for all files. Renamed ts file to avoid errors with .js files Compiled test_is_primeTS.ts into .js file.

* feat: adds more context to README.md file

* feat: adds context into README.md

Author: Edge-J

lesson_04/jarededge/README.md

@@ -0,0 +1,59 @@
+## Explanation
+
+I know we were instruected to only implement 2 languages but I decided to do 3 to practice writing in these languages as much as I could. Each version of the isPrime function follows the same logical structure, broken down into small helper functions for clarity and maintainability. The logic checks if a number is less than or equal to 1, whether it's 2 or 3, if it's divisible by 2 or 3, and finally uses the 6k ± 1 optimization to check for other factors efficiently.
+
+## Differences for programs
+
+Function Declarations & Syntax:
+
+- Python uses def with colons and indentation.
+
+- JavaScript and TypeScript use function and curly braces.
+
+- TypeScript adds type annotations (e.g., n: number, : boolean).
+
+## Type Safety:
+
+- Python is dynamically typed but can include type hints.
+
+- JavaScript is fully dynamic and prone to runtime type errors.
+
+- TypeScript offers compile-time type checking for more robust code.
+
+##Booleans & Print Statements:
+
+- Python uses True/False and print()
+
+- JS/TS use true/false and console.log() (uses capitol letters)
+
+## Refactoring Practice:
+
+- All three versions refactor logic into smaller single-responsibility functions
+
+- This improves readability and testability
+
+Tooling Differences:
+
+- TypeScript requires a compiler (tsc) to convert code into JavaScript before execution
+
+- Python and JavaScript can run directly via interpreters (e.g., python, node)
+
+
+## Differences for tests
+
+
+## Test Frameworks & Syntax
+
+- Python (unittest): Uses the built-in unittest framework
+
+- JavaScript (Node assert): No framework; uses Node’s built-in assert with a manual runTests() function.
+
+- TypeScript (compiled JS): Compiled output JS that uses a custom assertEqual helper and a manual runTestsTS(); not using a TS-aware test runner in this artifact.
+  
+- All 3 tests used some sort of assert helper
+
+
+## Output
+
+- Python prints a structured summary (dots/letters, failures)
+- JavaScript and TypeScript Prints a message of completion or failure

lesson_04/jarededge/is_prime.js

@@ -0,0 +1,37 @@
+function isLessThanOrEqualToOne(n) {
+    return n <= 1;
+}
+
+function isTwoOrThree(n) {
+    return n === 2 || n === 3;
+}
+
+function isDivisibleByTwoOrThree(n) {
+    return n % 2 === 0 || n % 3 === 0;
+}
+
+function hasOtherDivisors(n) {
+    let i = 5;
+    while (i * i <= n) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return true;
+        }
+        i += 6;
+    }
+    return false;
+}
+
+function isPrime(n) {
+    if (isLessThanOrEqualToOne(n)) return false;
+    if (isTwoOrThree(n)) return true;
+    if (isDivisibleByTwoOrThree(n)) return false;
+    return !hasOtherDivisors(n);
+}
+
+module.exports = {isPrime};
+
+// Testing before JUnit tests
+const testNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 19, 21, 23, 26];
+testNumbers.forEach((num) => {
+    console.log(`${num} is prime? ${isPrime(num)}`);
+});

lesson_04/jarededge/is_prime.py

@@ -0,0 +1,36 @@
+def is_less_than_or_equal_to_one(n: int) -> bool:
+    return n <= 1
+
+
+def is_two_or_three(n: int) -> bool:
+    return n == 2 or n == 3
+
+
+def is_divisible_by_two_or_three(n: int) -> bool:
+    return n % 2 == 0 or n % 3 == 0
+
+
+def has_other_divisors(n: int) -> bool:
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return True
+        i += 6
+    return False
+
+
+def is_prime(n: int) -> bool:
+    if is_less_than_or_equal_to_one(n):
+        return False
+    if is_two_or_three(n):
+        return True
+    if is_divisible_by_two_or_three(n):
+        return False
+    return not has_other_divisors(n)
+
+
+# Testing the program before JUnit tests
+if __name__ == "__main__":
+    test_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 19, 21, 23, 26]
+    for num in test_numbers:
+        print(f"{num} is prime? {is_prime(num)}")

lesson_04/jarededge/is_primeTS.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimeTS = isPrimeTS;
+function isLessThanOrEqualToOneTS(n) {
+    return n <= 1;
+}
+function isTwoOrThreeTS(n) {
+    return n === 2 || n === 3;
+}
+function isDivisibleByTwoOrThreeTS(n) {
+    return n % 2 === 0 || n % 3 === 0;
+}
+function hasOtherDivisorsTS(n) {
+    var i = 5;
+    while (i * i <= n) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return true;
+        }
+        i += 6;
+    }
+    return false;
+}
+function isPrimeTS(n) {
+    if (isLessThanOrEqualToOneTS(n))
+        return false;
+    if (isTwoOrThreeTS(n))
+        return true;
+    if (isDivisibleByTwoOrThreeTS(n))
+        return false;
+    return !hasOtherDivisorsTS(n);
+}
+// Testing before JUnit tests
+var testNumbersTS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 19, 21, 23, 26];
+testNumbersTS.forEach(function (num) {
+    console.log("".concat(num, " is prime? ").concat(isPrimeTS(num)));
+});

lesson_04/jarededge/is_primeTS.ts

@@ -0,0 +1,44 @@
+
+
+
+
+
+
+
+function isLessThanOrEqualToOneTS(n: number): boolean {
+    return n <= 1;
+}
+
+function isTwoOrThreeTS(n: number): boolean {
+    return n === 2 || n === 3;
+}
+
+function isDivisibleByTwoOrThreeTS(n: number): boolean {
+    return n % 2 === 0 || n % 3 === 0;
+}
+
+function hasOtherDivisorsTS(n: number): boolean {
+    let i = 5;
+    while (i * i <= n) {
+        if (n % i === 0 || n % (i + 2) === 0) {
+            return true;
+        }
+        i += 6;
+    }
+    return false;
+}
+
+ export function isPrimeTS(n: number): boolean {
+    if (isLessThanOrEqualToOneTS(n)) return false;
+    if (isTwoOrThreeTS(n)) return true;
+    if (isDivisibleByTwoOrThreeTS(n)) return false;
+    return !hasOtherDivisorsTS(n);
+}
+
+// Testing before JUnit tests
+const testNumbersTS: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 19, 21, 23, 26];
+
+testNumbersTS.forEach((num) => {
+    console.log(`${num} is prime? ${isPrimeTS(num)}`);
+});
+

lesson_04/jarededge/test_is_prime.js

@@ -0,0 +1,19 @@
+const assert = require('assert');
+const { isPrime } = require('./is_prime');
+
+function runTests(){
+    assert.strictEqual(isPrime(2), true);
+    assert.strictEqual(isPrime(3), true);
+    assert.strictEqual(isPrime(17), true);
+    assert.strictEqual(isPrime(23), true);
+    assert.strictEqual(isPrime(1), false);
+    assert.strictEqual(isPrime(4), false);
+    assert.strictEqual(isPrime(9), false);
+    assert.strictEqual(isPrime(16), false);
+
+    console.log("All the test cases passed");
+
+
+}
+
+runTests();

lesson_04/jarededge/test_is_prime.py

@@ -0,0 +1,20 @@
+import unittest
+from is_prime import is_prime
+
+
+class TestisPrime(unittest.TestCase):
+    def test_primes(self):
+        self.assertTrue(is_prime(2))
+        self.assertTrue(is_prime(3))
+        self.assertTrue(is_prime(17))
+        self.assertTrue(is_prime(23))
+
+    def test_non_primes(self):
+        self.assertFalse(is_prime(1))
+        self.assertFalse(is_prime(4))
+        self.assertFalse(is_prime(9))
+        self.assertFalse(is_prime(16))
+
+
+if __name__ == "__main__":
+    unittest.main()

lesson_04/jarededge/test_is_primeTS.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var is_primeTS_1 = require("./is_primeTS");
+function assertEqual(actual, expected, label) {
+    if (actual !== expected) {
+        throw new Error("".concat(label, ") Test failed. Expected ").concat(expected, ", got ").concat(actual));
+    }
+}
+function runTestsTS() {
+    assertEqual((0, is_primeTS_1.isPrimeTS)(2), true, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(3), true, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(17), true, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(23), true, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(1), false, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(4), false, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(9), false, "prime");
+    assertEqual((0, is_primeTS_1.isPrimeTS)(16), false, "prime");
+    console.log("All the TS test passed");
+}
+runTestsTS();

lesson_04/jarededge/test_is_primeTS.ts

@@ -0,0 +1,23 @@
+import { isPrimeTS } from "./is_primeTS";
+
+function assertEqual(actual: boolean, expected: boolean, label: string){
+    if (actual !== expected){
+        throw new Error (`${label}) Test failed. Expected ${expected}, got ${actual}`);
+
+    }
+}
+
+function runTestsTS(){
+    assertEqual(isPrimeTS(2), true, "prime");
+    assertEqual(isPrimeTS(3), true, "prime");
+    assertEqual(isPrimeTS(17), true, "prime");
+    assertEqual(isPrimeTS(23), true, "prime");
+    assertEqual(isPrimeTS(1), false, "prime");
+    assertEqual(isPrimeTS(4), false, "prime");
+    assertEqual(isPrimeTS(9), false, "prime");
+    assertEqual(isPrimeTS(16), false, "prime");
+console.log("All the TS test passed");
+
+}
+
+runTestsTS();