From 4844d11a4468fde0775d2b2a6e029a4052f211a6 Mon Sep 17 00:00:00 2001 From: Siyabonga Vilakazi Date: Fri, 17 Oct 2025 14:39:41 +0200 Subject: [PATCH 1/3] A few updates --- __pycache__/student_code.cpython-310.pyc | Bin 0 -> 9573 bytes student_code.py | 40 +++++- test.py | 160 +++++++++++++++++++++++ tests/test.py | 160 ----------------------- 4 files changed, 197 insertions(+), 163 deletions(-) create mode 100644 __pycache__/student_code.cpython-310.pyc create mode 100644 test.py delete mode 100644 tests/test.py diff --git a/__pycache__/student_code.cpython-310.pyc b/__pycache__/student_code.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7934728c78925b75595d76662f8bc911802b2ce9 GIT binary patch literal 9573 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 F{{g74HCX@v literal 0 HcmV?d00001 diff --git a/student_code.py b/student_code.py index d7fdfd0..8463c49 100644 --- a/student_code.py +++ b/student_code.py @@ -12,7 +12,15 @@ def sum_of_squares(n: int): Raises: ValueError: If n is a negative integer. """ - pass + if n < 0: + raise ValueError + + results = [] + for i in range(n+1): + square_number = i ** 2 + results.append(square_number) + + return sum(results) def evaluate_performance(grades: list, min_pass: int): """ @@ -25,7 +33,10 @@ def evaluate_performance(grades: list, min_pass: int): Returns: str: "Pass" if the average grade is greater than or equal to min_pass, otherwise "Fail". """ - pass + if (sum(grades) / len(grades)) >= min_pass: + return "Pass" + else: + return "Fail" def calculate_cumulative_performance(scores: dict): """ @@ -37,7 +48,30 @@ def calculate_cumulative_performance(scores: dict): Returns: dict: A dictionary containing the average score and a list of subjects where the score is below average. """ - pass + + results = [] + subjects = [] + + + for keys, values in scores.items(): + results.append(values) + subjects.append(keys) + + average = sum(results) / len(results) + + + dict = {} + dict["average"] = f"{int(average):.2f}" + + for ave, sub in zip(results, subjects): + if ave < average: + if dict["below_average"]: + dict["below_average"].append(sub) + elif not dict["below_average"]: + dict["below_average"] = [sub] + + return dict +print(calculate_cumulative_performance({"Math": 65, "English": 85, "Science": 50})) def analyze_improvement(scores: list): """ diff --git a/test.py b/test.py new file mode 100644 index 0000000..48bfda1 --- /dev/null +++ b/test.py @@ -0,0 +1,160 @@ +import unittest +from student_code import * + +class TestSumOfSquares(unittest.TestCase): + def test_sum_of_squares_basic(self): + self.assertEqual(sum_of_squares(3), 14, "Basic test failed: sum_of_squares(3)") + + def test_sum_of_squares_edge(self): + self.assertEqual(sum_of_squares(0), 0, "Edge case failed: sum_of_squares(0)") + + def test_sum_of_squares_large(self): + self.assertEqual(sum_of_squares(100), 338350, "Large input test failed.") + + def test_sum_of_squares_negative(self): + with self.assertRaises(ValueError): + sum_of_squares(-5) + +class TestPerformanceEvaluation(unittest.TestCase): + def test_performance_evaluation_pass(self): + min_passing_grade = 75 + self.assertEqual(evaluate_performance([80, 70, 90], min_passing_grade), "Pass", "Performance evaluation failed for passing case.") + + def test_performance_evaluation_fail(self): + min_passing_grade = 75 + self.assertEqual(evaluate_performance([60, 70, 50], min_passing_grade), "Fail", "Performance evaluation failed for failing case.") + + +class TestCumulativePerformance(unittest.TestCase): + def test_cumulative_performance(self): + scores = {"Math": 65, "English": 85, "Science": 50} + expected_output = {"average": 66.67, "below_average": ["Math", "Science"]} + self.assertEqual(calculate_cumulative_performance(scores), expected_output, "Cumulative performance calculation failed.") + +# class TestImprovementOverTime(unittest.TestCase): +# def test_improvement_over_time(self): +# scores = [50, 55, 70, 85] +# expected_output = {"trend": "positive", "improved": True} +# self.assertEqual(analyze_improvement(scores), expected_output, "Improvement analysis failed.") + +# class TestClassRanking(unittest.TestCase): +# def test_class_ranking(self): +# students = [("Alice", 85), ("Bob", 70), ("Charlie", 90)] +# expected_output = [("Charlie", 90), ("Alice", 85), ("Bob", 70)] +# self.assertEqual(rank_students(students), expected_output, "Class ranking failed.") + +# class TestLoopWithConditions(unittest.TestCase): +# def test_return_even_numbers(self): +# self.assertEqual(even_numbers(20), [2,4,6,8,10,12,14,16,18,20], "Even numbers from 1 to 20 failed.") + +# def test_print_odd_numbers(self): +# self.assertEqual(odd_numbers(20), [1,3,5,7,9,11,13,15,17,19], "Odd numbers from 1 to 20 failed.") + +# def test_sum_multiples_of_num(self): +# self.assertEqual(sum_multiples_of_num(3, 10), 165, "Sum of multiples of 3 between 1 and 50 failed.") +# self.assertEqual(sum_multiples_of_num(5, 10), 275, "Sum of multiples of 5 between 1 and 10 failed.") +# self.assertEqual(sum_multiples_of_num(8, 10), 440, "Sum of multiples of 8 between 1 and 10 failed.") + +# def test_skip_specific_value(self): +# self.assertEqual(skip_num(5,10), [1, 2, 3, 4, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") +# self.assertEqual(skip_num(7,10), [1, 2, 3, 4, 5, 6, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") +# self.assertEqual(skip_num(3,10), [1, 2, 4, 5, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") + +# class TestLoopTermination(unittest.TestCase): +# def test_break_on_specific_value(self): +# self.assertEqual(break_test(5, 10), [1, 2, 3, 4], "Loop termination on specific value failed.") + +# class TestLoopWithInput(unittest.TestCase): +# def test_read_numbers_until_zero(self): +# input_numbers = [1, 2, 3, 0] +# self.assertEqual(sum_numbers_until_zero(input_numbers), 6, "Summing numbers until 0 failed.") + +# def test_count_positive_numbers(self): +# self.assertEqual(count_positive_numbers([-1, 2, 3, -4, 5]), 3, "Counting positive numbers failed.") + +# class TestLoopWithCollections(unittest.TestCase): +# def test_sum_dictionary_values(self): +# dict_values = {'a': 1, 'b': 2, 'c': 3} +# self.assertEqual(sum_dictionary_values(dict_values), 6, "Summing values in a dictionary failed.") + +# def test_sum_unique_elements(self): +# elements = [1, 2, 2, 3] +# self.assertEqual(sum_unique_elements(elements), 6, "Summing unique elements failed.") + +# class TestSpecialUseOfControlStatements(unittest.TestCase): +# def test_skip_divisible_by_num(self): +# self.assertEqual(skip_divisible_by_num(3, 20), [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20], "Skipping numbers divisible by 3 failed.") +# self.assertEqual(skip_divisible_by_num(5, 15), [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14], "Skipping numbers divisible by 5 failed.") +# self.assertEqual(skip_divisible_by_num(6, 15), [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15], "Skipping numbers divisible by 6 failed.") + +# class SimpleDataProcessing(unittest.TestCase): +# def test_square_numbers(self): +# numbers = [1, 2, 3] +# self.assertEqual(square_numbers(numbers), [1, 4, 9], "Square numbers test failed.") + +# class InputTransformation(unittest.TestCase): +# def test_transform_string(self): +# text = 'hello, world' +# transform = ['Uppercase', 'Capitalize', 'Lowercase'] +# self.assertEqual(transform_string(text, transform[0]), 'HELLO, WORLD', "Uppercase transformation test failed.") +# self.assertEqual(transform_string(text, transform[1]), 'Hello, world', "Capitalize transformation test failed.") +# self.assertEqual(transform_string(text, transform[2]), text, "Lowercase transformation test failed.") + +# class DataAggregation(unittest.TestCase): +# def test_sum_and_average(self): +# numbers = [5, 15, 25] +# total, average = sum_and_average(numbers) +# self.assertEqual(total, 45, "Sum test failed.") +# self.assertEqual(average, 15.0, "Average test failed.") + +# def test_word_frequency_count(self): +# words = ['cat', 'dog', 'dog'] +# frequency = word_frequency_count(words) +# self.assertEqual(frequency, {'cat': 1, 'dog': 2}, "Word frequency count test failed.") + +# class DataFiltering(unittest.TestCase): +# def test_filter_even_numbers(self): +# numbers = [1, 2, 3, 4] +# evens = filter_even_numbers(numbers) +# self.assertEqual(evens, [2, 4], "Filter even numbers test failed.") + + +# class TestSimpleAlgorithms(unittest.TestCase): +# def test_find_median_odd_length(self): +# self.assertEqual(find_median([1, 3, 5]), 3, "Odd length test failed.") + +# def test_find_median_unsorted(self): +# self.assertEqual(find_median([7, 3, 1, 5]), 4, "Unsorted list test failed.") + +# def test_find_median_empty_list(self): +# with self.assertRaises(ValueError): +# find_median([]) + +# def test_find_median_duplicates(self): +# self.assertEqual(find_median([1, 1, 1]), 1, "Duplicate values test failed.") + +# def test_find_median_non_integer(self): +# with self.assertRaises(TypeError): +# find_median(["a", 1]) + +# def test_find_median_large_input(self): +# self.assertEqual(find_median(list(range(1, 10**6 + 1))), 500000.5, "Large input test failed.") + +# def test_find_median_decimal(self): +# self.assertEqual(find_median([1.5, 3.5, 2.5]), 2.5, "Decimal numbers test failed.") + +# class TestBasicProblemSolving(unittest.TestCase): +# def test_reverse_string(self): +# self.assertEqual(reverse_string("hello"), "olleh", "Reverse string test failed.") + +# def test_find_largest_number(self): +# self.assertEqual(largest_number([4, 2, 9, 7]), 9, "Find largest number test failed.") + +# def test_is_prime(self): +# self.assertTrue(is_prime(29), "Check if number is prime test failed.") + +# def test_count_character_occurrences(self): +# self.assertEqual(count_character_occurrences("banana", "a"), 3, "Count character occurrences test failed.") + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test.py b/tests/test.py deleted file mode 100644 index 4966190..0000000 --- a/tests/test.py +++ /dev/null @@ -1,160 +0,0 @@ -import unittest -from student_code import * - -class TestSumOfSquares(unittest.TestCase): - def test_sum_of_squares_basic(self): - self.assertEqual(sum_of_squares(3), 14, "Basic test failed: sum_of_squares(3)") - - def test_sum_of_squares_edge(self): - self.assertEqual(sum_of_squares(0), 0, "Edge case failed: sum_of_squares(0)") - - def test_sum_of_squares_large(self): - self.assertEqual(sum_of_squares(100), 338350, "Large input test failed.") - - def test_sum_of_squares_negative(self): - with self.assertRaises(ValueError): - sum_of_squares(-5) - -class TestPerformanceEvaluation(unittest.TestCase): - def test_performance_evaluation_pass(self): - min_passing_grade = 75 - self.assertEqual(evaluate_performance([80, 70, 90], min_passing_grade), "Pass", "Performance evaluation failed for passing case.") - - def test_performance_evaluation_fail(self): - min_passing_grade = 75 - self.assertEqual(evaluate_performance([60, 70, 50], min_passing_grade), "Fail", "Performance evaluation failed for failing case.") - - -class TestCumulativePerformance(unittest.TestCase): - def test_cumulative_performance(self): - scores = {"Math": 65, "English": 85, "Science": 50} - expected_output = {"average": 66.67, "below_average": ["Math", "Science"]} - self.assertEqual(calculate_cumulative_performance(scores), expected_output, "Cumulative performance calculation failed.") - -class TestImprovementOverTime(unittest.TestCase): - def test_improvement_over_time(self): - scores = [50, 55, 70, 85] - expected_output = {"trend": "positive", "improved": True} - self.assertEqual(analyze_improvement(scores), expected_output, "Improvement analysis failed.") - -class TestClassRanking(unittest.TestCase): - def test_class_ranking(self): - students = [("Alice", 85), ("Bob", 70), ("Charlie", 90)] - expected_output = [("Charlie", 90), ("Alice", 85), ("Bob", 70)] - self.assertEqual(rank_students(students), expected_output, "Class ranking failed.") - -class TestLoopWithConditions(unittest.TestCase): - def test_return_even_numbers(self): - self.assertEqual(even_numbers(20), [2,4,6,8,10,12,14,16,18,20], "Even numbers from 1 to 20 failed.") - - def test_print_odd_numbers(self): - self.assertEqual(odd_numbers(20), [1,3,5,7,9,11,13,15,17,19], "Odd numbers from 1 to 20 failed.") - - def test_sum_multiples_of_num(self): - self.assertEqual(sum_multiples_of_num(3, 10), 165, "Sum of multiples of 3 between 1 and 50 failed.") - self.assertEqual(sum_multiples_of_num(5, 10), 275, "Sum of multiples of 5 between 1 and 10 failed.") - self.assertEqual(sum_multiples_of_num(8, 10), 440, "Sum of multiples of 8 between 1 and 10 failed.") - - def test_skip_specific_value(self): - self.assertEqual(skip_num(5,10), [1, 2, 3, 4, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") - self.assertEqual(skip_num(7,10), [1, 2, 3, 4, 5, 6, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") - self.assertEqual(skip_num(3,10), [1, 2, 4, 5, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") - -class TestLoopTermination(unittest.TestCase): - def test_break_on_specific_value(self): - self.assertEqual(break_test(5, 10), [1, 2, 3, 4], "Loop termination on specific value failed.") - -class TestLoopWithInput(unittest.TestCase): - def test_read_numbers_until_zero(self): - input_numbers = [1, 2, 3, 0] - self.assertEqual(sum_numbers_until_zero(input_numbers), 6, "Summing numbers until 0 failed.") - - def test_count_positive_numbers(self): - self.assertEqual(count_positive_numbers([-1, 2, 3, -4, 5]), 3, "Counting positive numbers failed.") - -class TestLoopWithCollections(unittest.TestCase): - def test_sum_dictionary_values(self): - dict_values = {'a': 1, 'b': 2, 'c': 3} - self.assertEqual(sum_dictionary_values(dict_values), 6, "Summing values in a dictionary failed.") - - def test_sum_unique_elements(self): - elements = [1, 2, 2, 3] - self.assertEqual(sum_unique_elements(elements), 6, "Summing unique elements failed.") - -class TestSpecialUseOfControlStatements(unittest.TestCase): - def test_skip_divisible_by_num(self): - self.assertEqual(skip_divisible_by_num(3, 20), [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20], "Skipping numbers divisible by 3 failed.") - self.assertEqual(skip_divisible_by_num(5, 15), [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14], "Skipping numbers divisible by 5 failed.") - self.assertEqual(skip_divisible_by_num(6, 15), [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15], "Skipping numbers divisible by 6 failed.") - -class SimpleDataProcessing(unittest.TestCase): - def test_square_numbers(self): - numbers = [1, 2, 3] - self.assertEqual(square_numbers(numbers), [1, 4, 9], "Square numbers test failed.") - -class InputTransformation(unittest.TestCase): - def test_transform_string(self): - text = 'hello, world' - transform = ['Uppercase', 'Capitalize', 'Lowercase'] - self.assertEqual(transform_string(text, transform[0]), 'HELLO, WORLD', "Uppercase transformation test failed.") - self.assertEqual(transform_string(text, transform[1]), 'Hello, world', "Capitalize transformation test failed.") - self.assertEqual(transform_string(text, transform[2]), text, "Lowercase transformation test failed.") - -class DataAggregation(unittest.TestCase): - def test_sum_and_average(self): - numbers = [5, 15, 25] - total, average = sum_and_average(numbers) - self.assertEqual(total, 45, "Sum test failed.") - self.assertEqual(average, 15.0, "Average test failed.") - - def test_word_frequency_count(self): - words = ['cat', 'dog', 'dog'] - frequency = word_frequency_count(words) - self.assertEqual(frequency, {'cat': 1, 'dog': 2}, "Word frequency count test failed.") - -class DataFiltering(unittest.TestCase): - def test_filter_even_numbers(self): - numbers = [1, 2, 3, 4] - evens = filter_even_numbers(numbers) - self.assertEqual(evens, [2, 4], "Filter even numbers test failed.") - - -class TestSimpleAlgorithms(unittest.TestCase): - def test_find_median_odd_length(self): - self.assertEqual(find_median([1, 3, 5]), 3, "Odd length test failed.") - - def test_find_median_unsorted(self): - self.assertEqual(find_median([7, 3, 1, 5]), 4, "Unsorted list test failed.") - - def test_find_median_empty_list(self): - with self.assertRaises(ValueError): - find_median([]) - - def test_find_median_duplicates(self): - self.assertEqual(find_median([1, 1, 1]), 1, "Duplicate values test failed.") - - def test_find_median_non_integer(self): - with self.assertRaises(TypeError): - find_median(["a", 1]) - - def test_find_median_large_input(self): - self.assertEqual(find_median(list(range(1, 10**6 + 1))), 500000.5, "Large input test failed.") - - def test_find_median_decimal(self): - self.assertEqual(find_median([1.5, 3.5, 2.5]), 2.5, "Decimal numbers test failed.") - -class TestBasicProblemSolving(unittest.TestCase): - def test_reverse_string(self): - self.assertEqual(reverse_string("hello"), "olleh", "Reverse string test failed.") - - def test_find_largest_number(self): - self.assertEqual(largest_number([4, 2, 9, 7]), 9, "Find largest number test failed.") - - def test_is_prime(self): - self.assertTrue(is_prime(29), "Check if number is prime test failed.") - - def test_count_character_occurrences(self): - self.assertEqual(count_character_occurrences("banana", "a"), 3, "Count character occurrences test failed.") - -if __name__ == "__main__": - unittest.main() From 854f235af7cf3c0f25452d0e9668bb5636986232 Mon Sep 17 00:00:00 2001 From: Siyabonga Vilakazi Date: Fri, 17 Oct 2025 14:52:58 +0200 Subject: [PATCH 2/3] Updated --- student_code.py | 26 +++++++------------------- 1 file changed, 7 insertions(+), 19 deletions(-) diff --git a/student_code.py b/student_code.py index 8463c49..b1a120a 100644 --- a/student_code.py +++ b/student_code.py @@ -49,28 +49,16 @@ def calculate_cumulative_performance(scores: dict): dict: A dictionary containing the average score and a list of subjects where the score is below average. """ - results = [] - subjects = [] - + if not scores: + return {"average": 0, "below_average": []} - for keys, values in scores.items(): - results.append(values) - subjects.append(keys) + total_score = sum(scores.values()) + average_score = round((total_score / len(scores)), 2) - average = sum(results) / len(results) + below_average_score = [subject for subject, score in scores.items() if score < average_score] + return {"average": average_score, "below_average": below_average_score} - dict = {} - dict["average"] = f"{int(average):.2f}" - - for ave, sub in zip(results, subjects): - if ave < average: - if dict["below_average"]: - dict["below_average"].append(sub) - elif not dict["below_average"]: - dict["below_average"] = [sub] - - return dict print(calculate_cumulative_performance({"Math": 65, "English": 85, "Science": 50})) def analyze_improvement(scores: list): @@ -287,7 +275,7 @@ def filter_even_numbers(nums: list[int]): Returns: list: A list containing only the even integers from the input list. """ - pass + pass """Learning Outcome: Simple Algorithms(Problem Solving)""" From 3e88b6d110646de57ca166800379e97e4702f0e5 Mon Sep 17 00:00:00 2001 From: Thamsanqa Hadebe Date: Fri, 17 Oct 2025 22:00:51 +0200 Subject: [PATCH 3/3] Did the problem sets given to enhance understanding of python --- __pycache__/student_code.cpython-313.pyc | Bin 0 -> 8532 bytes student_code.py | 365 ++++++++--------------- test.py | 246 +++++++-------- 3 files changed, 242 insertions(+), 369 deletions(-) create mode 100644 __pycache__/student_code.cpython-313.pyc diff --git a/__pycache__/student_code.cpython-313.pyc b/__pycache__/student_code.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f19027e049e12b890a4cca65d97b756aa6bc2ec3 GIT binary patch literal 8532 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 SX~Cc)Z~Benzv;nc?Ee6dV+0rg literal 0 HcmV?d00001 diff --git a/student_code.py b/student_code.py index b1a120a..9bfed02 100644 --- a/student_code.py +++ b/student_code.py @@ -1,17 +1,6 @@ """Learning Outcome: Functions""" def sum_of_squares(n: int): - """ - Calculate the sum of the squares of all integers from 1 to n. - - Parameters: - n (int): A non-negative integer up to which the squares will be summed. - - Returns: - int: The sum of the squares of all integers from 1 to n. - - Raises: - ValueError: If n is a negative integer. - """ + if n < 0: raise ValueError @@ -23,31 +12,13 @@ def sum_of_squares(n: int): return sum(results) def evaluate_performance(grades: list, min_pass: int): - """ - Evaluate the performance based on a list of grades and a minimum passing grade. - - Parameters: - grades (list): A list of integers representing student grades. - min_pass (int): The minimum average grade required to pass. - - Returns: - str: "Pass" if the average grade is greater than or equal to min_pass, otherwise "Fail". - """ + if (sum(grades) / len(grades)) >= min_pass: return "Pass" else: return "Fail" def calculate_cumulative_performance(scores: dict): - """ - Calculate the cumulative performance based on student scores. - - Parameters: - scores (dict): A dictionary where keys are subject names and values are the corresponding scores. - - Returns: - dict: A dictionary containing the average score and a list of subjects where the score is below average. - """ if not scores: return {"average": 0, "below_average": []} @@ -59,70 +30,48 @@ def calculate_cumulative_performance(scores: dict): return {"average": average_score, "below_average": below_average_score} -print(calculate_cumulative_performance({"Math": 65, "English": 85, "Science": 50})) def analyze_improvement(scores: list): - """ - Analyze the improvement trend based on a list of scores. - Parameters: - scores (list): A list of integers representing scores over time. + results = {} + for i in scores: + if i < i + 1: + results["trend"] = "positive" + results["improved"] = True + elif i > i + 1: + results["trend"] = "negative" + results["improved"] = False + else: + results["trend"] = "neutral" + results["improved"] = False + + return results - Returns: - dict: A dictionary containing the trend of improvement ("positive", "negative", or "neutral") - and a boolean indicating whether there has been an improvement. - """ - pass def rank_students(students: list[tuple[str, int]]): - """ - Rank students based on their scores. - - Parameters: - students (list): A list of tuples where each tuple contains a student's name and their score. + + return sorted(students, key=lambda student: student[1], reverse=True) - Returns: - list: A sorted list of tuples in descending order based on scores. - """ - pass """Learning Outcome: Basic Loops""" def even_numbers(n: int): - """ - Generate a list of even numbers from 1 to n. - - Parameters: - n (int): The upper limit for generating even numbers. + + return [num for num in range(1, n + 1) if num % 2 == 0] - Returns: - list: A list of even integers from 1 to n. - """ - pass def odd_numbers(n: int): - """ - Generate a list of odd numbers from 1 to n. - - Parameters: - n (int): The upper limit for generating odd numbers. + + return [num for num in range(1, n + 1) if num % 2 != 0] - Returns: - list: A list of odd integers from 1 to n. - """ - pass def sum_multiples_of_num(num: int, length: int): - """ - Calculate the sum of multiples of a given number up to a specified length. + + sum = 0 + for i in range(1, length + 1): + sum += i * num - Parameters: - num (int): The number whose multiples are to be summed. - length (int): The upper limit for the range of multiples. + return sum - Returns: - int: The sum of multiples of num from 1 to length. - """ - pass def skip_num(n: int, length: int): """ @@ -135,210 +84,134 @@ def skip_num(n: int, length: int): Returns: list: A list of integers from 1 to length, excluding n. """ - pass + return [num for num in range(1, length + 1) if num != n] -def break_test(n: int, length: int): - """ - Generate a list of numbers from 1 to length, stopping when a specific number is encountered. - Parameters: - n (int): The number at which to stop adding to the list. - length (int): The upper limit for generating numbers. +def break_test(n: int, length: int): + + results = [] + for i in range(1, length + 1): + if i == n: + break + + results.append(i) + return results - Returns: - list: A list of integers from 1 to length, excluding n and stopping before it. - """ - pass def sum_numbers_until_zero(nums: list): - """ - Calculate the sum of numbers in a list until a zero is encountered. - - Parameters: - nums (list): A list of integers. - - Returns: - int: The sum of integers in the list up to (but not including) the first zero. - """ - pass + + result = [] + for n in nums: + if 0 == n: + break + result.append(n) + return sum(result) def count_positive_numbers(nums: list): - """ - Count the number of positive integers in a list. + + count = 0 + for n in nums: + if n > 0: + count += 1 + return count - Parameters: - nums (list): A list of integers. - - Returns: - int: The count of positive integers in the list. - """ - pass def sum_dictionary_values(dictionary: dict): - """ - Calculate the sum of all values in a dictionary. - - Parameters: - dictionary (dict): A dictionary with numeric values. - - Returns: - int: The sum of all values in the dictionary. - """ - pass + + return sum(dictionary.values()) def sum_unique_elements(elements: list): - """ - Calculate the sum of unique elements in a list. - - Parameters: - elements (list): A list of integers. + + result = [] + for el in elements: + if el not in result: + result.append(el) + return sum(result) - Returns: - int: The sum of unique integers in the list. - """ - pass def skip_divisible_by_num(n: int, length: int): - """ - Generate a list of numbers from 1 to length, skipping those that are divisible by a specific number. - - Parameters: - n (int): The number to skip multiples of. - length (int): The upper limit for generating numbers. - - Returns: - list: A list of integers from 1 to length, excluding those divisible by n. - """ - pass + + result = [] + for i in range(1, length + 1): + if i % n == 0: + continue + result.append(i) + return result """Learning Outcome: Processing Data""" def square_numbers(nums: list): - """ - Calculate the square of each number in a list. - - Parameters: - nums (list): A list of integers. - - Returns: - list: A list containing the squares of the input integers. - """ - pass - -def transform_string(input: str, transform: str): - """ - Transform a string based on the specified transformation type. - - Parameters: - input (str): The string to be transformed. - transform (str): The type of transformation ('capitalize', 'upper', 'lower'). - - Returns: - str: The transformed string. - - Raises: - ValueError: If the transformation type is unknown. - """ - pass + + return [n**2 for n in nums] + +def transform_string(input: str, transform): + + if transform == "capitalize": + return input.capitalize() + elif transform == "uppercase": + return input.upper() + elif transform == "lowercase": + return input.lower() + else: + raise ValueError def sum_and_average(nums: list[int]): - """ - Calculate the sum and average of a list of numbers. - - Parameters: - nums (list[int]): A list of integers. - - Returns: - tuple: A tuple containing the sum and average of the numbers. - """ - pass + + sum_of_nums = sum(nums) + average = sum_of_nums / len(nums) + return sum_of_nums, average def word_frequency_count(words: list[str]): - """ - Count the frequency of each word in a list. - - Parameters: - words (list[str]): A list of words. - - Returns: - dict: A dictionary with words as keys and their frequencies as values. - """ - pass + + result = {} + for w in words: + result[w] = result.get(w, 0) + 1 + return result def filter_even_numbers(nums: list[int]): - """ - Filter out even numbers from a list. - - Parameters: - nums (list[int]): A list of integers. - - Returns: - list: A list containing only the even integers from the input list. - """ - pass + + return [n for n in nums if n % 2 == 0] """Learning Outcome: Simple Algorithms(Problem Solving)""" def find_median(nums: list[int]): - """ - Find the median of a list of numbers. - - Parameters: - nums (list[int]): A list of integers. - - Returns: - float: The median value of the list. + + if not nums: + raise ValueError + + nums.sort() + length = len(nums) + mid_nums = length // 2 - Raises: - ValueError: If the list is empty. - """ - pass + if length % 2 == 0: + return (nums[mid_nums - 1] + nums[mid_nums]) / 2 + else: + return float(nums[mid_nums]) def reverse_string(input: str): - """ - Reverse the given string. - - Parameters: - input (str): The string to be reversed. - - Returns: - str: The reversed string. - """ - pass + + return input[::-1] def largest_number(nums: list[int]): - """ - Find the largest number in a list. - - Parameters: - nums (list[int]): A list of integers. - - Returns: - int or None: The largest number in the list, or None if the list is empty. - """ - pass + + if not nums: + return None + return max(nums) def is_prime(n: int): - """ - Check if a number is prime. - - Parameters: - n (int): The number to check. - - Returns: - bool: True if the number is prime, False otherwise. - """ - pass + + if n <= 1: + return False + if n == 2: + return True + if n % 2 == 0: + return False + + for i in range(3, int(n ** 0.5) + 1, 2): + if n % i == 0: + return False + return True def count_character_occurrences(word_sentence: str, char_count: str): - """ - Count the occurrences of a character in a given sentence. - - Parameters: - word_sentence (str): The sentence in which to count occurrences. - char_count (str): The character to count. - - Returns: - int: The number of occurrences of the character in the sentence. - """ - pass \ No newline at end of file + + return word_sentence.count(char_count) \ No newline at end of file diff --git a/test.py b/test.py index 48bfda1..777da1b 100644 --- a/test.py +++ b/test.py @@ -31,130 +31,130 @@ def test_cumulative_performance(self): expected_output = {"average": 66.67, "below_average": ["Math", "Science"]} self.assertEqual(calculate_cumulative_performance(scores), expected_output, "Cumulative performance calculation failed.") -# class TestImprovementOverTime(unittest.TestCase): -# def test_improvement_over_time(self): -# scores = [50, 55, 70, 85] -# expected_output = {"trend": "positive", "improved": True} -# self.assertEqual(analyze_improvement(scores), expected_output, "Improvement analysis failed.") - -# class TestClassRanking(unittest.TestCase): -# def test_class_ranking(self): -# students = [("Alice", 85), ("Bob", 70), ("Charlie", 90)] -# expected_output = [("Charlie", 90), ("Alice", 85), ("Bob", 70)] -# self.assertEqual(rank_students(students), expected_output, "Class ranking failed.") - -# class TestLoopWithConditions(unittest.TestCase): -# def test_return_even_numbers(self): -# self.assertEqual(even_numbers(20), [2,4,6,8,10,12,14,16,18,20], "Even numbers from 1 to 20 failed.") - -# def test_print_odd_numbers(self): -# self.assertEqual(odd_numbers(20), [1,3,5,7,9,11,13,15,17,19], "Odd numbers from 1 to 20 failed.") - -# def test_sum_multiples_of_num(self): -# self.assertEqual(sum_multiples_of_num(3, 10), 165, "Sum of multiples of 3 between 1 and 50 failed.") -# self.assertEqual(sum_multiples_of_num(5, 10), 275, "Sum of multiples of 5 between 1 and 10 failed.") -# self.assertEqual(sum_multiples_of_num(8, 10), 440, "Sum of multiples of 8 between 1 and 10 failed.") +class TestImprovementOverTime(unittest.TestCase): + def test_improvement_over_time(self): + scores = [50, 55, 70, 85] + expected_output = {"trend": "positive", "improved": True} + self.assertEqual(analyze_improvement(scores), expected_output, "Improvement analysis failed.") + +class TestClassRanking(unittest.TestCase): + def test_class_ranking(self): + students = [("Alice", 85), ("Bob", 70), ("Charlie", 90)] + expected_output = [("Charlie", 90), ("Alice", 85), ("Bob", 70)] + self.assertEqual(rank_students(students), expected_output, "Class ranking failed.") + +class TestLoopWithConditions(unittest.TestCase): + def test_return_even_numbers(self): + self.assertEqual(even_numbers(20), [2,4,6,8,10,12,14,16,18,20], "Even numbers from 1 to 20 failed.") + + def test_print_odd_numbers(self): + self.assertEqual(odd_numbers(20), [1,3,5,7,9,11,13,15,17,19], "Odd numbers from 1 to 20 failed.") + + def test_sum_multiples_of_num(self): + self.assertEqual(sum_multiples_of_num(3, 10), 165, "Sum of multiples of 3 between 1 and 50 failed.") + self.assertEqual(sum_multiples_of_num(5, 10), 275, "Sum of multiples of 5 between 1 and 10 failed.") + self.assertEqual(sum_multiples_of_num(8, 10), 440, "Sum of multiples of 8 between 1 and 10 failed.") -# def test_skip_specific_value(self): -# self.assertEqual(skip_num(5,10), [1, 2, 3, 4, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") -# self.assertEqual(skip_num(7,10), [1, 2, 3, 4, 5, 6, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") -# self.assertEqual(skip_num(3,10), [1, 2, 4, 5, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") - -# class TestLoopTermination(unittest.TestCase): -# def test_break_on_specific_value(self): -# self.assertEqual(break_test(5, 10), [1, 2, 3, 4], "Loop termination on specific value failed.") - -# class TestLoopWithInput(unittest.TestCase): -# def test_read_numbers_until_zero(self): -# input_numbers = [1, 2, 3, 0] -# self.assertEqual(sum_numbers_until_zero(input_numbers), 6, "Summing numbers until 0 failed.") - -# def test_count_positive_numbers(self): -# self.assertEqual(count_positive_numbers([-1, 2, 3, -4, 5]), 3, "Counting positive numbers failed.") - -# class TestLoopWithCollections(unittest.TestCase): -# def test_sum_dictionary_values(self): -# dict_values = {'a': 1, 'b': 2, 'c': 3} -# self.assertEqual(sum_dictionary_values(dict_values), 6, "Summing values in a dictionary failed.") - -# def test_sum_unique_elements(self): -# elements = [1, 2, 2, 3] -# self.assertEqual(sum_unique_elements(elements), 6, "Summing unique elements failed.") - -# class TestSpecialUseOfControlStatements(unittest.TestCase): -# def test_skip_divisible_by_num(self): -# self.assertEqual(skip_divisible_by_num(3, 20), [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20], "Skipping numbers divisible by 3 failed.") -# self.assertEqual(skip_divisible_by_num(5, 15), [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14], "Skipping numbers divisible by 5 failed.") -# self.assertEqual(skip_divisible_by_num(6, 15), [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15], "Skipping numbers divisible by 6 failed.") - -# class SimpleDataProcessing(unittest.TestCase): -# def test_square_numbers(self): -# numbers = [1, 2, 3] -# self.assertEqual(square_numbers(numbers), [1, 4, 9], "Square numbers test failed.") - -# class InputTransformation(unittest.TestCase): -# def test_transform_string(self): -# text = 'hello, world' -# transform = ['Uppercase', 'Capitalize', 'Lowercase'] -# self.assertEqual(transform_string(text, transform[0]), 'HELLO, WORLD', "Uppercase transformation test failed.") -# self.assertEqual(transform_string(text, transform[1]), 'Hello, world', "Capitalize transformation test failed.") -# self.assertEqual(transform_string(text, transform[2]), text, "Lowercase transformation test failed.") - -# class DataAggregation(unittest.TestCase): -# def test_sum_and_average(self): -# numbers = [5, 15, 25] -# total, average = sum_and_average(numbers) -# self.assertEqual(total, 45, "Sum test failed.") -# self.assertEqual(average, 15.0, "Average test failed.") - -# def test_word_frequency_count(self): -# words = ['cat', 'dog', 'dog'] -# frequency = word_frequency_count(words) -# self.assertEqual(frequency, {'cat': 1, 'dog': 2}, "Word frequency count test failed.") - -# class DataFiltering(unittest.TestCase): -# def test_filter_even_numbers(self): -# numbers = [1, 2, 3, 4] -# evens = filter_even_numbers(numbers) -# self.assertEqual(evens, [2, 4], "Filter even numbers test failed.") - - -# class TestSimpleAlgorithms(unittest.TestCase): -# def test_find_median_odd_length(self): -# self.assertEqual(find_median([1, 3, 5]), 3, "Odd length test failed.") - -# def test_find_median_unsorted(self): -# self.assertEqual(find_median([7, 3, 1, 5]), 4, "Unsorted list test failed.") - -# def test_find_median_empty_list(self): -# with self.assertRaises(ValueError): -# find_median([]) - -# def test_find_median_duplicates(self): -# self.assertEqual(find_median([1, 1, 1]), 1, "Duplicate values test failed.") - -# def test_find_median_non_integer(self): -# with self.assertRaises(TypeError): -# find_median(["a", 1]) - -# def test_find_median_large_input(self): -# self.assertEqual(find_median(list(range(1, 10**6 + 1))), 500000.5, "Large input test failed.") - -# def test_find_median_decimal(self): -# self.assertEqual(find_median([1.5, 3.5, 2.5]), 2.5, "Decimal numbers test failed.") - -# class TestBasicProblemSolving(unittest.TestCase): -# def test_reverse_string(self): -# self.assertEqual(reverse_string("hello"), "olleh", "Reverse string test failed.") - -# def test_find_largest_number(self): -# self.assertEqual(largest_number([4, 2, 9, 7]), 9, "Find largest number test failed.") - -# def test_is_prime(self): -# self.assertTrue(is_prime(29), "Check if number is prime test failed.") - -# def test_count_character_occurrences(self): -# self.assertEqual(count_character_occurrences("banana", "a"), 3, "Count character occurrences test failed.") + def test_skip_specific_value(self): + self.assertEqual(skip_num(5,10), [1, 2, 3, 4, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") + self.assertEqual(skip_num(7,10), [1, 2, 3, 4, 5, 6, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") + self.assertEqual(skip_num(3,10), [1, 2, 4, 5, 6, 7, 8, 9, 10], "Skipping 5 in loop from 1 to 10 failed.") + +class TestLoopTermination(unittest.TestCase): + def test_break_on_specific_value(self): + self.assertEqual(break_test(5, 10), [1, 2, 3, 4], "Loop termination on specific value failed.") + +class TestLoopWithInput(unittest.TestCase): + def test_read_numbers_until_zero(self): + input_numbers = [1, 2, 3, 0] + self.assertEqual(sum_numbers_until_zero(input_numbers), 6, "Summing numbers until 0 failed.") + + def test_count_positive_numbers(self): + self.assertEqual(count_positive_numbers([-1, 2, 3, -4, 5]), 3, "Counting positive numbers failed.") + +class TestLoopWithCollections(unittest.TestCase): + def test_sum_dictionary_values(self): + dict_values = {'a': 1, 'b': 2, 'c': 3} + self.assertEqual(sum_dictionary_values(dict_values), 6, "Summing values in a dictionary failed.") + + def test_sum_unique_elements(self): + elements = [1, 2, 2, 3] + self.assertEqual(sum_unique_elements(elements), 6, "Summing unique elements failed.") + +class TestSpecialUseOfControlStatements(unittest.TestCase): + def test_skip_divisible_by_num(self): + self.assertEqual(skip_divisible_by_num(3, 20), [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20], "Skipping numbers divisible by 3 failed.") + self.assertEqual(skip_divisible_by_num(5, 15), [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14], "Skipping numbers divisible by 5 failed.") + self.assertEqual(skip_divisible_by_num(6, 15), [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15], "Skipping numbers divisible by 6 failed.") + +class SimpleDataProcessing(unittest.TestCase): + def test_square_numbers(self): + numbers = [1, 2, 3] + self.assertEqual(square_numbers(numbers), [1, 4, 9], "Square numbers test failed.") + +class InputTransformation(unittest.TestCase): + def test_transform_string(self): + text = 'hello, world' + transform = ['uppercase', 'capitalize', 'lowercase'] + self.assertEqual(transform_string(text, transform[0]), 'HELLO, WORLD', "Uppercase transformation test failed.") + self.assertEqual(transform_string(text, transform[1]), 'Hello, world', "Capitalize transformation test failed.") + self.assertEqual(transform_string(text, transform[2]), text, "Lowercase transformation test failed.") + +class DataAggregation(unittest.TestCase): + def test_sum_and_average(self): + numbers = [5, 15, 25] + total, average = sum_and_average(numbers) + self.assertEqual(total, 45, "Sum test failed.") + self.assertEqual(average, 15.0, "Average test failed.") + + def test_word_frequency_count(self): + words = ['cat', 'dog', 'dog'] + frequency = word_frequency_count(words) + self.assertEqual(frequency, {'cat': 1, 'dog': 2}, "Word frequency count test failed.") + +class DataFiltering(unittest.TestCase): + def test_filter_even_numbers(self): + numbers = [1, 2, 3, 4] + evens = filter_even_numbers(numbers) + self.assertEqual(evens, [2, 4], "Filter even numbers test failed.") + + +class TestSimpleAlgorithms(unittest.TestCase): + def test_find_median_odd_length(self): + self.assertEqual(find_median([1, 3, 5]), 3, "Odd length test failed.") + + def test_find_median_unsorted(self): + self.assertEqual(find_median([7, 3, 1, 5]), 4, "Unsorted list test failed.") + + def test_find_median_empty_list(self): + with self.assertRaises(ValueError): + find_median([]) + + def test_find_median_duplicates(self): + self.assertEqual(find_median([1, 1, 1]), 1, "Duplicate values test failed.") + + def test_find_median_non_integer(self): + with self.assertRaises(TypeError): + find_median(["a", 1]) + + def test_find_median_large_input(self): + self.assertEqual(find_median(list(range(1, 10**6 + 1))), 500000.5, "Large input test failed.") + + def test_find_median_decimal(self): + self.assertEqual(find_median([1.5, 3.5, 2.5]), 2.5, "Decimal numbers test failed.") + +class TestBasicProblemSolving(unittest.TestCase): + def test_reverse_string(self): + self.assertEqual(reverse_string("hello"), "olleh", "Reverse string test failed.") + + def test_find_largest_number(self): + self.assertEqual(largest_number([4, 2, 9, 7]), 9, "Find largest number test failed.") + + def test_is_prime(self): + self.assertTrue(is_prime(29), "Check if number is prime test failed.") + + def test_count_character_occurrences(self): + self.assertEqual(count_character_occurrences("banana", "a"), 3, "Count character occurrences test failed.") if __name__ == "__main__": unittest.main()