def test_solution():
eq_('03/19/19', solution.answer(19, 19, 3))
eq_('Ambiguous', solution.answer(3, 30, 3))
eq_('Ambiguous', solution.answer(1, 1, 3))
eq_('01/01/01', solution.answer(1, 1, 1))
eq_('11/13/99', solution.answer(99, 11, 13))
eq_('Ambiguous', solution.answer(12, 31, 30))
eq_('02/28/29', solution.answer(2, 28, 29))
eq_('Ambiguous', solution.answer(2, 12, 12))
def test_answer_neg_weights(self):
times = [
[0, 1, 1, 1, 1], # 0 = Start
[1, 0, 1, 1, 1], # 1 = Bunny 0
[1, 1, 0, 1, -1], # 2 = Bunny 1
[1, 1, 1, 0, 1], # 3 = Bunny 2
[1, 1, 1, 1, 0] # 4 = Bulkhead
]
time_limit = 2
self.assertEqual(answer(times, time_limit), [0, 1])
def test_reference(self):
a, b, c = ([1], [1, 1], [[1], 1, 1])
list_ = [a, b, c]
actual = answer(list_)
self.assertEqual(actual, c)
self.assertFalse(actual is c)
deep = c[0]
self.assertEqual(actual[0], deep)
self.assertFalse(actual[0] is deep)
def test_solution():
eq_(solution.answer([1,4,2,5,1,2,3]), 5)
eq_(solution.answer([1,2,3,2,1]), 0)
eq_(solution.answer([2, 5, 1, 2, 3, 4, 7, 7, 6]), 10)
eq_(solution.answer([2, 5, 1, 3, 1, 2, 1, 7, 7, 6]), 17)
eq_(solution.answer([2, 7, 2, 7, 4, 7, 1, 7, 3, 7]), 18)
eq_(solution.answer([6, 7, 7, 4, 3, 2, 1, 5, 2]), 10)
eq_(solution.answer([2, 5, 1, 2, 3, 4, 7, 7, 6,
2, 7, 1, 2, 3, 4, 5, 5, 4]), 26)
def test001(self):
print 'test 002\n'
population = [[6, 7, 2, 7, 6], [6, 3, 1, 4, 7], [0, 2, 4, 1, 10], [8, 1, 1, 4, 9], [8, 7, 4, 9, 9]]
x = 2
y = 1
strength = 5
r = solution.answer(population, x, y, strength)
print ' input:\t', population, x, y, strength
print ' expect:\t', [[6, 7, -1, 7, 6], [6, -1, -1, -1, 7], [-1, -1, -1, -1, 10], [8, -1, -1, -1, 9], [8, 7, -1, 9, 9]]
print ' output:\t', r
print
def test000(self):
print 'test 000\n'
population = [[1, 2, 3], [2, 3, 4], [3, 2, 1]]
x = 0
y = 0
strength = 2
r = solution.answer(population, x, y, strength)
print ' input:\t', population, x, y, strength
print ' expect:\t', [[-1, -1, 3], [-1, 3, 4], [3, 2, 1]]
print ' output:\t', r
print
def test_answer_with_cycles(self):
times = [
[0, 2, 2, 2, -1], # 0 = Start
[2, 0, 2, 2, -1], # 1 = Bunny 0
[2, 2, 0, 2, -1], # 2 = Bunny 1
[2, 2, 2, 0, -1], # 3 = Bunny 2
[2, 2, 2, 2, 0], # 4 = Bulkhead
]
# Sequential path distance = ??? = ???
# Best path: ???; distance = 6
time_limit = 1
self.assertEqual(answer(times, time_limit), [0])
def test_answer_provided2(self):
"""
This case is directed/asymmetrical with negative weights and negative-weighted cycles (I think), and cannot
rescue all bunnies within time limit.
"""
times = [
[0, 2, 2, 2, -1], # 0 = Start
[9, 0, 2, 2, -1], # 1 = Bunny 0
[9, 3, 0, 2, -1], # 2 = Bunny 1
[9, 3, 2, 0, -1], # 3 = Bunny 2
[9, 3, 2, 2, 0], # 4 = Bulkhead
]
time_limit = 1
self.assertEqual(answer(times, time_limit), [1, 2])
def test_answer_max_dim_matrix(self):
times = [
[0, 1, 1, 1, 1, 1, 1], # 0 = Start
[1, 0, 1, 1, 1, 1, 1], # 1 = Bunny 0
[1, 1, 0, 1, 1, 1, 1], # 2 = Bunny 1
[1, 1, 1, 0, 1, 1, 1], # 3 = Bunny 2
[1, 1, 1, 1, 0, 1, 1], # 4 = Bunny 3
[1, 1, 1, 1, 1, 0, 1], # 5 = Bunny 4
[1, 1, 1, 1, 1, 1, 0] # 6 = Bulkhead
]
# Sequential path distance = 1 + 1 + 1 + 1 = 6
# Best path: 0, 1, 2, 3, 4, 5, 6; distance = 6
time_limit = sys.maxint
self.assertEqual(answer(times, time_limit), [0, 1, 2, 3, 4])
def test_answer_1(self):
"""
Simple symmetrical paths, no time limit
"""
times = [
[0, 10, 5, 1, 1], # 0 = Start
[10, 0, 3, 1, 1], # 1 = Bunny 0
[5, 3, 0, 2, 1], # 2 = Bunny 1
[1, 1, 2, 0, 1], # 3 = Bunny 2
[1, 1, 1, 1, 0] # 4 = Bulkhead
]
# Sequential path distance = 10 + 3 + 2 + 1 = 16
# Best path: 0, 3, 1, 2, 4; distance = 1 + 1 + 3 + 1 = 6
time_limit = sys.maxint
self.assertEqual(answer(times, time_limit), [0, 1, 2])
def test_answer_provided1(self):
"""
This case is undirected/symmetrical with no negative weights or negative-weighted cycles, and CANNOT be solved
within the time limit.
So the standard TSP should work with the addition of handling the time-limit bound.
"""
times = [
[0, 1, 1, 1, 1], # 0 = Start
[1, 0, 1, 1, 1], # 1 = Bunny 0
[1, 1, 0, 1, 1], # 2 = Bunny 1
[1, 1, 1, 0, 1], # 3 = Bunny 2
[1, 1, 1, 1, 0] # 4 = Bulkhead
]
time_limit = 3
self.assertEqual(answer(times, time_limit), [0, 1])
def test_dogefu(self):
# reddit.com/r/dogecoin/comments/303sj9/dogefu_key_origami/
#input_key = '6KUsZfnpC35S4J92BiJfY6g7oi94PDwiHDPFxUAzkQtfdut2oWw'
# Swap first and last blocks
#input_key = '6 t2oWw npC35 S4J92 BiJfY 6g7oi 94PDw iHDPF xUAzk Qtfdu KUsZf'
# Swap first and second halves
#input_key = '6 94PDw iHDPF xUAzk Qtfdu t2oWw KUsZf npC35 S4J92 BiJfY 6g7oi'
# Reverse characters of first block
#input_key = '6 wDP49 iHDPF xUAzk Qtfdu t2oWw KUsZf npC35 S4J92 BiJfY 6g7oi'
input_key = '6wDP49iHDPFxUAzkQtfdut2oWwKUsZfnpC35S4J92BiJfY6g7oi'
public_key = 'DPXVGzs1ttpo1sDQ6xaqCc8WRY1HPurn3i'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_answer_2(self):
"""
This case is undirected/symmetrical with no negative weights or negative-weighted cycles, and all bunnies
can be rescued within the time limit.
So the standard TSP should work -- except we end at bulkhead node, not back at the start.
"""
times = [
[0, 1, 1, 1, 1], # 0 = Start
[1, 0, 1, 1, 1], # 1 = Bunny 0
[1, 1, 0, 1, 1], # 2 = Bunny 1
[1, 1, 1, 0, 1], # 3 = Bunny 2
[1, 1, 1, 1, 0] # 4 = Bulkhead
]
# Sequential path distance = 1 + 1 + 1 + 1 = 4
# Best path: 0, 1, 2, 3, 4; distance = 4
time_limit = sys.maxint
self.assertEqual(answer(times, time_limit), [0, 1, 2])
def test_dogefu(self):
# reddit.com/r/dogecoin/comments/303sj9/dogefu_key_origami/
#input_key = '6KUsZfnpC35S4J92BiJfY6g7oi94PDwiHDPFxUAzkQtfdut2oWw'
# Swap first and last blocks
#input_key = '6 t2oWw npC35 S4J92 BiJfY 6g7oi 94PDw iHDPF xUAzk Qtfdu KUsZf'
# Swap first and second halves
#input_key = '6 94PDw iHDPF xUAzk Qtfdu t2oWw KUsZf npC35 S4J92 BiJfY 6g7oi'
# Reverse characters of first block
#input_key = '6 wDP49 iHDPF xUAzk Qtfdu t2oWw KUsZf npC35 S4J92 BiJfY 6g7oi'
input_key = '6wDP49iHDPFxUAzkQtfdut2oWwKUsZfnpC35S4J92BiJfY6g7oi'
public_key = 'DPXVGzs1ttpo1sDQ6xaqCc8WRY1HPurn3i'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_answer(self):
for test_parameter in TestParameters:
actual = answer(test_parameter.list_)
self.assertEqual(actual, test_parameter.last)
def testSamples(self):
self.assertEqual(s.answer(0), 2)
self.assertEqual(s.answer(9), 2)
self.assertEqual(s.answer(42), 4)
def test_empty_string(self):
self.assertEqual(answer(""), 0)
def test_pattern_with_arity_4(self):
self.assertEqual(answer("abcabcabcabc"), 4)
from solution import answer answer(["annie", "bonnie", "liz"]) answer(['java', 'python', 'ruby', 'c', 'r', 'ab'])
def test_final(self):
input_key = '6KTnTsUJ1cryy3Kyb28yWNuiWiTvvMWU1MtHYiN4oMRTeDqb9jD'
public_key = 'DQ7Ys3fkuCHjt5dg4yHTcNB8t7FwM3AQSJ'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_3swaps(self):
input_key = '6PJUiyB8BBcydqpMLyoadMWuWyhBxsaRu2YPpMRrfa93tRhKQ79'
public_key = 'DHjmUqaaYBfDpyFvD9H8RjafbFy7cU5fGa'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_namesumlist(self):
self.assertEqual(answer(['annie', 'bonnie', 'liz'])['name_sum_list'], [[43, 'annie'], [59, 'bonnie'], [47, 'liz']])
def test_answer():
eq_(['L', 'R'], solution.answer(2))
eq_(['L', '-', 'R'], solution.answer(8))
eq_(['R'], solution.answer(1))
eq_(['-', 'L', 'R', 'L', 'R'], solution.answer(60))
def test_output(self):
self.assertEqual(answer(['annie', 'bonnie', 'liz'])['output'], ['bonnie', 'liz', 'annie'])
def test_samesumsort(self):
self.assertEqual(answer(['java', 'python', 'ruby', 'c', 'r', 'ab'])['output'], ['python', 'ruby', 'java', 'r', 'c', 'ab'])
def test_listlist(self):
self.assertEqual(answer(['annie', 'bonnie', 'liz'])['list_list'], [[1, 14, 14, 9, 5], [2, 15, 14, 14, 9, 5], [12, 9, 26]])
def test_big_list(self):
list_ = range(100000000000000000000000000000)
last = 99999999999999999999999999999
actual = answer(list_)
self.assertEqual(actual, last)
def test_sumlist(self):
self.assertEqual(answer(['annie', 'bonnie', 'liz'])['sum_list'], [43, 59, 47])
from solution import answer
answer_list = [
answer([1, 4, 2, 5, 1, 2, 3]),
answer([1, 2, 3, 2, 1])
]
for answers in answer_list:
print answers
def test_answer_repeating_len_9(self):
lst = [6] * 9
self.assertEqual(answer(lst), 84)
def test_answer():
eq_(2, answer(["foo", "bar", "oof", "bar"]))
eq_(5, answer(["x", "y", "xy", "yy", "", "yx"]))
def test_base(self):
input_key = '6JUPiyB8BBcydqprLyoadMWuWyhBxsaRu2YPpMRMfa93tRhKQ97'
public_key = 'DHjmUqaaYBfDpyFvD9H8RjafbFy7cU5fGa'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_3swaps(self):
input_key = '6PJUiyB8BBcydqpMLyoadMWuWyhBxsaRu2YPpMRrfa93tRhKQ79'
public_key = 'DHjmUqaaYBfDpyFvD9H8RjafbFy7cU5fGa'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_pattern_with_arity_2(self):
self.assertEqual(answer("abccbaabccba"), 2)
def test_final(self):
input_key = '6KTnTsUJ1cryy3Kyb28yWNuiWiTvvMWU1MtHYiN4oMRTeDqb9jD'
public_key = 'DQ7Ys3fkuCHjt5dg4yHTcNB8t7FwM3AQSJ'
self.assertEqual(solution.answer(input_key, public_key), public_key)
def test_no_pattern(self):
self.assertEqual(answer("asdfghjkl"), 0)
def test_answer(self):
self.assertEqual(answer(12), [9, 1, 1, 1])
self.assertEqual(answer(15324), [15129, 169, 25, 1])
def test_none_type(self):
self.assertEqual(answer(None), 0)
def test_answer_repeating_len_100(self):
lst = [6] * 100
self.assertEqual(answer(lst), 161700)
def test_answer(self):
self.assertEqual(["L", "R"], solution.answer(2))
self.assertEqual(["L", "-", "R"], solution.answer(8))
self.assert_commands_balance(
(1000000000, 0, 1, 2, 3, 4, 5, 7, 11, 13, 14, 15, 20, 26, 27, 28,
78, 90, 99, 101, 240, 242, 243, 832, 777, 12345678))
def test_answer_repeating_len_500(self):
lst = [6] * 500
self.assertEqual(answer(lst), 20708500)
def test_answer_empty_list(self):
with self.assertRaises(IndexError) as context:
list_ = []
answer(list_)
from solution import answer
answer_list = [
answer([[0, 1], [1, 2], [2, 3], [3, 5], [4, 5]]),
answer([[0, 1000000], [42, 43], [0, 1000000], [42, 43]]),
]
for answers in answer_list:
print answers
def test_answer_repeating_len_12(self):
lst = [6] * 12
self.assertEqual(answer(lst), 220)
def test_answer(self):
self.assertEqual(answer(["1.1.2", "1.0", "1.3.3", "1.0.12", "1.0.2"]),
["1.0", "1.0.2", "1.0.12", "1.1.2", "1.3.3"])
self.assertEqual(answer(["1.11", "2.0.0", "1.2", "2", "0.1", "1.2.1",
"1.1.1", "2.0"]), ["0.1", "1.1.1", "1.2", "1.2.1", "1.11", "2",
"2.0", "2.0.0"])
def subject(self, *args):
return solution.answer(*args)
def test_answer_repeating_len_15(self):
lst = [6] * 15
self.assertEqual(answer(lst), 455)
def test_answer_repeating_len_18(self):
lst = [6] * 18
self.assertEqual(answer(lst), 816)
def test_answer_provided2(self):
self.assertEqual(answer([1, 2, 3, 4, 5, 6]), 3)
def test_base(self):
input_key = '6JUPiyB8BBcydqprLyoadMWuWyhBxsaRu2YPpMRMfa93tRhKQ97'
public_key = 'DHjmUqaaYBfDpyFvD9H8RjafbFy7cU5fGa'
self.assertEqual(solution.answer(input_key, public_key), public_key)
from solution import answer
# Ask user for a start and end for the range of weights to test
while True:
start = input("Enter an integer (between 0 and 10^9) from where to start the test range: ")
end = input("Enter an integer (between 0 and 10^9) from where to end the test range: ")
if(start > end):
print("The end occurs after the beginning: \n\tStart:%d \n\tEnd:%d" %(start,end))
elif(end > pow(10,9)):
print("Start or end is out of bounds; pick a start or end in the bounds of 0 to 10^9")
else:
for i in range(start,end):
print "%d: " %(i),answer(i)
