def is_palindrome(the_string): """ ------------------------------------------------------- [function description] ------------------------------------------------------- Preconditions: [parameter name - parameter description (parameter type and constraints)] Postconditions: [returns: or prints:] [return value name - return value description (return value type)] ------------------------------------------------------- """ x = 0 d = Deque() for i in range(len(the_string)): if the_string[i].isalpha(): d.insert_front(the_string[i]) while x < len(the_string) // 2: first = d.remove_front() last = d.remove_rear() if first == last: value = True else: value = False x = len(the_string) // 2 x += 1 return value
def test_initial_dequeue(self): """ Dequeuing from an empty deque raises ValueError. """ d = Deque() self.assertRaises(ValueError, d.dequeue_left) self.assertRaises(ValueError, d.dequeue_right)
def test_addFront(self): deque = Deque() self.assertEqual(deque.size(), 0) deque.addFront(11) self.assertEqual(deque.size(), 1) deque.addFront(15) self.assertEqual(deque.size(), 2)
def test_has_doubly_linked_list_internal(self): # """ # A deque has a data member, which is a dllist. # """ from pyllist import dllist # Hint: pip3 install llist d = Deque() self.assertEqual(dllist, type(d.data))
def test_peekleft(): """Test to see value of first, head, object with peekleft().""" from deque import Deque dq = Deque() dq.append('one') dq.append('two') assert dq.peekleft() == 'one'
def test_deque_appends_two_valus_on_the_end(): """Test that append adds two values on the end.""" from deque import Deque d = Deque() d.append(6) d.append(8) assert d.tail.val == 8
def test_appendleft_into_empty(): """Test that appendleft-ing into an empty list assigns the node to both head and tail.""" from deque import Deque d = Deque() d.appendleft(5) assert d.head == d.tail assert d.head and d.tail
def test_deleteAtFront(self): #arrange dq = Deque(4) #assert with self.assertRaises(ValueError): dq.deleteAtFront() #act dq.insertAtFront(1) #assert self.assertEqual(1, dq.deleteAtFront()) #act dq.insertAtRear(1) dq.insertAtRear(2) #assert self.assertEqual(1, dq.deleteAtFront()) self.assertEqual(2, dq.deleteAtFront()) with self.assertRaises(ValueError): dq.deleteAtFront() #act dq.insertAtRear(1) dq.insertAtFront(2) #assert self.assertEqual(2, dq.deleteAtFront()) self.assertEqual(1, dq.deleteAtFront()) with self.assertRaises(ValueError): dq.deleteAtFront()
def test_deque_popleft(): """Test popleft removes a value from the tail(front) of the deque.""" test_case = Deque(TEST_DEQUE_INIT_DATA) plop = test_case.popleft() # import pdb; pdb.set_trace() assert plop == [1, 2, 3, 4, 5] assert test_case.size() == 4
def test_size(): """Test peek method of deque.""" from deque import Deque deque = Deque() deque.append(data[0]) deque.append(data[1]) assert deque.size() == 2
def test_insertAtFront(self): #arrange dq = Deque(4) #act dq.insertAtFront(1) # assert self.assertEqual(0, dq.front) self.assertEqual(0, dq.rear) #act dq.insertAtFront(2) #assert self.assertEqual(1, dq.front) self.assertEqual(0, dq.rear) #act dq.insertAtFront(3) #assert self.assertEqual(2, dq.front) self.assertEqual(0, dq.rear) #act dq.insertAtFront(4) #assert self.assertEqual(3, dq.front) self.assertEqual(0, dq.rear) #act - assert with self.assertRaises(ValueError): dq.insertAtFront(5) self.assertEqual(3, dq.front) self.assertEqual(0, dq.rear)
def test_append_left(): """Test Deque class append_left method.""" from deque import Deque deque = Deque() deque.append_left(data[0]) deque.append_left(data[1]) assert deque.tail.data == data[1]
def test_append(): """Test Deque class append method.""" from deque import Deque deque = Deque() deque.append(data[0]) deque.append(data[1]) assert deque.head.data == data[1]
def Palindrome_checker(aString): status = True container = Deque() for char in aString: container.addFront(char) #print(len(container)) if len(aString) % 2 == 1 and status: pos = 1 while pos <= len(container) // 2: if container.removeFront() == container.removeRear(): pos += 1 else: status = False return status else: pos = 1 while pos <= len(container) // 2: if container.removeFront() == container.removeRear(): pos += 1 else: status = False return status
def __init__(self, size, items=[]): self.data = Deque() self.maxsize = size self.size = 0 for item in items: self.enqueue(item) assert len(self) <= self.maxsize
def test_deque_appendleft_one(): """Test that appendleft method adds specified data to the deque.""" test_case = Deque(TEST_DEQUE_INIT_DATA) original_size = test_case.size() test_case.appendleft("string") assert test_case.dll.tail.data == "string" assert test_case.size() == original_size + 1
def test_enqueue_left_one_internal(self): """ Enqueueing a 'left' value adds it to the beginning of the internal dllist. """ d = Deque() d.enqueue_left('fee') self.assertEqual('fee', d.data.first.value)
def palindrome_checker(word): word = "".join(re.findall(r"\w", word.lower())) pal_deque = Deque() # adds words through the rear # add_rear(pushes items forward) -->[r, a, d, a, r]<-- add_front(pushes items backwards) # [r] # [a, r] # [d, a, r] # [a, d, a, r] # [r, a, d, a, r] for w in word: pal_deque.add_rear(w) still_equal = True while pal_deque.size() > 1 and True: rear = pal_deque.remove_rear() # print(f'rear->{rear}') front = pal_deque.remove_front() # print(f'front->{front}') if rear != front: still_equal = False return still_equal
def test_appendleft_adds_two_values_on_the_front(): """Test that append adds two values on the front.""" from deque import Deque d = Deque() d.appendleft(6) d.appendleft(8) assert d.head.val == 8
def test_deque_constructor_with_empty_iterable(): """Test that a deque created with an empty iterable is empty.""" from deque import Deque d = Deque([]) assert d.end is None assert d.front is None assert d._values.length == 0
def test_popleft_on_empty(): """Test that popleft-ing an empty list returns none.""" from deque import Deque import pytest d = Deque() with pytest.raises(IndexError): d.popleft()
def test_deque_constructor_with_iterable(itr): """Test that a deque created with an iterable contains all items.""" from deque import Deque d = Deque(itr) assert d.end.val == itr[-1] assert d.front.val == itr[0] assert d._values.length == len(itr)
def test_enqueue_right_one_internal(self): # """ # Enqueueing a 'right' value adds it to the beginning of the internal dllist. # """ d = Deque() d.enqueue_right('fee') self.assertEqual('fee', d.data.first.value)
def test_removeTail(self): deque = Deque() self.assertEqual(deque.size(), 0) deque.addFront(11) self.assertEqual(deque.size(), 1) deque.addFront(15) self.assertEqual(deque.size(), 2) deque.addFront(54) deque.addFront(48) removedEl = deque.removeTail() self.assertEqual(removedEl, 11) self.assertEqual(deque.size(), 3) removedEl = deque.removeTail() self.assertEqual(removedEl, 15) self.assertEqual(deque.size(), 2) removedEl = deque.removeTail() self.assertEqual(removedEl, 54) self.assertEqual(deque.size(), 1) removedEl = deque.removeTail() self.assertEqual(removedEl, 48) self.assertEqual(deque.size(), 0) removedEl = deque.removeTail() self.assertEqual(removedEl, None) self.assertEqual(deque.size(), 0)
def test_not_empty_right(self): """ A deque with one right-enqueued value is not empty. """ d = Deque() d.enqueue_right('fee') self.assertFalse(d.is_empty())
def test_create_deque_single_item(): """Test create deque with single node.""" from deque import Deque nd = Deque(1) assert len(nd) == 1 assert nd._container.head.value == 1 assert nd._container.tail.value == 1
def test_deque(): d = Deque() d.insert_head(1) print(d) d.insert_tail(2) print(d) print(f"pop tail: {d.pop_tail()}") print(d) print(f"pop head: {d.pop_head()}") print(f"should be empty: {d}") d.insert_tail(1) print(d) d.insert_head(2) print(d) print(f"pop head: {d.pop_head()}") print(d) print(f"pop tail: {d.pop_tail()}") print(f"should be empty: {d}") d.insert_tail('a') d.insert_head('b') d.insert_head('c') d.insert_head('d') print(d) print(f"new deque reverse: {d.reverse()}") print(d) print("reverse in place:") d.reverse_in_place() print(d)
def test_instantiation(self): """ A Deque exists. """ try: Deque() except NameError: self.fail("Could not instantiate Deque.")
def test_empty_after_dequeue_right(self): """ A deque with one enqueued value is empty after right-dequeuing. """ d = Deque() d.enqueue_left('fee') _ = d.dequeue_right() self.assertTrue(d.is_empty())
def test_size(list, result): from deque import Deque dq = Deque() for i in list: dq.append(i) dq.pop() dq.pop() assert dq.size() == result