""" PRACTICE Exam 1, problem 3. Authors: David Mutchler, Vibha Alangar, Dave Fisher, Matt Boutell, Mark Hays, Mohammed Noureddine, Sana Ebrahimi, Sriram Mohan, their colleagues and PUT_YOUR_NAME_HERE. """ # TODO: 1. PUT YOUR NAME IN THE ABOVE LINE. ############################################################################### # Students: # # These problems have DIFFICULTY and TIME ratings: # DIFFICULTY rating: 1 to 10, where: # 1 is very easy # 3 is an "easy" Test 1 question. # 5 is a "typical" Test 1 question. # 7 is a "hard" Test 1 question. # 10 is an EXTREMELY hard problem (too hard for a Test 1 question) # # TIME ratings: A ROUGH estimate of the number of minutes that we # would expect a well-prepared student to take on the problem. # # IMPORTANT: For ALL the problems in this module, # if you reach the time estimate and are NOT close to a solution, # STOP working on that problem and ASK YOUR INSTRUCTOR FOR HELP # on it, in class or via Piazza. ############################################################################### import testing_helper import time def main(): """ Calls the TEST functions in this module. """ print("-----------------------------------------------") print("Un-comment each of the following TEST functions") print("as you implement the functions that they test.") print("-----------------------------------------------") # run_test_problem3a() # run_test_problem3b() def run_test_problem3a(): """ Tests the problem3a function. """ print() print("--------------------------------------------------") print("Testing the problem3a function:") print("--------------------------------------------------") format_string = " problem3a( {}, {} )" test_results = [0, 0] # Number of tests passed, failed. # Test 1: expected = (1 / (4 ** 1)) + (2 / (5 ** 2)) + (3 / (6 ** 3)) + \ (4 / (7 ** 4)) + (5 / (8 ** 5)) + (6 / (9 ** 6)) # which is approximately 0.3457187393495064 print_expected_result_of_test([6, 4], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(6, 4) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 2: expected = (1 / (1 ** 1)) + (2 / (2 ** 2)) + (3 / (3 ** 3)) # which is approximately 1.6111111111111112 print_expected_result_of_test([3, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(3, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 3: expected = (1 / (35 ** 1)) + (2 / (36 ** 2)) # which is approximately 0.03011463844797178 print_expected_result_of_test([2, 35], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(2, 35) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 4: expected = (1 / (0.1 ** 1)) + (2 / (1.1 ** 2)) + (3 / (2.1 ** 3)) + \ (4 / (3.1 ** 4)) # which is approximately 12.020144157845959 print_expected_result_of_test([4, 0.1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(4, 0.1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 5: expected = 1 / 1 # which is 1 print_expected_result_of_test([1, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(1, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 6: expected = (1 / (5 ** 1)) + (2 / (6 ** 2)) + (3 / (7 ** 3)) + \ (4 / (8 ** 4)) + (5 / (9 ** 5)) + (6 / (10 ** 6)) + \ (7 / (11 ** 7)) # which is approximately 0.2653695083904117 print_expected_result_of_test([7, 5], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(7, 5) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 7: expected = (1 / (2 ** 1)) + (2 / (3 ** 2)) + (3 / (4 ** 3)) # which is approximately 0.7690972222222222 print_expected_result_of_test([3, 2], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(3, 2) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 8: expected = (1 / (1 ** 1)) + (2 / (2 ** 2)) + (3 / (3 ** 3)) + (4 / (4 ** 4)) # which is approximately 1.6267361111111112 print_expected_result_of_test([4, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(4, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 9: expected = 22.213482474800703 print_expected_result_of_test([13, 0.05], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(13, 0.05) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 10: expected = 0.5961871168220374 print_expected_result_of_test([3, 2.5], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(3, 2.5) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # Test 11: expected = 102.38398042755968 print_expected_result_of_test([10, 0.01], expected, test_results, format_string, suffix=" (approximately)") actual = problem3a(10, 0.01) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=14) # SUMMARY of test results: print_summary_of_test_results(test_results) def problem3a(m, r): """ What comes in: A positive integer m and a number r. What goes out: -- Returns the sum that is the first m terms of the series (1 / (r ** 1)) + (2 / ((r+1) ** 2)) + (3 / ((r+2) ** 3) + ... Side effects: None. Examples: -- problem3a(6, 4) returns (1 / (4 ** 1)) + (2 / (5 ** 2)) + (3 / (6 ** 3)) + (4 / (7 ** 4)) + (5 / (8 ** 5)) + (6 / (9 ** 6)), which is approximately 0.3457187393495064 -- problem3a(3, 1) returns (1 / (1 ** 1)) + (2 / (2 ** 2)) + (3 / (3 ** 3)), which is approximately 1.6111111111111112 -- problem3a(2, 35) returns (1 / (35 ** 1)) + (2 / (36 ** 2)), which is approximately 0.03011463844797178 -- problem3a(4, 0.1) returns (1 / (0.1 ** 1)) + (2 / (1.1 ** 2)) + (3 / ( 2.1 ** 3)) + (4 / (3.1 ** 4 )), which is approximately 12.020144157845959 """ ########################################################################### # TODO: 2. Implement and test this function. # Tests have been written for you (above). # ------------------------------------------------------------------------ # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 6 # TIME ESTIMATE: 7 to 12 minutes. ########################################################################### def run_test_problem3b(): """ Tests the problem3b function. """ print() print("--------------------------------------------------") print("Testing the problem3b function:") print("--------------------------------------------------") format_string = " problem3b( {}, {}, {} )" test_results = [0, 0] # Number of tests passed, failed. # Test 1: expected = (2 / 5) + (3 / 7) + (4 / 9) + (5 / 11) + (6 / 13) + (7 / 15) # which is approximately 2.655766455766456 print_expected_result_of_test([6, 2, 5], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(6, 2, 5) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 2: expected = (10 / 6) + (11 / 8) + (12 / 10) # which is approximately 4.241666666666667 print_expected_result_of_test([3, 10, 6], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(3, 10, 6) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 3: expected = (20 / 4) # which is 5 print_expected_result_of_test([1, 20, 4], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(1, 20, 4) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 4: expected = (10 / 10) + (11 / 12) + (12 / 14) + (13 / 16) # which is approximately 3.5863095238095237 print_expected_result_of_test([4, 10, 10], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(4, 10, 10) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 5: expected = 19.37465007372624 print_expected_result_of_test([30, 10, 11], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(30, 10, 11) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 6: expected = 50.0 print_expected_result_of_test([100, 4, 8], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(100, 4, 8) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 7: expected = 49.5 print_expected_result_of_test([99, 4, 8], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(99, 4, 8) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 8: expected = 50.5 print_expected_result_of_test([101, 4, 8], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(101, 4, 8) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 9: expected = 53.15592858306353 print_expected_result_of_test([101, 5, 7], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(101, 5, 7) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 10: expected = 51.642171094650834 print_expected_result_of_test([100, 1, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(100, 1, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 11: expected = 52.14465865683989 print_expected_result_of_test([101, 1, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(101, 1, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 12: expected = 52.64712171102708 print_expected_result_of_test([102, 1, 1], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(102, 1, 1) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 13: expected = 487.5687456418132 print_expected_result_of_test([1000, 6, 23], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(1000, 6, 23) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 14: expected = 1801.8405099999466 print_expected_result_of_test([999, 600, 25], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(999, 600, 25) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # Test 15: expected = 7736.352797543001 print_expected_result_of_test([2999, 10000, 2001], expected, test_results, format_string, suffix=" (approximately)") actual = problem3b(2999, 10000, 2001) # Run the code to be tested print_actual_result_of_test(expected, actual, test_results, precision=8) # SUMMARY of test results: print_summary_of_test_results(test_results) def problem3b(m, r, s): """ What comes in: Positive integers m, r and s. What goes out: -- Returns the sum that is the first m terms of the series (r / s) + ((r + 1) / (s + 2)) + ((r + 2) / (s + 4)) + ((r + 3) / (s + 6) + ((r + 4) / (s + 8)) + ... Side effects: None. Examples: -- problem3b(6, 2, 5) returns (2 / 5) + (3 / 7) + (4 / 9) + (5 / 11) + (6 / 13) + (7 / 15), which is approximately 2.655766455766456 -- problem3b(3, 10, 6) returns (10 / 6) + (11 / 8) + (12 / 10), which is approximately 4.241666666666667 -- problem3b(1, 20, 4) returns (20 / 4), which is 5. -- problem3b(4, 10, 10) returns (10 / 10) + (11 / 12) + (12 / 14) + (13 / 16) which is approximately 3.5863095238095237 """ ########################################################################### # TODO: 3. Implement and test this function. # Tests have been written for you (above). # ------------------------------------------------------------------------ # DIFFICULTY AND TIME RATINGS (see top of this file for explanation) # DIFFICULTY: 6 # TIME ESTIMATE: 7 to 12 minutes. ########################################################################### ############################################################################### # Our tests use the following to print error messages in red. # Do NOT change it. You do NOT have to do anything with it. ############################################################################### def print_expected_result_of_test(arguments, expected, test_results, format_string, suffix=""): testing_helper.print_expected_result_of_test(arguments, expected, test_results, format_string, suffix) def print_actual_result_of_test(expected, actual, test_results, precision=None): testing_helper.print_actual_result_of_test(expected, actual, test_results, precision) def print_summary_of_test_results(test_results): testing_helper.print_summary_of_test_results(test_results) # To allow color-coding the output to the console: USE_COLORING = True # Change to False to revert to OLD style coloring testing_helper.USE_COLORING = USE_COLORING if USE_COLORING: # noinspection PyShadowingBuiltins print = testing_helper.print_colored else: # noinspection PyShadowingBuiltins print = testing_helper.print_uncolored # ----------------------------------------------------------------------------- # Calls main to start the ball rolling. # The try .. except prevents error messages on the console from being # intermingled with ordinary output to the console. # ----------------------------------------------------------------------------- try: main() except Exception: print("ERROR - While running this test,", color="red") print("your code raised the following exception:", color="red") print() time.sleep(1) raise