Merge branch 'main' into longest_word

collaboration/communication.md

@@ -29,19 +29,19 @@ How often we will get in touch on each channel, and what we will discuss there:
 | Clement| 6-8 PM | 6-8 PM  | 6-8 PM    | 6-8 PM   | 6-8 PM | 6-8 PM   | 6-8 PM |
 | Fahed  | 6-8 PM | 7-9 PM  | 6-8 PM    | 5-7 PM   | 8-9 PM | 8-9 PM   | 6-8 PM |
 | Faisal | $TIME$ | $TIME$  | $TIME$    | $TIME$   | $TIME$ | $TIME$   | $TIME$ |
-| Majd   |6-8 PM  | 6-8 PM  | 5-6 PM    | 4-7 PM   | 4-7 PM | 4-7 PM   | 7-9 PM |
+| Majd   | 6-8 PM | 5-6 PM  | 7-9 PM    | 5-7 PM   |7-9 PM  | 6-8 PM   | 6-8 PM |
 | Mohamed| 6-9 PM | 6-9 PM  | 6-9 PM    | 6-10 PM  | 2-9 PM | 6-9 PM   | 6-9 PM |
 | Obey   | $TIME$ | $TIME$  | $TIME$    | $TIME$   | $TIME$ | $TIME$   | $TIME$ |
 | Özgür  | 5-7 PM | 5-7 PM  | 5-7 PM    | 5-7 PM   | 5-7 PM | 5-7 PM   | 5-7 PM |
-| Razan  | 7-9 PM | 9-10 PM  | 7-9 PM    | 7-9 PM   | 7-9 PM | 7-9 PM  | 7-9 PM |
+| Razan  | 7-9 PM | 9-10 PM | 7-9 PM    | 7-9 PM   | 7-9 PM | 7-9 PM   | 7-9 PM |
 
 ### How many hours everyone reserves for Code review per day
 
 - Anas: 2 Hours
 - Clement: 1.5 hours
 - Fahed: 1 hour
 - Faisal: $HOURS$
-- Majd: $HOURS$
+- Majd: 4 hours
 - Mohamed: 2 hours
 - Obey: $HOURS$
 - Özgür: 2 hours

solutions/README.md

@@ -29,10 +29,18 @@ while corresponding test files are maintained in the `tests` folder.
 | `grading_system.py`| Assigning letter grade to a numeric score.  | Razan |
 | `kronecker_product.py` | Computes the Kronecker ⊗ product of 2 matrices | Fahed|
 | `feet_to_meters.py` | Converting feet to meters| Obay |
+| `area_circle.py`| Calculates the area of the circle | Majd |
+| `multiplication.py`| Calculate the multiple of two numbers | Majd|
+| `square.py`| Find the number power of two | Majd |
 | `volts_to_amperes.py` | Converting volts to amperes| Obay |
 | `miles_to_kilometers.py` | Converting miles to kilometers| Obay |
 | `greatest_number.py` | Finding greatest number in a list| Razan |
+| `common_elements.py`   | finding common elements in two lists       | Mohamed|
+| `simple_calculator.py` | performs simple operations on two integers | Mohamed|
+| `reverse_string.py`    | reverses contents of an input string       | Mohamed|
 | `check_prime_number.py` | Given a positive int if it is a prime number| Özgür |
+| `password_strength.py` | Checks the strength of a password| Anas |
+| `decimal_to_binary.py` | Converts decimal to its equivalent binary| Anas |
 
 ---
 

solutions/area_circle.py

@@ -0,0 +1,35 @@
+"""
+Group: ET6-foundations-group-16
+Author:Majd Abualsoud
+Date: January 11, 2025
+This module provides a function to calculate the area of a circle given its radius.
+"""
+
+import math
+
+
+def area_of_circle(radius: float) -> float:
+    """
+    Calculate the area of a circle given its radius.
+
+    Args:
+        radius (float): The radius of the circle. Must be a non-negative number.
+
+    Returns:
+        float: The area of the circle.
+
+    Raises:
+        ValueError: If the radius is negative.
+
+    Examples:
+        >>> area_of_circle(1)
+        3.141592653589793
+        >>> area_of_circle(0)
+        0.0
+        >>> area_of_circle(2.5)
+        19.634954084936208
+    """
+    if radius < 0:
+        raise ValueError("The radius must be a non-negative number.")
+
+    return math.pi * radius * radius

solutions/common_elements.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+A module for finding the common elements between two input lists.
+
+Created on 11/1/2025
+@author: Mohamed Altayeb
+Group: ET foundations group 16 (Matrix)
+
+Module functions:
+    - common_elements: finds the common elements between two lists.
+
+"""
+
+
+def common_elements(list1: list, list2: list) -> list:
+    """
+    Compares two input lists and returns a list that contains
+    all the common elements between the two input lists without repeating
+    the common elements if they are duplicated in the input lists:
+
+    Arguments:
+        list1 (list): the first list we want to compare.
+        list2 (list): the second list we want to compare.
+
+    Returns-> list: A list containing all common elements between two input lists,
+                    the returned list will have the common elements of the first input list
+                    followed by the common elements of the second input list.
+
+
+    Raises:
+    AssertionError: if inputs are not lists.
+
+    >>> common_elements([1,2,3,4,5,6] , [4,5,6,7])
+    [4, 5, 6]
+
+    >>> common_elements(["c", "a", "r"] , ["c", "a", "t"])
+    ['c', 'a']
+
+    >>> common_elements([[1,2] , [2,3,4], ["mohamed"]]  ,  [["mohamed"], [1,2,3], [2,3,4], [4,5,6]])
+    [[2, 3, 4], ['mohamed']]
+    """
+    # Ensure both inputs are lists
+    if not isinstance(list1, list) or not isinstance(list2, list):
+        raise AssertionError("Both inputs must be lists")
+
+    common_list_no_duplicates = []
+
+    # Iterate through elements of the first list
+    for element1 in list1:
+        # Iterate through elements of second list comparing
+        # each element in the second list to the element in the first list
+        for element2 in list2:
+            if element1 == element2 and element1 not in common_list_no_duplicates:
+                # Add the element to the resultant list
+                common_list_no_duplicates.append(element1)
+
+    # Return the resultant list with common elements with no duplicated elements
+    return common_list_no_duplicates

solutions/multiplication.py

@@ -1,6 +1,9 @@
 #!/usr/bin/env python3
 # -- coding: utf-8 --
 """
