Merge branch 'lesson_07-homework' of https://github.com/jxwatson251/code-differently-25-q1 into lesson_07-homework

Author: jxwatson251

.github/workflows/check_lesson_09_pr.yaml

@@ -0,0 +1,27 @@
+name: Check Lesson 09 Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_09/types/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up JDK
+      uses: actions/setup-java@v4
+      with:
+        java-version: '21'
+        distribution: 'temurin'
+
+    - name: Build Lesson 09 with Gradle
+      working-directory: ./lesson_09/types
+      run: ./gradlew check

lesson_04/dariusd/README.md

@@ -0,0 +1,60 @@
+# Prime Time
+
+## Composite # Check Python
+ ### Requirements
+- Python 3.x
+
+```python
+# Function to check if a number is composite
+def is_composite(number):
+    if number < 2:
+        return f"{number} is neither prime nor composite."
+
+    # Check for factors from 2 to sqrt(number)
+    for i in range(2, int(number**0.5) + 1):
+        if number % i == 0:
+            return f"{number} is a composite number."
+
+    return f"{number} is a prime number."
+```
+
+## Prime # Check Bash
+
+```bash
+# Function to check if a number is prime
+is_prime() {
+    local num=$1
+    if ((num <= 1)); then
+        echo "$num is not prime."
+        return 1
+    fi
+    # Function to check factors from 2 to square root(number)
+    for ((i = 2; i <= num / 2; i++)); do
+        if ((num % i == 0)); then
+            echo "$num is not prime."
+            return 1
+        fi
+    done
+    echo "$num is prime."
+}
+```
+
+## Explanation
+
+The Python Script isn't your conventional prime number detector. Instead I took the approach of using a composite number detector that uses the function `is_composite` to show weather the `number` you input is composite. If inputted number is less than 2 then `it's neither prime nor composite`. If previous rule is false(greater than 2) then we run factors of 2 to the square root to determine `results`. Any factor larger than the square root would already have a corresponding smaller factor so will know if our `number is composite` or not.
+
+ Next, the Bash Script is a classic prime numbers check that uses the function `is_prime` to... you've guessed it check if users number is a prime. Said function will first check if the inputted `number` is greater than or equal to 1; If said previous rule was true then the we stop. If false, then it will run sequence to determine if said number is has factors from 2 to square root of number. When done if 2 factors are found it `isn't a prime number` and `is a prime number` if 2 aren't found. System will `echo`(notify user) of final verdict.
+
+## Differences
+
+
+1. **Syntax**: 
+   - In Python, we use `def` as our keyword and `int` as a way to describe the inputted number.
+   - In Bash we use `local` as our keyword and `num`/`$num` as a way to describe inputted number from users.
+   
+2. **Function Calls**:
+   - `Print` is used to call functions and output information for Python while `Echo` is  used for Bash, in which both give info to the the user.
+
+3. **Composite vs Prime**:
+   - The Python script is used to determine weather the inputted number `is a Composite number`; In doing so we also get the reciprocal on if it's a prime number as well.
+   - The Bash Script is the opposite in which where looking for if the inputted number `is prime` and in doing so we get the reciprocal if it isn't.

lesson_04/dylanlafferty/ReadME.md

@@ -0,0 +1,81 @@
+## Java Implementation
+
+```class PrimeChecker {
+    public static boolean isPrime(int number) {
+        if (number <= 1) {
+            return false;
+        }
+
+        // Check if number is divisible by any number from 2 to sqrt(number)
+        for (int i = 2; i <= Math.sqrt(number); i++) {
+            if (number % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int num1 = 11; //This number may be changed to change the input 
+        int num2 = 15; //This one too
+        System.out.println(num1 + " is prime: " + isPrime(num1));
+        System.out.println(num2 + " is prime: " + isPrime(num2));
+    }
+}
+```
+
+## JavaScript implementation
+
+```
+// let number = prompt("Enter a number to check if it is a Prime number");
+
+function checkPrime(number) {
+    if (number === null || number === undefined) {
+        console.log("You have not entered a number");
+        return;
+    }
+
+    if (number <= 1) {
+        console.log("This is not a prime number");
+        return false; // Numbers less than or equal to 1 are not prime
+    }
+
+    for (let i = 2; i < Math.sqrt(number); i++) {
+        if (number % i === 0) {
+            console.log("This is not a prime number");
+            return false; // If divisible by any number other than 1 and itself
+        }
+    }
+
+    console.log("This is a prime number");
+    return true; // If no divisors were found, the number is prime
+}
+
+console.log(checkPrime(45)); // 
+console.log(checkPrime(23)); // 
+console.log(checkPrime(13)); // 
+```
+
+## Explaination
+
+The Java
+The Java implementation uses a class named `PrimeChecker`. `PrimeChecker` will get an integer named `number` and run it through 2 tests. The first test will be to see if `number` is less than or greater than 1 which then will return `false`.  It will then see if the number is able to be divided by anything other than itself and if not then it will return `True`.
+
+The JavaScript implementation uses a function named `checkPrime`. `CheckPrime` first checks if a `number` has been entered. If a `number` has been entered and if it is less than or equal to 1 it will return `True`. If this passes the for loop will run and see if that `number` can be divided into itself and if it can then return `False`.  
+
+## Similarites
+1. **Syntax**
+    - Both languages write If statements in the same way using `if(instance) { code } `.
+    - The For Loop are both written using `for` and adding the statements inside of `(statement1)`.
+    - Math works the same in both languages using the `%` for division.
+2. **Input Fields**
+    - Both Languages can have a predefined input inside of the code.
+    - Both Languages can return either `true` or `false` to the console.
+
+## Differences
+1. **Syntax**
+    - In `Java` there are two Static functions but one it required to be defined as main. However in `JavaScript` you do not need to define a main function.
+    - In `Java` in order to print something you have to write a `system.out.print` compared to `JavaScript` It uses the `console.log`.
+2. ## Declarations
+    - With `Java` You have to let the computer know what type of input you are giving it. So if you would want to give a variable a number you need to declare that as an integer or `int`. While you can just write a number out in `javaScript`.
+    

