def test_naive():
for raw_case, raw_ans in testcases:
case = listNodeConverter(raw_case)
ans = listNodeConverter(raw_ans)
# printListNode(case)
# printListNode(Naive().deleteDuplicates(case))
assert compareListNode(ans, Naive().deleteDuplicates(case)) == True
def test_naive():
assert compareListNode(
naive().mergeKLists([listNodeConverter(lst) for lst in listsA1]),
answer1)
assert compareListNode(
naive().mergeKLists([listNodeConverter(lst) for lst in listsB1]),
answer2)
def test_naive():
l1 = listNodeConverter([2, 4, 3])
l2 = listNodeConverter([5, 6, 4])
ans = listNodeConverter([7, 0, 8])
assert compareListNode(ans, naive().addTwoNumbers(l1, l2)) == True
l1 = listNodeConverter([1, 8])
l2 = listNodeConverter([0])
ans = listNodeConverter([1, 8])
assert compareListNode(ans, naive().addTwoNumbers(l1, l2)) == True
from LinkedList.ReverseLinkedList.Iterative206 import Solution as iterative
from LinkedList.ReverseLinkedList.Recursive206 import Solution as recursive
from LinkedList.ListNodeModule import compareListNode, listNodeConverter
linkedlist = []
linkedlist.append(listNodeConverter([1, 2, 3, 4, 5]))
linkedlist.append(listNodeConverter([1]))
linkedlist.append(listNodeConverter([]))
answer = []
answer.append(listNodeConverter([5, 4, 3, 2, 1]))
answer.append(listNodeConverter([1]))
answer.append(listNodeConverter([]))
def test_iterative():
for i, ll in enumerate(linkedlist):
assert compareListNode(iterative().reverseList(ll), answer[i]) == True
linkedlist2 = []
linkedlist2.append(listNodeConverter([1, 2, 3, 4, 5]))
linkedlist2.append(listNodeConverter([1]))
linkedlist2.append(listNodeConverter([]))
def test_recursive():
for i, ll in enumerate(linkedlist2):
assert compareListNode(recursive().reverseList(ll), answer[i]) == True
def test_dc():
assert compareListNode(
dc().mergeKLists([listNodeConverter(lst) for lst in listsA2]), answer1)
assert compareListNode(
dc().mergeKLists([listNodeConverter(lst) for lst in listsB2]), answer2)
from LinkedList.MergeKSortedLists.Naive023 import Solution as naive
from LinkedList.MergeKSortedLists.DC023 import Solution as dc
from LinkedList.ListNodeModule import listNodeConverter, compareListNode
listsA1 = [[2], [], [-1]]
listsB1 = [[1, 4, 5], [1, 3, 4], [2, 6]]
answer1 = listNodeConverter([-1, 2])
answer2 = listNodeConverter([1, 1, 2, 3, 4, 4, 5, 6])
def test_naive():
assert compareListNode(
naive().mergeKLists([listNodeConverter(lst) for lst in listsA1]),
answer1)
assert compareListNode(
naive().mergeKLists([listNodeConverter(lst) for lst in listsB1]),
answer2)
listsA2 = [[2], [], [-1]]
listsB2 = [[1, 4, 5], [1, 3, 4], [2, 6]]
def test_dc():
assert compareListNode(
dc().mergeKLists([listNodeConverter(lst) for lst in listsA2]), answer1)
assert compareListNode(
dc().mergeKLists([listNodeConverter(lst) for lst in listsB2]), answer2)
from LinkedList.ListNodeModule import listNodeConverter, compareListNode
from LinkedList.MergeTwoSortedLists.Better021 import Solution as better
Lists = []
Lists.append([listNodeConverter([1, 2, 4]), listNodeConverter([1, 3, 4])])
Lists.append([listNodeConverter([]), listNodeConverter([1, 3, 4])])
Lists.append([listNodeConverter([]), listNodeConverter([])])
answer = []
answer.append(listNodeConverter([1, 1, 2, 3, 4, 4]))
answer.append(listNodeConverter([1, 3, 4]))
answer.append(listNodeConverter([]))
def test_better():
for i, case in enumerate(Lists):
assert compareListNode(better().mergeTwoLists(case[0], case[1]),
answer[i])
from LinkedList.ListNodeModule import listNodeConverter, compareListNode
from LinkedList.InsertionSortList.Naive147 import Solution as naive
testcase = [(listNodeConverter([4, 2, 1, 3]), listNodeConverter([1, 2, 3, 4])),
(listNodeConverter([]), listNodeConverter([])),
(listNodeConverter([1]), listNodeConverter([1]))]
def test_naive():
for head, ans in testcase:
assert compareListNode(naive().insertionSortList(head), ans)
def test_naive():
for lst, k, ans in testcase:
assert compareListNode(naive().rotateRight(listNodeConverter(lst), k),
listNodeConverter(ans))
def test_twopointer():
for i, ll in enumerate(linkedlist):
assert compareListNode(
TwoPointer().removeNthFromEnd(listNodeConverter(ll), n[i]),
answer[i]) == True
def test_hashtable():
for i, ll in enumerate(linkedlist):
assert compareListNode(
HashTable().removeNthFromEnd(listNodeConverter(ll), n[i]),
answer[i]) == True
from LinkedList.ListNodeModule import listNodeConverter, compareListNode
from LinkedList.RemoveNthNodeFromEndOfList.HT019 import Solution as HashTable
from LinkedList.RemoveNthNodeFromEndOfList.TwoPointer019 import Solution as TwoPointer
linkedlist = []
linkedlist.append([1, 2, 3, 4, 5])
linkedlist.append([1])
linkedlist.append([1, 2])
n = []
n.append(2)
n.append(1)
n.append(2)
answer = []
answer.append(listNodeConverter([1, 2, 3, 5]))
answer.append(listNodeConverter([]))
answer.append(listNodeConverter([2]))
def test_hashtable():
for i, ll in enumerate(linkedlist):
assert compareListNode(
HashTable().removeNthFromEnd(listNodeConverter(ll), n[i]),
answer[i]) == True
def test_twopointer():
for i, ll in enumerate(linkedlist):
assert compareListNode(
TwoPointer().removeNthFromEnd(listNodeConverter(ll), n[i]),