+Group: ET6-foundations-group-16
+Author:Majd Abualsoud
+Date: January 11, 2025
 A module for multiplying two numbers.
 Module contents:
     - multiply_numbers: Multiplies two numbers and returns the product.

solutions/tests/test_area_circle.py

@@ -0,0 +1,39 @@
+"""
+Group: ET6-foundations-group-16
+Author:Majd Abualsoud
+Date: January 11, 2025
+Test suite for the area_of_circle function.
+"""
+
+import math
+import unittest
+
+from ..area_circle import area_of_circle
+
+
+class TestAreaOfCircle(unittest.TestCase):
+    """
+    Unit tests for the area_of_circle function.
+    """
+
+    def test_positive_radius(self):
+        """Test area calculation with a positive radius."""
+        self.assertAlmostEqual(area_of_circle(1), 3.141592653589793)
+        self.assertAlmostEqual(area_of_circle(2.5), 19.634954084936208)
+
+    def test_zero_radius(self):
+        """Test area calculation with a radius of zero."""
+        self.assertAlmostEqual(area_of_circle(0), 0.0)
+
+    def test_negative_radius(self):
+        """Test area calculation with a negative radius."""
+        with self.assertRaises(ValueError):
+            area_of_circle(-1)
+
+    def test_large_radius(self):
+        """Test area calculation with a large radius."""
+        self.assertAlmostEqual(area_of_circle(1e6), math.pi * 1e6 * 1e6)
+
+
+if __name__ == "main":
+    unittest.main()

solutions/tests/test_common_elements.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test module for common_elements function
+
+Test categories:
+ -Standard cases: typical inputs
+ -Edge cases: extreme inputs and boundaries
+ -Defensive tests: wrong input types, assertions
+
+Created on 11/1/2025
+@author: Mohamed Altayeb
+Group: ET foundations group 16 (Matrix)
+"""
+
+import unittest
+
+from ..common_elements import common_elements
+
+
+class TestCommonElements(unittest.TestCase):
+    """Test suite for the common_elements function"""
+
+    # Standard cases
+    def test_lists_with_integers(self):
+        """it should return a list with the common integers between the two input lists"""
+        self.assertEqual(common_elements([1, 2, 3], [2, 3]), [2, 3])
+
+    def test_lists_with_string_elements(self):
+        """it should return a list with the common string elements between the two input lists"""
+        self.assertEqual(common_elements(["a", "b", "c"], ["b", "c"]), ["b", "c"])
+
+    def test_lists_with_duplicated_elements(self):
+        """it should return a list with the common elements between the two input lists
+        without duplicating the elements in the output list"""
+        self.assertEqual(common_elements(["a", "b", "b"], ["b", "b", "c"]), ["b"])
+
+    def test_lists_with_mixed_string_and_integer_elements(self):
+        """it should return a list with the common string elements between the two input lists"""
+        self.assertEqual(
+            common_elements(["a", "b", 2, 56, "abc"], ["abc", 56, 999]), [56, "abc"]
+        )
+
+    def test_lists_within_lists(self):
+        """it should return a list with the common elements between the two input lists
+        even if the elements are lists as well"""
+        self.assertEqual(
+            common_elements(
+                [[1, 2], [2, 3, 4], ["mohamed"]],
+                [["mohamed"], [1, 2, 3], [2, 3, 4], [4, 5, 6]],
+            ),
+            [[2, 3, 4], ["mohamed"]],
+        )
+
+    def test_order_of_elements_in_output_list(self):
+        """the function should prioritize the order of the elements in the first input list"""
+        self.assertEqual(common_elements([1, 2, 3], [3, 2, 1]), [1, 2, 3])
+
+    # Edge cases
+    def test_long_lists(self):
+        """it should return a list with the common elements between the two input lists
+        regardless of the length of the input lists"""
+        self.assertEqual(
+            common_elements(
+                [
+                    1,
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    7,
+                    8,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                ],
+                [
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                    9,
+                ],
+            ),
+            [9],
+        )
+
+    def test_one_of_the_lists_is_empty(self):
+        """it should return an empty list"""
+        self.assertEqual(common_elements(["Mohamed", "cat", "1,2,3"], []), [])
+
+    def test_both_of_the_lists_are_empty(self):
+        """it should return an empty list"""
+        self.assertEqual(common_elements([], []), [])
+
+    # Defensive tests
+    def test_input1_is_not_a_list(self):
+        """It should raise AssertionError if first input is not a list"""
+        with self.assertRaises(AssertionError):
+            common_elements("mohamed", [1, 2, 3, 4, 5, 6])
+
+    def test_input2_is_not_a_list(self):
+        """It should raise AssertionError if second input is not a list"""
+        with self.assertRaises(AssertionError):
+            common_elements([1, 2, 3, 4, 5, 6], "numbers")