lesson_04/ezra4/README.md

@@ -1,29 +1,47 @@
 ## Python Implementation
 
 ```python
-def prime_num(num):
+def is_prime(num):
     if num <= 1:
         return False
-    for i in range(2, num): 
+    for i in range(2, num):
         if num % i == 0:
             return False
     return True
+
+def main():
+    num = int(input("Enter a number: "))
+    print(f"{num} is prime." if is_prime(num) else f"{num} is not prime.")
+
+if __name__ == "__main__":
+    main()
 ```
 
 ## Java Implementation
 
 
 ```java
-public static void main(String[] args) { 
-    Scanner scanner = new Scanner(System.in);
-    System.out.print("Enter a number:");
-    int num = scanner.nextInt();
-
-    if (isPrime(num)) {
-        System.out.println(num + " is prime.");
+import java.util.Scanner;
+
+public class PrimeChecker {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter a number: ");
+        int num = scanner.nextInt();
+        System.out.println(num + (isPrime(num) ? " is prime." : " is not prime."));
+        scanner.close();
     }
-    else {
-        System.out.println(num + " is not prime.");
+
+    public static boolean isPrime(int num) {
+        if (num <= 1) {
+            return false;
+        }
+        for (int i = 2; i < num; i++) {
+            if (num % i == 0) {
+                return false;
+            }
+        }
+        return true;
     }
 }
 ```
@@ -46,5 +64,6 @@ In java we have a different approach. Unlike python we define our class using `(
 
 2. Java uses `System.out.print()` to print out the statement and python uses `print()` to print statement.
 
-
-3. I notice i have to import `java.util.Scanner` to prompt user to input a number while python you only need to use, `input()`
+3. I notice i have to import `java.util.Scanner` to prompt user to input a number while python you only need to use, `input()`
+4. Java uses `{}` for blocks and `;` to end statement while python doesn't need semicolons.
+   

lesson_05/dylanlafferty/README.md

@@ -0,0 +1,12 @@
+
+
+## Three user Stories
+    ```
+    1. As a `Line Cook`, `I want ` an application that allows me to see an easy-to-read ticket that only displays items that belong to my station on that ticket. `So that` I can quickly make entrees faster and be able to focus on what is on my stations end other than the other stations.
+
+    2. As a `Software engineer`, `I want` a program that will allow me to drag and drop different css elements, `So that` I can efficently create a custom webpage without having to spend hours making the perfect CSS.
+
+    3. As a `Inventory Stock`, `I want` a program that will keep track of items in my storage and when that item hits a certain number it will automatically send order. `So that` I can automate my storage process and spend time reordering on other tasks in the store.
+    ```
+
+    

lesson_08/README.md

@@ -13,4 +13,7 @@ Please review the following resources before lecture:
 
 ## Homework
 
-- TODO(anthonydmays): Add moar details
+- [ ] Memorize the `printPermutations` and `reverseString` methods in [algos_app][algos-app].
+- [ ] Do pre-work for [lesson 09](/lesson_09/).
+
+[algos-app]: ./algos/src/lesson8.ts

lesson_08/algos/.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true
+organize_imports = true
+trim_trailing_whitespace = true
+quote_type = single

lesson_08/algos/.eslintignore

@@ -0,0 +1 @@
+build/

lesson_08/algos/.prettierignore

@@ -0,0 +1,3 @@
+# Ignore artifacts:
+build
+coverage

lesson_08/algos/.prettierrc

@@ -0,0 +1 @@
+{}