def find_palindromes(self, file, file_name):
"""
method which finds palindroms.
"""
words_list = self.read_file(file)
stack = ArrayStack()
result = []
for word in words_list:
word_len = len(word)
if word_len == 1.0:
result.append(word)
else:
word_mid = word_len // 2
middle = word_len % 2
for i in range(word_len):
if i < word_mid:
stack.push(word[i])
elif middle == 1 and i == word_mid:
continue
else:
if stack.pop() != word[i]:
check = False
break
check = True
if check is True:
result.append(word)
self.write_to_file(result, file_name)
return result
def queueToStack(queue):
queue_copy = copy.deepcopy(queue)
stack = ArrayStack()
while True:
try:
stack.add(queue_copy.pop())
except KeyError:
break
return stack
def isPalindrome(string):
"""Returns True if string is a palindrome
or False otherwise."""
stk = ArrayStack()
for ch in string:
stk.push(ch)
for ch in string:
if ch != stk.pop():
return False
return True
def stack_to_queue(stack):
'''Convert stack to queue, without changing given stack
peek of the stack is the first element in the queue'''
queue = ArrayQueue()
stack_copy = ArrayStack(stack)
while len(stack_copy) != 0:
queue.add(stack_copy.pop())
return queue
def queue_to_stack(queue):
'''Convert queue to stack, without modifying the queue
peek of the stack must be first element of the queue'''
stack = ArrayStack()
queue_copy = ArrayQueue(queue)
while len(queue_copy) != 0:
stack.push(queue_copy.remove(len(queue_copy) - 1))
return stack
def lipop_unit_test(self):
temp = ArrayStack()
for count in range(4):
temp.push(count+1)
temp.pop()
self.assertEqual(temp.peek(), 3)
temp.pop()
self.assertEqual(len(temp),2)
def queue_to_stack(queue: ArrayQueue) -> ArrayStack:
"""
Converts queue to stack and returns Stack object
"""
stack = ArrayStack()
copy_of_queue = deepcopy(queue)
for ind in range(len(queue), 0, -1):
ind -= 1
stack.add(copy_of_queue.remove(ind))
return stack
def check_palindrome(s):
s = str(s)
stack = ArrayStack()
even = 1 if len(s) % 2 else 0
half = len(s) // 2
for i in range(half):
stack.push(s[i])
ind = half + even
for i in range(half):
if stack.pop() != s[ind + i]:
return False
return True
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
list_queue = []
for i in queue.__iter__():
list_queue.append(i)
list_stack = list_queue[::-1]
new_stack = ArrayStack()
for j in range(len(list_queue)):
new_stack.push(list_stack[j])
return new_stack
def test_stack():
S = ArrayStack()
S.push(5)
print(S.top())
S.push(6)
print(len(S))
print(S.pop())
print(S.is_empty())
print(S.data)
def stack_to_queue(stack):
"""
Return queue from stack (front of queue is peek of stack).
"""
copy_stack = ArrayStack()
queue = ArrayQueue()
for element in stack:
copy_stack.push(element)
while len(copy_stack) != 0:
queue.add(copy_stack.pop())
return queue
def queue_to_stack(queue):
"""
Converts the queue to a stack.
"""
stk_ar = ArrayStack()
q = ArrayQueue(queue)
el = []
while not q.isEmpty():
el.append(q.pop())
q1 = ArrayQueue(el[::-1])
while not q1.isEmpty():
stk_ar.push(q1.pop())
return stk_ar
def test_arraystack_popallthrowsempty(self):
stack = ArrayStack()
for i in range(100):
stack.push(i + 1)
for i in range(100):
stack.pop()
stack.pop()
def queue_to_stack(queue: ArrayQueue) -> ArrayStack:
"""
Return stack from queue (front of queue is peek of stack).
"""
copy_queue = ArrayQueue()
stack = ArrayStack()
for element in queue:
copy_queue.add(element)
reversed_queue = reverse_queue(copy_queue)
for element in reversed_queue:
stack.push(element)
return stack
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)
def queue_to_stack(queue):
"""Converts queue to a stack"""
output_stack = ArrayStack()
start_queue = copy.deepcopy(queue)
temporary_stack = ArrayStack()
while start_queue.isEmpty() is False:
elem = start_queue.pop()
temporary_stack.push(elem)
while temporary_stack.isEmpty() is False:
elem = temporary_stack.pop()
output_stack.push(elem)
return output_stack
def queue_to_stack(queue):
"""
Converts queue to stack.
"""
temp_queue = ArrayQueue()
temp_stack = ArrayStack() #elements are in reversed order
result_stack = ArrayStack()
while not queue.isEmpty():
elem = queue.pop()
temp_queue.add(elem)
temp_stack.push(elem)
while not temp_queue.isEmpty():
queue.add(temp_queue.pop())
while not temp_stack.isEmpty():
result_stack.push(temp_stack.pop()) #we reverse elements
return result_stack
def queue_to_stack(queue):
"""
Convert queue to stack
"""
stack1 = ArrayStack()
stack2 = ArrayStack()
while len(queue) != 0:
num = queue.pop()
stack1.push(num)
while len(stack1) != 0:
num = stack1.pop()
stack2.push(num)
return stack2
def queue_to_stack(queue):
'''
Conver queue to stack.
'''
queue_copy = deepcopy(queue)
stack = ArrayStack()
while queue_copy:
stack.push(queue_copy.pop())
result = ArrayStack()
while stack:
result.push(stack.pop())
return result
def queue_to_stack(queue):
copied = copy(queue)
future_stack = []
while True:
try:
future_stack.append(copied.pop())
except KeyError:
return ArrayStack(reversed(future_stack))
def checkBalance(st):
stck = ArrayStack()
for i in st:
if i == '[' or i == '{' or i == '(':
stck.push(i)
else:
if i == ']' or i == '}' or i == ')':
if stck.isEmpty() or stck.peek() != opposite(i):
return False
else:
stck.pop()
if stck.isEmpty():
return True
return False
def is_matched_html(raw):
"""Return True if all HTML tags are properly matched;
False Otherwise."""
S = ArrayStack()
# find first '<' character
start = raw.find('<')
while start != -1:
# find next '>' character
end = raw.find('>', start + 1)
if end == -1:
return False
# strip away < >
tag = raw[start + 1:end]
# this is opening tag
if not tag.startswith('/'):
S.push(tag)
# this is closing tag
else:
if S.is_empty():
return False
if tag[1:] != S.pop():
return False
start = raw.find('<', end + 1)
# all tags matched
return S.is_empty()
class PFEvaluator(object):
def __init__(self, scanner):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
elif currentToken.isOperator():
if len(self._operandStack) < 2:
raise Exception("Too few operands on the stack")
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(self._computeValue(currentToken,
t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
else:
raise Exception("Unknown token type")
if len(self._operandStack) > 1:
raise Exception("Too many operands on the stack")
result = self._operandStack.pop()
return result.getValue();
def __str__(self):
result = "\n"
if self._expressionSoFar == "":
result += "Portion of expression processed: none\n"
else:
result += "Portion of expression processed: " + \
self._expressionSoFar + "\n"
if self._operandStack.isEmpty():
result += "The stack is empty"
else:
result += "Operands on the stack : " + \
str(self._operandStack)
return result
def _computeValue(self, op, value1, value2):
result = 0;
theType = op.getType()
if theType == Token.PLUS:
result = value1 + value2;
elif theType == Token.MINUS:
result = value1 - value2;
elif theType == Token.MUL:
result = value1 * value2;
elif theType == Token.DIV:
result = value1 // value2;
elif theType == Token.EXP:
result = value1 ** value2;
else:
raise Exception("Unknown operator")
return result
class PFEvaluator(object):
def __init__(self, scanner):
self._expression_so_far = ""
self._operand_stack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.has_next():
current_token = self._scanner.next()
self._expression_so_far += str(current_token) + " "
if current_token.get_type() == Token.INT: # 数字入栈
self._operand_stack.push(current_token)
elif current_token.is_operator(): # 操作符计算
if len(self._operand_stack) < 2: # 栈内数字小于2
raise AttributeError (\
"Too few operands on the stack")
t2 = self._operand_stack.pop()
t1 = self._operand_stack.pop()
result = \
Token(self._compute_value(current_token,
t1.get_value(),
t2.get_value()))
self._operand_stack.push(result)
else:
raise AttributeError("Unknown token type")
if len(self._operand_stack) > 1: # 计算完成后, 栈内深入数字大于2
raise AttributeError(\
"Too many operands on the stack")
result = self._operand_stack.pop()
return result.get_value()
def __str__(self):
result = "\n"
if self._expression_so_far == "":
result += \
"Portion of expression processed none\n"
else:
result += "Portion of expression processed: " + \
self._expression_so_far + "\n"
if self._operand_stack.isEmpty():
result += "Thre stack is empty"
else:
result += "Operands on the stack: " + \
str(self._operand_stack)
return result
def _compute_value(self, op, value1, value2):
result = 0
the_type = op.get_type()
if the_type == Token.PLUS:
result = value1 + value2
elif the_type == Token.MINUS:
result = value1 - value2
elif the_type == Token.MUL:
result = value1 * value2
elif the_type == Token.DIV:
result = value1 // value2
else:
raise AttributeError("Unknown operator")
return result
def is_palindrome(self, word):
"""
Checks whether the word is a palindrome.
"""
if len(word) <= 1:
return False
mid = len(word)/2
if mid == int(mid):
stack1, str2 = ArrayStack(word[:int(mid)]), word[int(mid):]
else:
stack1, str2 = ArrayStack(word[:int(mid)]), word[int(mid)+1:]
# print(f"WORD: {word}\nFIRST PART: {str(stack1)}\nSECOND PART: {str2}")
for char in str2:
if stack1.pop() != char:
return False
# print("FOUND PALINDROME:", word)
return True
def find_palindromes(self, path: str, wirte_file: str) -> list:
"""
Return list of palindormes and writes them to file.
"""
palindromes = []
all_words = self.read_file(path)
for word in all_words:
palindrome = True
word_stack = ArrayStack()
for letter in word[:len(word) // 2]:
word_stack.push(letter)
for letter in word[(len(word) + 1) // 2:]:
if letter != word_stack.pop():
palindrome = False
if palindrome:
palindromes.append(word)
self.write_to_file(palindromes, wirte_file)
return palindromes
def find_palindromes(self, file_to_read, file_to_write):
"""
Finds palindromes in a file and writes them to another file.
"""
self.palindomes = []
new_stack = ArrayStack()
list_of_words = self.read_file(file_to_read)
self.file_to_write = file_to_write
for word in list_of_words:
for letter in word:
new_stack.push(letter)
try:
if self.check(word, new_stack):
self.palindomes.append(word)
self.write_to_file(word)
except KeyError:
continue
return self.palindomes
class PFEvaluator(object):
def __init__(self, scanner):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._scanner = scanner
def evaluate(self):
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
elif currentToken.isOperator():
if len(self._operandStack) < 2:
raise AttributeError("Too few operands on the stack")
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(self._computeValue(currentToken,
t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
else:
raise AttributeError("Unknown token type")
if len(self._operandStack) > 1:
raise AttributeError("Too many operands on the stack")
result = self._operandStack.pop()
return result.getValue();
def __str__(self):
result = "\n"
if self._expressionSoFar == "":
result += "Portion of expression processed: none\n"
else:
result += "Portion of expression processed: " + \
self._expressionSoFar + "\n"
if self._operandStack.isEmpty():
result += "The stack is empty"
else:
result += "Operands on the stack : " + \
str(self._operandStack)
return result
def _computeValue(self, op, value1, value2):
result = 0;
theType = op.getType()
if theType == Token.PLUS:
result = value1 + value2;
elif theType == Token.MINUS:
result = value1 - value2;
elif theType == Token.MUL:
result = value1 * value2;
elif theType == Token.DIV:
result = value1 // value2;
else:
raise Exception("Unknown operator")
return result
def find_palindromes(self, file_from, file_to):
"""
fincs all the palindromes and writes them to file_to
"""
self.read_file(file_from)
palindromes = ArrayStack()
for word in self.words:
if self.is_palindrome(word):
palindromes.push(word)
self.palindromes = []
while True:
try:
word = palindromes.pop()
# if len(word) > 1: -- would've been useful for end version
self.palindromes.append(word)
except KeyError:
break
self.palindromes = self.palindromes[::-1]
self.write_to_file(file_to)
return self.palindromes
def check_brackets(s):
stack = ArrayStack()
for i in s:
if i == "(":
stack.push("(")
if i == ")":
if stack.isEmpty():
return False
stack.pop()
if stack.isEmpty():
return True
else:
return False
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 _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 infixToPostfix(exp):
stck = ArrayStack()
postfix = ""
for i in range(len(exp)):
if isOperand(exp[i]):
postfix += exp[i]
else:
if stck.isEmpty():
stck.push(exp[i])
else:
if prec(exp[i]) >= prec(stck.peek()):
stck.push(exp[i])
else:
while not stck.isEmpty() and prec(exp[i]) < prec(stck.peek()):
postfix += stck.pop()
stck.push(exp[i])
# print "Stack:", stck.printStack(), "Expression:", postfix
while not stck.isEmpty():
postfix += stck.pop()
return postfix
def __init__(self, scanner):
self._expressionSoFar = ""
self._operandStack = ArrayStack()
self._scanner = scanner
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
def _initialize(self):
self.n = 0
self.blocks = ArrayStack()
def _initialize(self):
self.front = ArrayStack()
self.back = ArrayStack()
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()
def convert(self):
operatorStack = ArrayStack() #this will hold operators and grouping symbols
postfixExpression = "" #this will hold the final expression
while self.scanner.hasNext():
token_char = self.scanner.next()
if token_char.getType() == 4: #it's an integer
postfixExpression += str(token_char.getValue()) + " "
elif token_char.getValue() in ['(','[']: #left parenthesis
operatorStack.push(token_char)
elif token_char.isOperator(): #it's an operator
#pop off all the operators with equal or greater precedence
while len(operatorStack) != 0 and operatorStack.peek().getPrecedence() >= token_char.getPrecedence():
postfixExpression += str(operatorStack.pop().getValue()) + " "
#now we can push the new operator onto the stack
operatorStack.push(token_char)
elif token_char.getValue() in [')',']']: #right parenthesis
while len(operatorStack) != 0 and operatorStack.peek().getValue() not in ['(','[']: #find the matching one
postfixExpression += str(operatorStack.pop().getValue()) + " "
operatorStack.pop() #discard the left parenthesis
elif token_char.getType() == 0 and token_char.getValue() not in ['(',')','[',']']:
raise Exception("Error: unknown character.") #unknown character
#transfer over any remaining operators
while len(operatorStack) != 0:
postfixExpression += str(operatorStack.pop().getValue()) + " "
return postfixExpression
def in_edges(self, i):
out = ArrayStack()
for j in range(self.n):
if self.has_edge(j, i): out.append(j)
return out
