Merge branch 'main' into factorial

.vscode/settings.json

@@ -114,7 +114,17 @@
 
   // Enable/disable update table of contents on save
   "markdown.extension.toc.updateOnSave": false,
+
   "[python]": {
-    "editor.defaultFormatter": "ms-python.black-formatter"
-  }
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "explicit",
+      "source.organizeImports.ruff": "explicit"
+    }
+  },
+  "cSpell.words": [
+    "Falaq",
+    "Youniss"
+  ]
 }

solutions/IsPrime.py

@@ -30,6 +30,8 @@ def IsPrime(a: int) -> str:
     prime
     >>> IsPrime(2.5)
     invalid input
+    >>> IsPrime(-1)
+    not prime
     """
     if not isinstance(a, int):
         return "invalid input"

solutions/cumulative_sum.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Module: cumulative_sum
+
+Description:
+    This module provides a function to calculate the cumulative sum of
+    a list of numbers(integers\float). It is useful for applications requiring progressive
+    accumulation of values, such as financial calculations, data analysis,
+    or custom mathematical operations.
+
+Module Contents:
+    - cumulative_sum(numbers: list) -> list:
+        Computes and returns a list of cumulative sums from the input list.
+
+Author: Falaq Youniss
+Date: 29/12/2024
+"""
+
+
+def cumulative_sum(numbers: list) -> list:
+    """
+    Computes the cumulative sum of a list of numbers.
+
+    Args:
+        numbers (list): A list of numeric values (integers or floats).
+
+    Returns:
+        list: A list where each element is the cumulative sum up to that index.
+
+    Raises:
+        AssertionError:
+            - If the input is not a list.
+            - If the list contains non-numeric values.
+            - If the input is `None`.
+
+    >>> cumulative_sum([1, 2, 3, 4])
+    [1, 3, 6, 10]
+    >>> cumulative_sum([-1, -2, -3, -4])
+    [-1, -3, -6, -10]
+    >>> cumulative_sum([1.0, 2.0, 3.0, 4.0])
+    [1.0, 3.0, 6.0, 10.0]
+    """
+    # Validate input
+    assert numbers is not None, "Input cannot be None."
+    assert isinstance(numbers, list), "Input must be a list of numeric values."
+    assert all(
+        isinstance(num, (int, float)) for num in numbers
+    ), "All elements in the list must be numeric."
+    # Compute cumulative sums
+    cumulative_list = []
+    current_sum = 0
+    for num in numbers:
+        current_sum += num
+        cumulative_list.append(current_sum)
+
+    return cumulative_list

