Exemple #1
0
    def test_random(self):

        failures = []

        for i in range(0, self.random_runs):
            len_list = random.randrange(self.min_len, self.max_len)

            random_list = self.random_list_gen.get_list(len_list)

            a1_out = enumeration(random_list)
            a2_out = better_enumeration(random_list)
            a3_out = divide_and_conquer(random_list)
            # a3_out = a2_out
            a4_out = dynamic_programming(random_list)

            if a1_out != a2_out or a1_out != a3_out or a1_out != a4_out:
                failures.append((random_list, a1_out, a2_out, a3_out, a4_out))

        message_template = "%s\na1 %s\na2 %s\na3 %s\na4 %s\n\n"
        message = "%d runs, %d failures\n\n" % (self.random_runs, len(failures))

        for failure in failures:
            (failed_list, failed_a1, failed_a2, failed_a3, failed_a4) = failure
            message += message_template % (failed_list, failed_a1, failed_a2, failed_a3, failed_a4)

        message += "%d runs, %d failures\n\n" % (self.random_runs, len(failures))

        self.assertTrue(len(failures) == 0, message)
    def test_algorithm3_providedInput_shouldReturnMatchProvidedOutput(self):
        test_lists = load_lists_from_file('Problems/MSS_TestProblems-1.txt')
        expected = [(3, 14, 34), (0, 5, 30), (6, 12, 50), (2, 7, 187), (0, 4, 7), (0, 3, 210), (3, 7, 6)]
        actual = []
        for test_list in test_lists:
            actual.append(divide_and_conquer(test_list))
        message = "For the instructor provided input, should return the max sum of the provided output \n%s, but was \n%s" % (expected, actual)

        self.assertEqual(expected, actual, message)
Exemple #3
0
out.write("Better Enumeration, ")
for i in range(0, len(a2_list_lengths)):
    a2_random_lists = random_list_gen.get_lists(100, a2_list_lengths[i])
    start = time.clock()
    for random_list in a2_random_lists:
        better_enumeration(random_list)
    elapsed = time.clock() - start
    out.write("%f, " % elapsed)
out.write_line('')

out.write("Divide and Conquer, ")
for i in range(0, len(a3_list_lengths)):
    a3_random_lists = random_list_gen.get_lists(100, a3_list_lengths[i])
    start = time.clock()
    for random_list in a3_random_lists:
        divide_and_conquer(random_list)
    elapsed = time.clock() - start
    out.write("%f, " % elapsed)
out.write_line('')

out.write("Dynamic Programming, ")
for i in range(0, len(a4_list_lengths)):
    a4_random_lists = random_list_gen.get_lists(100, a4_list_lengths[i])
    start = time.clock()
    for random_list in a4_random_lists:
        dynamic_programming(random_list)
    elapsed = time.clock() - start
    out.write("%f, " % elapsed)
out.write_line('')

out.close()
Exemple #4
0
from algorithm2.algorithm2 import better_enumeration
from algorithm3.algorithm3 import divide_and_conquer
from algorithm4.algorithm4 import dynamic_programming
from file_loader.file_loader import load_lists_from_file
from file_writer.file_writer import FileWriter


lists = load_lists_from_file('Problems/MSS_Problems.txt')

out = FileWriter('Output/MSS_Results.txt')

for array_list in lists:

    algorithm1_output = enumeration(array_list)
    algorithm2_output = better_enumeration(array_list)
    algorithm3_output = divide_and_conquer(array_list)
    algorithm4_output = dynamic_programming(array_list)

    out.write_line(array_list)
    out.write_line('enumeration: ')
    out.write_line(algorithm1_output)
    out.write_line('better enumeration: ')
    out.write_line(algorithm2_output)
    out.write_line('divide and conquer: ')
    out.write_line(algorithm3_output)
    out.write_line('dynamic programming: ')
    out.write_line(algorithm4_output)
    out.write_line('\n')

out.close()
 def test_algorithm3_len3_2_neg1_2_should_return_0_3_3(self):
     test_list = [2, -1, 2]
     expected = (0, 3, 3)
     actual = divide_and_conquer(test_list)
     message = "For array [2, -1, 2], the max subarray should be the sum of all three elements, but was %s" % str(actual)
     self.assertEqual(expected, actual, message)
 def test_algorithm3_len2_1_1_should_return_0_2_2(self):
     test_list = [1, 1]
     expected = (0, 2, 2)
     actual = divide_and_conquer(test_list)
     message = "For array [1, 1], the max subarray should be the sum of both elements, but was %s" % str(actual)
     self.assertEqual(expected, actual, message)
 def test_algorithm3_len1_2_should_return_0_1_2(self):
     test_list = [2]
     expected = (0, 1, 2)
     actual = divide_and_conquer(test_list)
     message = "For a single element array with value 2, the max subarray should be the first element"
     self.assertEqual(expected, actual, message)