def test3(self): node1 = ListNode(1) node2 = ListNode(2) node3 = ListNode(3) node4 = ListNode(4) node5 = ListNode(5) node6 = ListNode(6) node7 = ListNode(7) node8 = ListNode(8) node9 = ListNode(9) node10 = ListNode(10) node11 = ListNode(11) node12 = ListNode(12) node13 = ListNode(13) node13 = ListNode(13) node1.next = node2 node2.next = node3 node3.next = node4 node4.next = node5 node5.next = node6 node6.next = node1 node7.next = node8 node8.next = node9 node9.next = node10 node10.next = node11 node11.next = node12 node12.next = node13 node12.next = node7 s = Solution() res = s.is_interset(node1, node7) print res self.assertFalse(res)
def test_0(): sol = Solution() assert sol.longestValidParentheses('') == 0 assert sol.longestValidParentheses('(') == 0 assert sol.longestValidParentheses(')') == 0 assert sol.longestValidParentheses('()') == 2 assert sol.longestValidParentheses(')(') == 0
def test1(self): array = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] k = 5 exp = 5 sol = Solution() res = sol.kth_smallset(array, k) self.assertEqual(res, exp)
def test_2(): sol = Solution() matrix = [['1', '1', '1', '0', '0'], ['1', '1', '1', '1', '1'], ['1', '1', '1', '1', '1'], ['1', '0', '0', '1', '0']] assert sol.maximalSquare(matrix) == 9
def test_0(): sol = Solution() assert sol.uniquePaths(0, 0) == 0 assert sol.uniquePaths(2, 0) == 0 assert sol.uniquePaths(0, 2) == 0 assert sol.uniquePaths(1, 3) == 1 assert sol.uniquePaths(3, 1) == 1
def test_1(): sol = Solution() triangle = [[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]] assert sol.minimumTotal(triangle) == 11
def test1(self): s = Solution() input_str = 'aa' p = 'a' res = s.isMatch(input_str, p) print res self.assertFalse(res)
def test4(self): s = Solution() input_str = 'aaaaaaaaaaaaab' p = 'a*a*a*a*a*a*a*a*a*a*c' res = s.isMatch(input_str, p) print res self.assertFalse(res)
def test3(self): s = Solution() input_str = 'aab' p = 'c*a*b' res = s.isMatch(input_str, p) print res self.assertTrue(res)
def test1(self): s = Solution() node1 = TreeNode(1) node2 = TreeNode(2) node1.left = node2 root = s.recoverTree(node1) self._inorder(root)
def test_2(): sol = Solution() matrix = [['1', '1', '1', '0', '0'], ['1', '1', '1', '1', '1'], ['1', '1', '1', '1', '1'], ['1', '0', '0', '1', '0']] assert sol.maximalRectangle(matrix) == 10
def test_2(): sol = Solution() m = n = 50 for _ in xrange(5): matrix = np.random.randint(-100, 100, (m, n)).tolist() k = np.random.randint(-400, 400) assert sol.maxSumSubmatrix(matrix, k) == maxSumSubmatrix(matrix, k)
def test1(self): node1 = Node(1) node2 = Node(2) node3 = Node(3) node4 = Node(4) node5 = Node(5) node6 = Node(6) node7 = Node(7) node8 = Node(8) node9 = Node(9) node10 = Node(10) node11 = Node(11) node1.left = node2 node1.right = node3 node2.left = node4 node2.right = node5 node3.left = node6 node3.right = node7 node6.left = node8 node6.right = node9 node7.left = node10 node7.right = node11 s = Solution() res = s.compress(node1) print res root = s.decompress(res) res2 = s.compress(root) print res2 self.assertEqual(res, res2)
def test_1(): sol = Solution() for n in xrange(1, 100): a = np.random.choice(100, n).tolist() b = sorted(a) k = 1 + np.random.randint(n) assert sol.findKthLargest(a, k) == b[-k]
class TestCase(unittest.TestCase): def setUp(self): self.solution = Solution() def testSolution01(self): a = (1, 3, 5, 7, 9, 11) b = (2, 4, 6, 8, 10) self.assertEqual(self.solution.findMedianSortedArrays(a, b), 6) def testSolution02(self): a = (1, 3, 4, 5, 7, 9) b = (2, 6, 8, 10) self.assertEqual(self.solution.findMedianSortedArrays(a, b), 5.5) def testSolution03(self): a = (1, 2, 3, 4, 5, 9) b = (6, 7, 8, 10, 11) self.assertEqual(self.solution.findMedianSortedArrays(a, b), 6) def testSolution04(self): a = (1, 2, 3, 4, 5, 6) b = (7, 8, 9, 10, 11) self.assertEqual(self.solution.findMedianSortedArrays(a, b), 6) def testSolution05(self): a = (1, 4, 8, 9, 10, 11) b = (2, 3, 5, 6, 7) self.assertEqual(self.solution.findMedianSortedArrays(a, b), 6)
def test_1(): sol = Solution() intervals = [Interval(1, 2), Interval(3, 5), Interval(6, 7), Interval(8, 10), Interval(12, 16)] new = Interval(4, 9) ans = [Interval(1, 2), Interval(3, 10), Interval(12, 16)] assert sol.insert(intervals, new) == ans
def test_1(): sol = Solution() buildings = [[2, 9, 10], [3, 7, 15], [5, 12, 12], [15, 20, 10], [19, 24, 8]] tgt = [[2, 10], [3, 15], [7, 12], [12, 0], [15, 10], [20, 8], [24, 0]] assert sol.getSkyline(buildings) == tgt
def test5(self): s = Solution() beginWord = "a" endWord = "c" wordDict = set(["a", "b", "c"]) res = s.findLadders(beginWord, endWord, wordDict) print res
def test1(self): s = Solution() beginWord = "hit" endWord = "cog" wordDict = set(["hot","dot","dog","lot","log"]) res = s.findLadders(beginWord, endWord, wordDict) print res
def test001(self): s = Solution() numbers = [5,2,5,1,4,3,6,4,3,2,6] n = s.singleNumber(numbers) print "input:\t", numbers print "expect:\t", 1 print "output:\t", n
def test2(self): head = Node() head.buff = [1, 2, 3] head.count = 3 n1 = Node() n1.buff = [4] n1.count = 1 n2 = Node() n2.buff = [5, 6] n2.count = 2 head.next = n1 n1.next = n2 sol = Solution() res = sol.get_idx_at(head, 0) exp = 1 self.assertEqual(res, exp) res = sol.get_idx_at(head, 1) exp = 2 self.assertEqual(res, exp) res = sol.get_idx_at(head, 4) exp = 5 self.assertEqual(res, exp) res = sol.get_idx_at(head, 5) exp = 6 self.assertEqual(res, exp)
def test_parameter_types(self): s = Solution('test_data/example/info.yaml') params = s.get_parameter_types(None) self.assertEqual(len(params), 5) self.assertEqual(params[0]['name'], 'floating-network-id') self.assertEqual(params[0]['type'], 'comma_delimited_list') self.assertIn(params[0]['default'], params[0]['constraints'][0]['allowed_values']) self.assertIn('_mapping', params[0]) self.assertEqual(params[0]['_mapping'], {'first_network': '11', 'second_network': '22', 'third_network': '33'}) self.assertEqual(s.map_parameter(params, 'floating-network-id', 'second_network'), '22') self.assertEqual(params[1]['name'], 'flavor') self.assertEqual(params[1]['type'], 'comma_delimited_list') self.assertIn(params[1]['default'], 'm1.small') self.assertEqual(params[2]['name'], 'image') self.assertEqual(params[2]['type'], 'comma_delimited_list') self.assertIn(params[2]['default'], params[2]['constraints'][0]['allowed_values']) self.assertEqual(params[3]['name'], 'image-count') self.assertEqual(params[3]['type'], 'number') self.assertEqual(params[4]['name'], 'keyname') self.assertEqual(params[4]['type'], 'comma_delimited_list') self.assertIn(params[4]['default'], params[4]['constraints'][0]['allowed_values'])
def test_1(): sol = Solution() assert sol.findMin([0, 1, 2, 3, 4, 5, 6, 7]) == 0 assert sol.findMin([7, 0, 1, 2, 3, 4, 5, 6]) == 0 assert sol.findMin([6, 7, 0, 1, 2, 3, 4, 5]) == 0 assert sol.findMin([5, 6, 7, 0, 1, 2, 3, 4]) == 0 assert sol.findMin([4, 5, 6, 7, 0, 1, 2]) == 0
class TestCase(unittest.TestCase): def setUp(self): self.solution = Solution() def assertListNodeEqual(self, l1, l2): if l1 is None and l2 is None: return self.assertEqual(l1.val, l2.val) self.assertListNodeEqual(l1.next, l2.next) def test_factory(self): l = ListNodeFactory.create(1, 2, 3) self.assertEqual(l.val, 1) self.assertEqual(l.next.val, 2) self.assertEqual(l.next.next.val, 3) def test_solution1(self): l1 = ListNodeFactory.create(2, 4, 3) l2 = ListNodeFactory.create(5, 6, 4) answer = self.solution.addTwoNumbers(l1, l2) self.assertListNodeEqual(answer, ListNodeFactory.create(7, 0, 8)) def test_solution2(self): l1 = ListNodeFactory.create(1, 2, 3, 4, 5) l2 = ListNodeFactory.create(9, 8, 7, 6, 5, 4) answer = self.solution.addTwoNumbers(l1, l2) self.assertListNodeEqual(answer, ListNodeFactory.create(0, 1, 1, 1, 1, 5)) def test_solution2(self): l1 = ListNodeFactory.create(5) l2 = ListNodeFactory.create(5) answer = self.solution.addTwoNumbers(l1, l2) self.assertListNodeEqual(answer, ListNodeFactory.create(0, 1))
def test_0(): sol = Solution() assert sol.minSubArrayLen(1, []) == 0 assert sol.minSubArrayLen(1, [1]) == 1 assert sol.minSubArrayLen(1, [2]) == 1 assert sol.minSubArrayLen(2, [2, 1, 1]) == 1 assert sol.minSubArrayLen(3, [1, 1]) == 0
def test_0(): sol = Solution() assert not sol.isInterleave('', '', 'a') assert sol.isInterleave('', 'bc', 'bc') assert not sol.isInterleave('', 'cb', 'bc') assert sol.isInterleave('a', 'b', 'ab') assert sol.isInterleave('b', 'a', 'ab')
def test_0(): sol = Solution() assert sol.uniquePathsWithObstacles([]) == 0 assert sol.uniquePathsWithObstacles([[0, 0, 0]]) == 1 assert sol.uniquePathsWithObstacles([[0, 1, 0]]) == 0 assert sol.uniquePathsWithObstacles([[0], [0], [0]]) == 1 assert sol.uniquePathsWithObstacles([[0], [1], [0]]) == 0
def test2(self): A = [-50,-50,-49,-48,-47,-47,-47,-46,-45,-43,-42,-41,-40,-40,-40,-40,-40,-40,-39,-38,-38,-38,-38,-37,-36,-35,-34,-34,-34,-33,-32,-31,-30,-28,-27,-26,-26,-26,-25,-25,-24,-24,-24,-22,-22,-21,-21,-21,-21,-21,-20,-19,-18,-18,-18,-17,-17,-17,-17,-17,-16,-16,-15,-14,-14,-14,-13,-13,-12,-12,-10,-10,-9,-8,-8,-7,-7,-6,-5,-4,-4,-4,-3,-1,1,2,2,3,4,5,6,6,7,8,8,9,9,10,10,10,11,11,12,12,13,13,13,14,14,14,15,16,17,17,18,20,21,22,22,22,23,23,25,26,28,29,29,29,30,31,31,32,33,34,34,34,36,36,37,37,38,38,38,39,40,40,40,41,42,42,43,43,44,44,45,45,45,46,47,47,47,47,48,49,49,49,50] output_list = [-50,-50,-49,-48,-47,-47,-46,-45,-43,-42,-41,-40,-40,-39,-38,-38,-37,-36,-35,-34,-34,-33,-32,-31,-30,-28,-27,-26,-26,-25,-25,-24,-24,-22,-22,-21,-21,-20,-19,-18,-18,-17,-17,-16,-16,-15,-14,-14,-13,-13,-12,-12,-10,-10,-9,-8,-8,-7,-7,-6,-5,-4,-4,-3,-1,1,2,2,3,4,5,6,6,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,16,17,17,18,20,21,22,22,23,23,25,26,28,29,29,30,31,31,32,33,34,34,36,36,37,37,38,38,39,40,40,41,42,42,43,43,44,44,45,45,46,47,47,48,49,49,50] num_output = len(output_list) s = Solution() rtn = s.removeDuplicates(A) self.assertEqual(rtn, num_output)
def test1(self): s = Solution() height = [2, 4, 1, 3] res = s.maxArea(height) answer = 6 self.assertEqual(answer, res) print res
def test_1(): sol = Solution() nums = [1, 2, 3] ans = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] assert sorted(ans) == sorted(sol.permute(nums))
def test_solution(): s = Solution() assert s.getImportance([[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1) == 11
def solve(x: str, y: str): return Solution().findAnagrams(x, y)
def test_solution(): s = Solution() assert s.findMaxConsecutiveOnes([1, 1, 0, 1, 1, 1]) == 3 assert s.findMaxConsecutiveOnes([1, 1, 1, 1, 1, 0, 1, 1, 1]) == 5
def setUp(self): self.pairs = [] self.pairs.append((5, Solution().maxProfit([7, 1, 5, 3, 6, 4]))) self.pairs.append((0, Solution().maxProfit([7, 6, 4, 3, 1])))
def test_revese(test_input, expected): assert Solution().singleNumber(test_input) == expected
def test_solution(): s = Solution() assert s.isOneBitCharacter([1, 0, 0]) == True assert s.isOneBitCharacter([1, 1, 1, 0]) == False
#!/usr/bin/env python # -*- coding: utf-8 -*- from solution import Solution # n = 4 # edges = [[1, 0], [1, 2], [1, 3]] n = 6 edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]] sol = Solution() res = sol.findMinHeightTrees(n, edges) print(res)
# -*- coding: utf-8 -*- from solution import Solution, ListNode Anode1 = ListNode(1) Anode2 = ListNode(4) Anode3 = ListNode(5) Anode1.next = Anode2 Anode2.next = Anode3 Bnode1 = ListNode(1) Bnode2 = ListNode(3) Bnode3 = ListNode(4) Bnode1.next = Bnode2 Bnode2.next = Bnode3 Cnode1 = ListNode(2) Cnode2 = ListNode(6) Cnode1.next = Cnode2 lst = [Anode1, Bnode1, Cnode1] sol = Solution() print(sol.mergeKLists(lst))
def test_numDecodings(self): s = Solution() result = s.numDecodings("12") self.assertEqual(result, 2)
def test_solution(): s = Solution() assert sorted(s.letterCombinations('23')) == sorted(["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"])
from solution import Solution s = Solution() assert s.lengthOfLongestSubstring("helloworld") == 5 assert s.lengthOfLongestSubstring("dvdf") == 3 assert s.lengthOfLongestSubstring("abcabcbb") == 3
def test_solution(): nums = [3, 5, 8] s = Solution() print(s.sortedArrayToBST(nums))
def test_missingNumberXOR_short(self): s = Solution() actual = s.missingNumber([3, 0, 1]) self.assertEqual(actual, 2)
def test_missingNumber(self): s = Solution() actual = s.missingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1]) self.assertEqual(actual, 8)
def test_1(self): self.assertEqual(Solution().search([4, 5, 6, 7, 0, 1, 2], 3), -1)
from functions import * from solution import Solution from algorithms import * s = Solution(2, -5.12, 5.12, 0.1, sphere, hill_climbing) print(s.find_minimum(aargs=(100, 10))) s.save_anim()
def test_193(self): self.assertEqual(Solution().search([4, 5, 6, 7, 8, 1, 2, 3], 8), 4)
def test_sample_1(self): self.assertEqual(Solution().search([4, 5, 6, 7, 0, 1, 2], 0), 4)
def test_186(self): self.assertEqual(Solution().search([5, 1, 3], 5), 0)
def test_191(self): self.assertEqual(Solution().search([6, 7, 8, 1, 2, 3, 4, 5], 6), 0)
def test_170(self): self.assertEqual(Solution().search([1, 3], 3), 1)
def test_181(self): self.assertEqual(Solution().search([3, 1], 3), 0)
#!/usr/bin/env python # -*- coding: utf-8 -*- from solution import Solution strs = ["", "", "eat", "tea", "tan", "ate", "nat", "bat"] sol = Solution() res = sol.groupAnagrams(strs) print(res)
def test_168(self): self.assertEqual(Solution().search([1, 3], 1), 0)
import sys import graph_tool.all as gt import numpy as np from solution import Solution, Neighbourhood f_p = sys.argv[1] from grasp import grasp per = 0.5 sol = Solution(lambda x: per * x, f_p) sol2 = sol.copy() sol3 = sol.copy() vertices = [0, 9, 4, 3] sol.batch_vertex_upgrade(vertices, update_mst=True) for v in vertices: sol2.upgrade_vertex(v) state = np.zeros(sol3.globals.N, dtype=bool) state[vertices] = True sol3.cleanse_to_state(state) assert sol.edge_upgrade_level.__str__() == sol2.edge_upgrade_level.__str__(), \ "both approaches should take you to the same solution" assert sol.edge_upgrade_level.__str__() == sol3.edge_upgrade_level.__str__(), \
def test_longestCommonPrefix(self): s = Solution() self.assertEqual(s.longestCommonPrefix(["flower", "flow", "flight"]), "fl")
def test_empty_input_list(self): self.assertEquals(0, Solution().maxProfit([]))
def test_length_one_list(self): self.assertEquals(0, Solution().maxProfit([2]))
def test_numDecodings_longer(self): s = Solution() result = s.numDecodings("226") self.assertEqual(result, 3)
q.append(left) idx += 1 if idx == len(tree): break right = constructOne(tree[idx]) idx += 1 tn.right = right q.append(right) return root def printNode(tn, indent): sb = "" for i in range(indent): sb += "\t" sb += str(tn.val) print(sb) def printTree(root, indent): if not root: return printTree(root.right, indent + 1) printNode(root, indent) printTree(root.left, indent + 1) n = 3 sol = Solution() res = sol.generateTrees(n) for tree in res: printTree(tree, 0) print("-----------------")