Merge branch 'code-differently:main' into Shawn-lesson06

Author: Djtheman1

.devcontainer/devcontainer.json

@@ -35,7 +35,9 @@
 				"ms-dotnettools.csdevkit",
 				"ritwickdey.LiveServer",
 				"mechatroner.rainbow-csv",
-				"alexcvzz.vscode-sqlite"
+				"alexcvzz.vscode-sqlite",
+				"Orta.vscode-jest",
+				"firsttris.vscode-jest-runner"
 			],
             "settings": {
                 "terminal.integrated.defaultProfile.linux": "zsh",

.github/workflows/check_lesson_05_pr.yaml

@@ -0,0 +1,32 @@
+name: Check Lesson 05 Quiz Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_05/quiz/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+
+    - name: Build Shared Lib with Node.js
+      working-directory: ./lib/typescript/codedifferently-instructional
+      run: npm ci
+
+    - name: Build Lesson 06 with Node.js
+      working-directory: ./lesson_05/quiz
+      run: |
+        npm ci
+        npm run check

.github/workflows/check_lesson_06_pr.yaml

@@ -0,0 +1,32 @@
+name: Check Lesson 06 Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_06/expression/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+
+    - name: Build Shared Lib with Node.js
+      working-directory: ./lib/typescript/codedifferently-instructional
+      run: npm ci
+
+    - name: Build Lesson 06 with Node.js
+      working-directory: ./lesson_06/expression
+      run: |
+        npm ci
+        npm run check

.github/workflows/check_lesson_07_pr.yaml

@@ -0,0 +1,32 @@
+name: Check Lesson 07 Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_07/conditionals/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+
+    - name: Build Shared Lib with Node.js
+      working-directory: ./lib/typescript/codedifferently-instructional
+      run: npm ci
+
+    - name: Build Lesson 07 with Node.js
+      working-directory: ./lesson_07/conditionals
+      run: |
+        npm ci
+        npm run check

.github/workflows/check_push.yml

@@ -56,4 +56,16 @@ jobs:
         npm run compile
         npm run lint
 
+    - name: Build Lesson 06 with Node.js
+      working-directory: ./lesson_06/expression
+      run: |
+        npm ci
+        npm run compile
+
+    - name: Build Lesson 07 with Node.js
+      working-directory: ./lesson_07/conditionals
+      run: |
+        npm ci
+        npm run compile
+
 

README.md

@@ -0,0 +1,50 @@
+## Javascript
+``` javascript
+
+function isPrime(num) {
+  if (num < 2) {
+    return false; // Numbers less than 2 are not prime
+  }
+
+  for (let i = 2; i < num; i++) {
+    if (num % i === 0) {
+      return false; 
+    }
+  }
+  
+  return true; 
+}
+
+console.log(isPrime(5)); //true
+console.log(isPrime(1)); //false
+
+```
+## Ruby  
+###### Tutorial used : https://www.youtube.com/watch?v=33pLqGvk-PM
+``` ruby
+def prime?(n)
+# '2..n-1' checks all the numbers from 2 up to less than 'n'.
+# 'none' -> sees if none of these numbers can divide 'n' evenly.
+  (2..n-1).none? {|divisor| n % divisor == 0}
+# If none of these numbers divide 'n' without a remainder,
+# then 'n' is a prime number. Otherwise, it's not.
+end
+
+p prime? 5 # prints 'true'
+p prime? 6 # prints 'false'
+p prime? 7 # also 'true'
+```
+
+
+## Explanation 
+
+My JavaScript implementation uses a function named ```isPrime``` that checks if a number is prime by first returning `false` if the number is less than 2, since prime numbers are greater than 1. Then, it tests every number from 2 up to one less than the given number to see if any of them can divide it without leaving a remainder. If it finds one that can divide it evenly, it returns `false` ; if not, it returns `true`, meaning the number is prime.
+
+The ruby implementation has a function named ```prime?``` that also looks at all the numbers from 2 up to one less than the number given. Same rules apply: If none of those numbers can divide it evenly, then it prints ```true```. For example, it tells us if 5 and 7 are prime (they are!) and if 6 is prime (it’s not!).
+
+### Differences
+1. Instead of ```function``` used to define what your function is in javascript, Ruby use ```def```
+2. Ruby is much more simple - where tthe ```if``` and ```else``` statement is simply in one line
+3. Ruby simply 'prints' the result of its functions rather than ```console.log();``` 
+
+

lesson_04/amiyahjones/README.md

@@ -0,0 +1,77 @@
+# Prime Number Finder (Python and JavaScript) #
+
+This project demonstrates how to find prime numbers between 1 and 100 using two programming languages: Python and JavaScript. Each function uses a for loop to check whether a number is prime, and both include inline comments to explain the code step by step. Additionally, there are detailed explanations after each function.
+
+## Prime Number Finder in Python ##
+```
+# Function to find prime numbers between 1 and 100 in Python
+def find_prime_num_py():
+
+    # Loop through numbers from 2 to 100
+    for num in range(2, 101):
+        is_prime = True # Assume the number is prime
+
+        # Check if num is divisible by any number between 2 and its square root
+        for i in range(2, int(num**0.5) + 1):
+            if num % i == 0:
+                is_prime = False # If divisible, not a prime number
+                break # Exit the loop early
+
+        # If is_prime is still true, num is a prime number
+        if is_prime:
+            print(num) # Output the prime number
+
+# Call the Python function
+find_prime_num_py()
+```
+### Python Explanation: ###
+The Python function, find_prime_num_py, uses a for loop to iterate through the numbers between 2 and 100. The is_prime variable is set to True for each number. Inside the inner loop, we check if the number is divisible by any integer between 2 and the square root of the number. If the number is divisible, it is marked as not prime, and we break out of the inner loop to stop further unnecessary checks. The square root limit ensures better performance. When the number is confirmed to be prime, it is printed to the console.
+
+
+## Prime Number Finder in JavaScript ##
+```
+// Function to find prime numbers between 1 and 100 in JavaScript
+function findPrimeNumberJS() {
+
+    // Loop through numbers from 2 to 100
+    for (let num = 2; num <= 100; num++) {
+        let isPrime = true; // Assume the number is prime
+
+        // Check if num is divisible by any number between 2 and its square root
+        for (let i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i === 0) {
+                isPrime = false; // If divisible, not a prime number
+                break; // Exit the loop early
+            }
+        }
+
+        // If isPrime is still true, num is a prime number
+        if (isPrime) {
+            console.log(num); // Output the prime number
+        }
+    }
+}
+
+// Call the JavaScript function
+findPrimeNumberJS();
+```
+
+### JavaScript Explanation: ###
+In this JavaScript function, findPrimeNumberJS, we use a for loop to iterate over the numbers from 2 to 100. The isPrime variable initially assumes that each number is prime. For each number num, we check if it is divisible by any number from 2 to the square root of num. If the number is divisible, it is marked as not prime by setting isPrime to false, and we break out of the inner loop to save time. If the number remains prime after the check, it is printed to the console. The square root check ensures we minimize the number of iterations for efficiency.
+
+## Similarities and Differences Between Python and JavaScript Prime Number Functions ##
+
+### Similarities
+
+* Logic (Using Square Roots to Check Primes): Both functions in Python and JavaScript use the same fundamental logic to determine if a number is prime. By checking divisors only up to the square root of the number, we can efficiently reduce the number of checks. This optimization works in both languages because if a number has a divisor greater than its square root, it must also have a corresponding smaller divisor, which would have been checked already.
+
+* Looping Structure: Both functions use a for loop to iterate over potential divisors, starting from 2. While the exact syntax differs, the purpose is the same—to test whether the number is divisible by any number within this range. If no divisor is found, the number is prime.
+
+
+### Differences:
+
+* Syntax: Python uses range() to generate numbers in a loop, while JavaScript directly declares the loop variable and sets its conditions. Python also uses indentation to define code blocks, while JavaScript uses curly braces {}.
+
+* Case Sensitivity: Python commonly uses snake_case for function and variable names (e.g., is_prime), while JavaScript typically uses camelCase (e.g., isPrime).
+
+* Variable Declarations: In Python, variables are declared by simply assigning a value to them (e.g., num = 5). In JavaScript, variables must be explicitly declared using let, const, or var (e.g., let num = 5).

lesson_04/chelseaogbonnia/README.md

@@ -0,0 +1,70 @@
+## Python implementation
+
+```python
+def is_prime(num): 
+# uses the function is_prime and takes the argument num
+    if num > 1: 
+# gets rid of numbers 1 and lower as the first prime number is 2
+        for i in range(2, (num // 2) + 1):
+# tells the computer to look at all numbers between 2 and half of the value of num rounded up to the next nearest value using floor division
+            if(num % i) == 0: 
+# then divides the num value, using modulo division, by every number in the range of two to +infinity 
+            return False 
+# if the remainder in equivalent to 0 then the number is not prime and returns False
+        else:
+            return True 
+# if the remaineder is not equivalent to 0 then the terminal will return True     
+    else:
+        return False
+# for all other real numbers that arent prime the terminal will reurn False
+
+print(is_prime(19)) #Output: True
+print(is_prime(9)) #Output: False
+```
+
+## Ruby implementation
+
+```ruby
+def isPrime(n) 
+#uses the function isPrime and takes the argument n
+    return false if n <= 1 
+#the computer will reurn false for all numbers less than or equal to zero
+    return true if n == 2 || n == 3 
+#tells the computer to return true if the n is equivalent to 2 or 3
+
+    return false if n % 2 == 0 || n % 3 == 0 
+#returns false if n is divisible by two or 3
+
+    i = 5 
+#defines i  starting value as 5
+    while i * i <= n 
+#while n is greater than or equal to 25
+        return false if n % i == 0 || n % (i + 2) == 0 
+#return false if n is divisible by 5 or 7
+        i += 6 
+#adds 6 to the value of i if n is not divisible by 5 or 7 and runs the loop again
+    end    
+    true 
+#returns true for all numbers that arent divisible by 2, 3, 5, or 7
+end
+puts isPrime(17) #Output: true
+puts isPrime(24) #Output: false
+```
+
+## Explanation
+
+The Python implementation uses a function named `is_prime` that takes a single argument `num`. It returns `False` if the number is 1 or less or divisible by any number from two to half the value of `num` (i.e., when the remainder of the division of the number by 2 is zero), otherwise, it returns `True` and returns any possible other values as false.
+
+The Ruby implementation uses a function named `isPrime` that also takes a single argument `n`. It returns `true` if the number is equivalent to 2 or 3 and if the number is not divisible by 2 or 3 and 5 or 7 if the number is over 25 and `false` if otherwise.
+
+### Differences
+
+1. **Syntax**: 
+   - Python uses `True` and `False` for boolean values, while Ruby uses `true` and `false`.
+   - The formatting for `if` statements are also different between the two. In Python, `if` statements have the initial statement and then on the next line the command to run if the variable falls under the `if` statement. In Ruby the formatting is completely different, the command comes first and after that the `if` statement comes in on the same line
+   - In Python, a colon(`:`) is used to close function statements, whereas in Ruby there is nothing closing the function statements.
+   - Ruby can return true or false without a return statement.  In contrast Python requires a return statement or will return with `None`.
+   - Ruby has to be closed in `end` after loops or an error will appear and the code won't run. Python, on the other hand doesn't need anything and will return with `None` instead of an error if not given further instructions.
+   - The syntax for calling functions and printing to the console/output is different. Python uses `print()`, while Ruby uses `puts()`.
+
+<!-- Used code from geeksforgeeks.org to assist in creating assignment -->