Merge branch 'code-differently:main' into Work07

Author: DavisD251

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/justineklund/README.md

@@ -0,0 +1,45 @@
+Python examples
+
+```python
+def is_prime(n):
+    if n < 2:
+        return False
+    for i in range(2, int(n**0.5) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+# Example usage
+num = 29
+if is_prime(num):
+    print(f"{num} is a prime number.")
+else:
+    print(f"{num} is not a prime number.")
+```
+  
+  
+Java Examples
+
+```java
+    public class PrimeChecker {
+    public static boolean isPrime(int n) {
+        if (n < 2) return false;
+        for (int i = 2; i <= Math.sqrt(n); i++) {
+            if (n % i == 0) return false;
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int num = 29;
+        System.out.println(num + " is prime: " + isPrime(num));
+    }
+}
+```
+
+Similarties 
+They both use if and for standards to go about the command. This essentially gives the computer a path to go through to make sure the number is prime or not. They also both use the true and false function. This tells the computer how to go about the next commands. Also they both use division. Division is important because if it can be di
+vided or not crtical in figuring out if the number is prime.
+
+Differences
+A big difference is in the certain command language used. Examples begin in how they start. Java begins with public static and python begins with def is prime. This continues all throughout the code line with multiple commands being different.

lesson_04/karenalabi/README.md

@@ -0,0 +1,75 @@
+Lesson 04
+
+## Python Implementation 
+
+```python
+    # Defines a function named (primenumcheck) that calls a parameter (numbers)
+    def primenumcheck (number): 
+        # Conditional statements that determine if the number being returned is prime
+        if number <= 1:
+            return False
+        if number == 2:
+            return True
+        if number % 2 == 0:
+            return False
+        # For loop to check if numbers greater than 2 are prime
+        for i in range(3, int(number ** 0.5) + 1, 2):
+        if number % i == 0:
+            return False
+    return True
+```
+
+## Java Implementation
+
+```java
+   // Declaring the class in program (PrimeNumberChecker)
+    public class PrimeNumberChecker
+         // boolean method to check if integer is Prime
+         // access modifier to start the program
+        public static boolean checkIfPrime (int number) {
+            // Conditional statements to determine if number is prime
+            if (number <= 1) {
+                return false;
+            }
+            if (number == 2) {
+                return true;
+            } 
+            if (number % 2 == 0) {
+                return false;
+            }
+            // For loop to check if mumbers greater than 2 are prime
+            for (int i = 3; i <= Math.sqrt(number); i += 2) {
+                if (number % i == 0) {
+                        return false;
+                }
+            }
+        return true;
+        }
+```
+
+
+## Explanation
+The Python implementation defines a function named with the `def` keyword. The function is called `primenumcheck` and it calls a parameter `number` and determines whether it is prime. The python implementation then uses condiitonal if - statements to return false if the number is less than or equal to 1, or if the number is divisible by 2 becuase prime numbers can only be divisible by themselves and are greater than 1. The function will return true if the number returned is equal to 2. The python implementation also uses a `for` loop to iterate through the odd numbers up to the squareoot of that given number. If any of these numbers evenly divides `number`, it is not prime, and will return false. The loop increments by 2 (`i += 2`) to rule out even numbers.
+
+The Java implementation follows a similar logic to the python implementation. It defines a public class named `PrimeNumberChecker`. Within this class, a `boolean` method called `checkIfPrime` is implemented to determine if an integer is prime or not. The method takes an `int` (integer) parameter called `number` and uses conditional statements (if-statements) to check if the input number is prime. Similar to the python inplementation, the java implementation also used a for-loop to iterate through numbers not evenly divisible by the given number. 
+
+### Differences 
+
+1. **Syntax**:
+    - In Python, the function is defined using the `def` keyword. The fucntion can be defined by directly calling the name `primenumcheck`. Whereas, in Java, the proper term is a method and methods are defined within a class using a return type `boolean`, in this case. The Java implementation will return true or fase based on the int parameter called `number`.
+
+    - Python uses indentation to define the beginning and end of that portion of code, while Java uses curly braces `{}`.
+
+    - Python capitalizes its boolean values. It uses `True` and `False`. Java does not capitalize the boolean values.
+
+    - Python uses hashes to comment out the code while java uses back slashes 
+
+2. **Type System**:
+     - Java requires the type of method (`boolean` or `int`) to be declared within an access modifier: `public static boolean checkIfPrime` , whereas the Python function can be called by its name: `def primenumcheck`
+        
+     - Java uses `boolean` to return `checkIfPrime` method, whereas the Python implementation returns True or False based on the if-statement conditions
+3. **Function Calls**:
+    - the python implementation uses a range within the for loop
+
+    - the java implementation uses the math sqroot 
+

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 @@
+{}

lesson_08/algos/eslint.config.js

@@ -0,0 +1,28 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import stylistic from '@stylistic/eslint-plugin';
+import eslintConfigPrettier from 'eslint-config-prettier';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.strict,
+  ...tseslint.configs.stylistic,
+  eslintConfigPrettier,
+  {
+    ignores: ['build'],
+    plugins: { '@stylistic': stylistic },
+    rules: {
+      '@typescript-eslint/interface-name-prefix': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/no-extraneous-class': 'off',
+      '@stylistic/quotes': [
+        'error',
+        'single',
+        { avoidEscape: true, allowTemplateLiterals: false },
+      ],
+    },
+  },
+);

lesson_08/algos/jest.config.js

@@ -0,0 +1,11 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+export default {
+  testEnvironment: 'node',
+  transform: {
+    '^.+.tsx?$': ['ts-jest', { useESM: true }],
+  },
+  moduleNameMapper: {
+    '^(\\.\\.?\\/.+)\\.js$': '$1',
+  },
+  extensionsToTreatAsEsm: ['.ts'],
+};