class RootishArrayStack(BaseList):
def __init__(self, iterable=[]):
self._initialize()
self.add_all(iterable)
def _initialize(self):
self.n = 0
self.blocks = ArrayStack()
def _i2b(self, i):
return int(ceil((-3.0 + sqrt(9 + 8 * i)) / 2.0))
def grow(self):
self.blocks.append(new_array(self.blocks.size() + 1))
def shrink(self):
r = self.blocks.size()
while r > 0 and (r - 2) * (r - 1) / 2 >= self.n:
self.blocks.remove(self.blocks.size() - 1)
r -= 1
def get(self, i):
if i < 0 or i > self.n - 1: raise IndexError()
b = self._i2b(i)
j = i - b * (b + 1) / 2
return self.blocks.get(b)[j]
def set(self, i, x):
if i < 0 or i > self.n - 1: raise IndexError()
b = self._i2b(i)
j = i - b * (b + 1) / 2
y = self.blocks.get(b)[j]
self.blocks.get(b)[j] = x
return y
def add(self, i, x):
if i < 0 or i > self.n: raise IndexError()
r = self.blocks.size()
if r * (r + 1) / 2 < self.n + 1: self.grow()
self.n += 1
for j in range(self.n - 1, i, -1):
self.set(j, self.get(j - 1))
self.set(i, x)
def remove(self, i):
if i < 0 or i > self.n - 1: raise IndexError()
x = self.get(i)
for j in range(i, self.n - 1):
self.set(j, self.get(j + 1))
self.n -= 1
r = self.blocks.size()
if (r - 2) * (r - 1) / 2 >= self.n: self.shrink()
return x
def clear(self):
self.blocks.clear()
self.n = 0
class RootishArrayStack(BaseList):
def __init__(self, iterable=[]):
self._initialize()
self.add_all(iterable)
def _initialize(self):
self.n = 0
self.blocks = ArrayStack()
def _i2b(self, i):
return int(ceil((-3.0 + sqrt(9 + 8*i)) / 2.0))
def grow(self):
self.blocks.append(new_array(self.blocks.size()+1))
def shrink(self):
r = self.blocks.size()
while r > 0 and (r-2)*(r-1)/2 >= self.n:
self.blocks.remove(self.blocks.size()-1)
r -= 1
def get(self, i):
if i < 0 or i > self.n - 1: raise IndexError()
b = self._i2b(i)
j = i - b*(b+1)/2
return self.blocks.get(b)[j]
def set(self, i, x):
if i < 0 or i > self.n - 1: raise IndexError()
b = self._i2b(i)
j = i - b*(b+1)/2
y = self.blocks.get(b)[j]
self.blocks.get(b)[j] = x
return y
def add(self, i, x):
if i < 0 or i > self.n: raise IndexError()
r = self.blocks.size()
if r*(r+1)/2 < self.n + 1: self.grow()
self.n += 1
for j in range(self.n-1, i, -1):
self.set(j, self.get(j-1))
self.set(i, x)
def remove(self, i):
if i < 0 or i > self.n - 1: raise IndexError()
x = self.get(i)
for j in range(i, self.n-1):
self.set(j, self.get(j+1))
self.n -= 1
r = self.blocks.size()
if (r-2)*(r-1)/2 >= self.n: self.shrink()
return x
def clear(self):
self.blocks.clear()
n = 0
class DualArrayDeque(BaseList):
def __init__(self, iterable=[]):
self._initialize()
self.add_all(iterable)
def _initialize(self):
self.front = ArrayStack()
self.back = ArrayStack()
def get(self, i):
if i < self.front.size():
return self.front.get(self.front.size() - i - 1)
else:
return self.back.get(i - self.front.size())
def set(self, i, x):
if i < self.front.size():
return self.front.set(self.front.size() - i - 1, x)
else:
return self.back.set(i - self.front.size(), x)
def add(self, i, x):
if i < self.front.size():
self.front.add(self.front.size() - i, x)
else:
self.back.add(i - self.front.size(), x)
self._balance()
def remove(self, i):
if i < self.front.size():
x = self.front.remove(self.front.size() - i - 1)
else:
x = self.back.remove(i - self.front.size())
self._balance()
return x
def _balance(self):
n = self.size()
mid = n // 2
if 3 * self.front.size() < self.back.size(
) or 3 * self.back.size() < self.front.size():
f = ArrayStack()
for i in range(mid):
f.add(i, self.get(mid - i - 1))
b = ArrayStack()
for i in range(n - mid):
b.add(i, self.get(mid + i))
self.front = f
self.back = b
def clear(self):
self.front.clear()
self.back.clear()
def size(self):
return self.front.size() + self.back.size()
class DualArrayDeque(BaseList):
def __init__(self, iterable=[]):
self._initialize()
self.add_all(iterable)
def _initialize(self):
self.front = ArrayStack()
self.back = ArrayStack()
def get(self, i):
if i < self.front.size():
return self.front.get(self.front.size() - i - 1)
else:
return self.back.get(i - self.front.size())
def set(self, i, x):
if i < self.front.size():
return self.front.set(self.front.size() - i - 1, x)
else:
return self.back.set(i - self.front.size(), x)
def add(self, i, x):
if i < self.front.size():
self.front.add(self.front.size() - i, x)
else:
self.back.add(i - self.front.size(), x)
self._balance()
def remove(self, i):
if i < self.front.size():
x = self.front.remove(self.front.size() - i - 1)
else:
x = self.back.remove(i - self.front.size())
self._balance()
return x
def _balance(self):
n = self.size()
mid = n // 2
if 3 * self.front.size() < self.back.size() or 3 * self.back.size() < self.front.size():
f = ArrayStack()
for i in range(mid):
f.add(i, self.get(mid - i - 1))
b = ArrayStack()
for i in range(n - mid):
b.add(i, self.get(mid + i))
self.front = f
self.back = b
def clear(self):
self.front.clear()
self.back.clear()
def size(self):
return self.front.size() + self.back.size()
class Palindrome:
"""
Class for finding palindromes.
"""
def __init__(self):
"""
Initialize with empty stack
"""
self._stack = ArrayStack()
def _read_ukrainian(self, filename: str) -> list:
"""
Return list of ukrainian words in the same order as in the filename.
"""
# words_list = []
with open(filename, mode='r', encoding="UTF-8") as words_file:
for line in words_file:
if line[0] != ' ':
ind = line.find(' ')
word = line[:ind]
# words_list.append(word)
self._stack.push(word)
return list(self._stack)
def _read_english(self, filename: str) -> list:
"""
Return list of english words in the same order as in the filename.
"""
# words_list = []
with open(filename, mode='r', encoding="UTF-8") as words_file:
for line in words_file:
word = line.strip()
# words_list.append(word)
self._stack.push(word)
return list(self._stack)
def read_file(self, filename: str) -> list:
"""
Return list of words in the same order as in the filename.
"""
self._stack.clear()
with open(filename, mode='r', encoding="UTF-8") as words_file:
char = words_file.readline()[0]
if ord(char.lower()) == 1072:
return self._read_ukrainian(filename)
if ord(char.lower()) == 97:
return self._read_english(filename)
return None
def find_palindromes(self, read_filename: str,
write_filename: str) -> list:
"""
Return list of polindromes.
"""
self.read_file(read_filename)
words = self._stack
polindromes = ArrayStack()
for word in words:
if word == word[-1::-1]:
polindromes.push(word)
self.write_to_file(write_filename, polindromes)
return list(polindromes)
@staticmethod
def write_to_file(filename: str, polindromes: ArrayStack):
"""
Writes polindromes to file.
"""
text = ""
for polindrome in polindromes:
text += f'{polindrome}\n'
with open(filename, mode='w', encoding="UTF-8") as write_file:
write_file.write(text)
def arclear_unit_test(self):
temp = ArrayStack()
for count in range(4):
temp.push(count+1)
temp.clear()
self.assertEqual(temp.isEmpty(), True)
# Remove all the items from stack1 until there is only 3 items left in it:
# <your code>
n = 10
while n > 4:
stack1.pop()
n -= 1
print("After removing all but 3 items from stack1:")
printStack1()
# Part 5:
# Use a single method to empty stack1:
# <your code>
stack1.clear()
print("After emptying stack1:")
printStack1()
# Part 6:
# Use pop() and push() to move all even valued items from stack2 to stack1.
# This will leave stack2 empty.
# This will leave stack1 with only even valued items.
# stack1 will be in the reverse order from the original stack2 order.
# When popping, use a try/except block to catch and ignore the KeyError exception.
# <your code>
for i in range(0, len(stack2)):
try:
x = stack2.pop()