solutions/mean.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+A module for finding the mean of a list of numbers.
+
+Module contents:
+    - mean: finds the mean of a list of numbers.
+
+Created on 29/12/2024
+@author: Mohammed Elfadil
+"""
+
+
+def mean(a: list) -> float:
+    """Finds the mean of a list of numbers.
+    Parameter:
+        a: list
+    Return -> float: the mean of the list
+    Raises:
+        AssertionError: if the argument is not a list
+    >>> mean([1, 2, 3, 4, 5])
+    3.0
+    >>> mean([10, 20, 30, 40, 50])
+    30.0
+    >>> mean([1.5, 2.5, 3.5])
+    2.5
+    >>>mean([2])
+    2.0
+    """
+    # check if the argument is a list
+    assert isinstance(a, list), "invalid input"
+
+    # return the mean of the list by dividing the sum of the list by the length of the list
+    return sum(a) / len(a)

solutions/tests/__init__.py

@@ -1 +0,0 @@
-

solutions/tests/test_cumulative_sum.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Module: test_cumulative_sum
+
+Description:
+    This module contains test cases for the `cumulative_sum` function defined
+    in the `cumulative_sum.py` module. It tests the function's behavior with
+    various input scenarios, ensuring that it handles different edge cases and
+    returns the expected cumulative sums.
+
+Test Categories:
+    - Standard cases: List of positive integers, negative integers, and floating-point numbers.
+    - Edge cases: Empty list, single-element list, list with zeros, large number list.
+    - Defensive tests: None input, Non-list inputs, list with non-numeric elements.
+
+Author: Falaq Youniss
+Date: 29/12/2024
+"""
+
+import unittest
+from ..cumulative_sum import cumulative_sum
+
+
+class TestCumulativeSum(unittest.TestCase):
+    """Test for cumulative_sum function that handles different cases"""
+
+    # Standard test cases
+    def test_positive_int(self):
+        """It should return a cumulative list of positive integers."""
+        self.assertEqual(cumulative_sum([1, 2, 3, 4]), [1, 3, 6, 10])
+
+    def test_negative_int(self):
+        """It should return a cumulative list of negative integers."""
+        self.assertEqual(cumulative_sum([-1, -2, -3, -4]), [-1, -3, -6, -10])
+
+    def test_positive_float(self):
+        """It should return a cumulative list of positive floats."""
+        self.assertEqual(cumulative_sum([1.0, 2.0, 3.0, 4.0]), [1.0, 3.0, 6.0, 10.0])
+
+    def test_negative_float(self):
+        """It should return a cumulative list of negative floats."""
+        self.assertEqual(
+            cumulative_sum([-1.0, -2.0, -3.0, -4.0]), [-1.0, -3.0, -6.0, -10.0]
+        )
+
+    def test_positive_negative(self):
+        """It should return a cumulative list of negative and positive integers."""
+        self.assertEqual(cumulative_sum([-1, 2, -3, 4]), [-1, 1, -2, 2])
+
+    def test_integer_float(self):
+        """It should return a cumulative list of integers and floats."""
+        self.assertEqual(cumulative_sum([1.0, 2, 3.0, 4]), [1, 3, 6.0, 10.0])
+
+    def test_combination(self):
+        """It should return a cumulative list of mixed positive and negative integers/floats."""
+        self.assertEqual(cumulative_sum([1.0, -2, -3.0, 4]), [1, -1, -4, 0])
+
+    def test_same(self):
+        """It should return a cumulative list of  positive integers."""
+        self.assertEqual(cumulative_sum([3, 3, 3]), [3, 6, 9])
+
+    # Edge cases
+    def test_zero(self):
+        """It should return a list of zeros."""
+        self.assertEqual(cumulative_sum([0, 0, 0, 0]), [0, 0, 0, 0])
+
+    def test_empty(self):
+        """It should return an empty list."""
+        self.assertEqual(cumulative_sum([]), [])
+
+    def test_one(self):
+        """It should return the same single-item list."""
+        self.assertEqual(cumulative_sum([1]), [1])
+
+    def test_large_numbers(self):
+        """It should correctly handle large numbers."""
+        self.assertEqual(cumulative_sum([1e6, 2e6, 3e6]), [1e6, 3e6, 6e6])
+
+    # Defensive tests
+    def test_none(self):
+        """It should raise AssertionError for None input."""
+        with self.assertRaises(AssertionError):
+            cumulative_sum(None)
+
+    def test_not_list(self):
+        """It should raise AssertionError for non-list input."""
+        with self.assertRaises(AssertionError):
+            cumulative_sum("hello")
+
+    def test_not_num(self):
+        """It should raise AssertionError for non-numeric list elements."""
+        with self.assertRaises(AssertionError):
+            cumulative_sum([1, "cat", 3])

solutions/tests/test_mean.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Module: test_mean
+
+Description:
+    This module contains the unit tests for the mean function in the solutions package.
+    the function calculates the mean of a list of numbers.
+
+Author: Mohammed Elfadil
+Date: 31/12/2024
+"""
+
+import unittest
+from solutions.mean import mean
+
+
+class TestMean(unittest.TestCase):
+    """test the mean function"""
+
+    def test_positive_numbers(self):
+        """It should evaluate 3.0"""
+        actual = mean([1, 2, 3, 4, 5])
+        expected = 3.0
+        self.assertEqual(actual, expected)
+
+    def test_positive_numbers2(self):
+        """It should evaluate 30.0"""
+        actual = mean([10, 20, 30, 40, 50])
+        expected = 30.0
+        self.assertEqual(actual, expected)
+
+    def test_zeros(self):
+        """It should evaluate 0.0"""
+        actual = mean([0, 0, 0, 0, 0])
+        expected = 0.0
+        self.assertEqual(actual, expected)
+
+    def test_single_input(self):
+        """It should evaluate 1.0"""
+        actual = mean([1])
+        expected = 1.0
+        self.assertEqual(actual, expected)
+
+    def test_integer(self):
+        """It should evaluate invalid input"""
+        with self.assertRaises(AssertionError):
+            mean(2)
+
+    def test_negatives(self):
+        """It should evaluate -4.0"""
+        actual = mean([-2, -4, -6])
+        expected = -4.0
+        self.assertEqual(actual, expected)
+
+    def test_floats(self):
+        """It should evaluate 2.5"""
+        actual = mean([1.5, 2.5, 3.5])
+        expected = 2.5
+        self.assertEqual(actual, expected)
+
+    def test_string(self):
+        """Test that invalid input raises an AssertionError."""
+        with self.assertRaises(AssertionError):
+            mean("2, 3, 4, 5")