def test_if_in_previous_triangle_then_true(self):
s = Solver(7)
self.assertEqual(True, s.inside_triangle(4, 0, 2))
self.assertEqual(True, s.inside_triangle(4, 0, 4))
self.assertEqual(True, s.inside_triangle(4, 1, 3))
self.assertEqual(True, s.inside_triangle(4, 2, 2))
self.assertEqual(True, s.inside_triangle(4, 3, 1))
def test_number_of_free_diamonds_is_correct(self):
s = Solver(3)
self.assertEqual(2, s.get_number_free())
s = Solver(5)
self.assertEqual(4, s.get_number_free())
s = Solver(7)
self.assertEqual(1, s.get_number_free())
s = Solver(14)
self.assertEqual(8, s.get_number_free())
s = Solver(16)
self.assertEqual(1, s.get_number_free())
s = Solver(27)
self.assertEqual(12, s.get_number_free())
def test_levels_from_file(self):
"""
Test the levels from files, assert if all levels were solved.
"""
file_name = open('levels.txt', 'r')
count = 0
count_solved = 0
try:
for line in file_name.readlines():
main = Solver()
main.output = False
text = line.split(" ")[0]
grid = helper.create_grid_from_text(text, True)
matrix = helper.convert_to_matrix(grid, constant.BOARD_SIZE)
if main.solve(matrix):
count_solved += 1
count += 1
print(main.total_steps)
main.total_steps = 0
finally:
file_name.close()
self.assertEqual(count, count_solved)
def test_three_diamonds_hits_zero_zero(self):
s = Solver(3)
self.assertEqual(1.0, s.get_probability(0, 0))
def test_when_two_diamonds_index_ones_probability_is_25(self):
s = Solver(14)
self.assertEqual(0.25, s.calculate_probability(1, 2))
from main import Solver
test_cases = [{
"case": ["#1 @ 1,3: 4x4", "#2 @ 3,1: 4x4", "#3 @ 5,5: 2x2"],
"expected_part1": 4, # Answer is sq inches
"expected_part2": 3
}]
if __name__ == "__main__":
for test in test_cases:
solver = Solver(12)
solver.solve(test['case'])
solver.print_grid()
assert solver.make_output_part1(
) == test['expected_part1'], "Expected Part 1: {} - Got: {}".format(
test['expected_part1'], solver.make_output_part1())
assert solver.make_output_part2(
) == test['expected_part2'], "Expected Part 2: {} - Got: {}".format(
test['expected_part2'], solver.make_output_part2())
def test_when_one_diamond_index_zeros_probability_is_50(self):
s = Solver(14)
self.assertEqual(0.5, s.calculate_probability(0, 1))
def test_populate_columns_for_height_four_and_six_diamonds_fills_half_right(
self):
s = Solver(12)
r = s.populate_right_column(s.calculate_height()[1], 6)
self.assertEqual([True, True, False, False], r)
def test_six_diamonds_hits_zero_two_always(self):
s = Solver(6)
self.assertEqual(1.0, s.get_probability(0, 2))
def test_if_not_in_previous_triangle_then_false(self):
s = Solver(7)
self.assertEqual(False, s.inside_triangle(4, 0, 6))
self.assertEqual(False, s.inside_triangle(4, 1, 5))
self.assertEqual(False, s.inside_triangle(4, 2, 4))
self.assertEqual(False, s.inside_triangle(4, 3, 3))
def test_four_diamonds_hits_one_two_never(self):
s = Solver(4)
self.assertEqual(0, s.get_probability(0, 2))
def test_four_diamonds_hits_one_one_half_the_time(self):
s = Solver(4)
self.assertEqual(0.5, s.get_probability(1, 1))
def test_three_diamonds_hits_one_one_occasionally(self):
s = Solver(3)
self.assertEqual(0.25, s.get_probability(1, 1))
def test_three_diamonds_hits_two_zero_often(self):
s = Solver(3)
self.assertEqual(0.75, s.get_probability(2, 0))
def test_edge_height_for_seven_to_fourteen_is_four(self):
s = Solver(7)
self.assertEqual(4, s.get_max_edge_height())
s = Solver(14)
self.assertEqual(4, s.get_max_edge_height())
def test_one_diamond_hits_zero_zero(self):
s = Solver(1)
self.assertEqual(1.0, s.get_probability(0, 0))
def test_edge_height_for_sixteen_to_twentyseven_is_six(self):
s = Solver(16)
self.assertEqual(6, s.get_max_edge_height())
s = Solver(27)
self.assertEqual(6, s.get_max_edge_height())
def test_calculate_height_for_five_diamonds_is_zero(self):
s = Solver(5)
self.assertEqual(0, s.calculate_height()[0])
def test_populate_columns_for_height_four_and_eight_diamonds_fills_right(
self):
s = Solver(14)
r = s.populate_right_column(s.calculate_height()[1], 8)
self.assertEqual([True, True, True, True], r)
def test_calculate_height_for_six_diamonds_is_two(self):
s = Solver(6)
self.assertEqual(2, s.calculate_height()[0])
def test_is_certain_when_right_column_contains_two_and_index_is_one(self):
s = Solver(5)
r = s.populate_right_column(s.calculate_height()[1], 4)
self.assertEqual(True, s.is_certain(r, 1))
def test_calculate_height_for_fourteen_diamonds_is_two(self):
s = Solver(14)
self.assertEqual(2, s.calculate_height()[0])
def test_when_two_diamonds_index_zeros_probability_is_75(self):
s = Solver(14)
self.assertEqual(0.75, s.calculate_probability(0, 2))
def test_calculate_height_for_fifteen_diamonds_is_four(self):
s = Solver(15)
self.assertEqual(4, s.calculate_height()[0])
# Building, training, and producing the new features by DCCA
model = DeepCCA(layer_sizes1,
layer_sizes2,
input_shape1,
input_shape2,
outdim_size,
use_all_singular_values,
device=device).double()
l_cca = None
if apply_linear_cca:
l_cca = linear_cca()
solver = Solver(model,
l_cca,
outdim_size,
epoch_num,
batch_size,
learning_rate,
reg_par,
device=device)
train1, train2 = data1[0][0], data2[0][0]
val1, val2 = data1[1][0], data2[1][0]
test1, test2 = data1[2][0], data2[2][0]
# val1=None
# test1=None
solver.fit(train1, train2, val1, val2, test1, test2)
# TODO: Save linear_cca model if needed
set_size = [
0,
train1.size(0),
train1.size(0) + val1.size(0),
def test_one_diamond_misses_zero_two(self):
s = Solver(1)
self.assertEqual(0.0, s.get_probability(0, 2))
"case": [
"[1518-11-01 00:00] Guard #10 begins shift",
"[1518-11-01 00:05] falls asleep", "[1518-11-01 00:25] wakes up",
"[1518-11-01 00:30] falls asleep", "[1518-11-01 00:55] wakes up",
"[1518-11-01 23:58] Guard #99 begins shift",
"[1518-11-02 00:40] falls asleep", "[1518-11-02 00:50] wakes up",
"[1518-11-03 00:05] Guard #10 begins shift",
"[1518-11-03 00:24] falls asleep", "[1518-11-03 00:29] wakes up",
"[1518-11-04 00:02] Guard #99 begins shift",
"[1518-11-04 00:36] falls asleep", "[1518-11-04 00:46] wakes up",
"[1518-11-05 00:03] Guard #99 begins shift",
"[1518-11-05 00:45] falls asleep", "[1518-11-05 00:55] wakes up"
],
"expected_part1":
240,
"expected_part2":
4455
}]
if __name__ == "__main__":
for test in test_cases:
solver = Solver()
solver.solve(test['case'])
assert solver.make_output_part1(
) == test['expected_part1'], "Expected: {} - Got: {}".format(
test['expected_part1'], solver.make_output_part1())
assert solver.make_output_part2(
) == test['expected_part2'], "Expected: {} - Got: {}".format(
test['expected_part2'], solver.make_output_part2())
def test_when_one_diamond_index_ones_probability_is_0(self):
s = Solver(14)
self.assertEqual(0.0, s.calculate_probability(1, 1))