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
