class Queue():
'''
Invarient :
Front will always contain elements if the back contains elements and peeking at front is always O(1)
'''
def __init__(self):
self.front = Stack()
self.back = Stack()
def size(self):
return self.front.size() + self.back.size()
def add(self, item):
self.back.push(item)
if (self.front.empty()):
self.transfer()
def top(self):
return self.front.top()
def empty(self):
return self.front.empty()
def remove(self):
if (self.empty()):
return Exception
self.front.pop()
if (self.front.empty()):
self.transfer()
def transfer(self):
while not self.back.empty():
self.front.push(self.back.top())
self.back.pop()
class StackWithMin:
def __init__(self):
self.stack = Stack()
self.minstack = Stack()
def push(self, value):
self.stack.push(value)
if value < self.min():
self.minstack.push(value)
def pop(self):
if self.stack.peek() == self.minstack.peek():
self.minstack.pop()
return self.stack.pop()
def peek(self):
return self.stack.peek()
def empty(self):
return self.stack.empty()
def min(self):
if self.minstack.empty():
return sentinal
else:
return self.minstack.peek()
def test_clear(self):
'''
Test peek
:return:
'''
s = Stack()
s.push("One")
s.push("Two")
self.assertEquals(False,s.empty())
s.clear()
self.assertEquals(True,s.empty())
def test_push_pop(self):
'''
Test Push Pop
:return:
'''
s = Stack()
s.push("One")
self.assertEquals(False,s.empty())
s.pop()
self.assertEquals(True,s.empty())
def PreOrderWalk_NoRecursion(root):
s = Stack()
s.push(root)
while not s.empty() :
node = s.pop()
print(node.value)
if node.right != None:
s.push(node.right)
if node.left != None:
s.push(node.left)
class MyQueue:
def __init__(self):
self.stack1 = Stack()
self.stack2 = Stack()
def enqueue(self, value):
self.stack1.push(value)
def dequeue(self):
if not self.stack2.empty():
return self.stack2.pop()
while not self.stack1.empty():
self.stack2.push(self.stack1.pop())
return self.stack2.pop()
def empty(self):
return self.stack1.empty()
def printContents(self):
s = Stack()
print("Contents of Stack " + str(self.index))
while not self.stack.empty():
disk = self.stack.pop()
print(disk)
s.push(disk)
while not s.empty():
self.stack.push(s.pop())
def SortStack(s):
temp = Stack()
while not s.empty():
x = s.pop()
while not temp.empty() and x > temp.peek():
s.push(temp.pop())
temp.push(x)
return temp
def InOrderWalk_NoRecursion(root):
s = Stack()
s.push(root)
while not s.empty():
node = s.peek()
if node.left != None:
s.push(node.left)
continue
node = s.pop()
while node != None:
print(node.value)
if node.right == None:
if not s.empty():
node = s.pop()
else:
break
else:
s.push(node.right)
break
def has_cycle(self):
stack = Stack()
for node in self.nodes:
self.set_all_nodes_inactive()
stack.empty()
stack.push(node)
while not stack.is_empty():
current_node = stack.pop()
if current_node.is_active():
return True
current_node.set_active(True)
for adjacent_node in current_node.get_adjacent_nodes():
stack.push(adjacent_node)
return False
def inorder(rootNode): s = Stack() p = rootNode while(p or (not s.empty())): if p: s.push() p = p.leftChild else: p = s.pop() BinaryTree._visit(p) p = p.leftChild
def PostOrderWalk_NoRecursion(root):
s = Stack()
s.push(root)
while not s.empty() :
node = s.peek()
if node.right != None:
s.push(node.right)
continue
if node.left != None:
s.push(node.left)
continue
if root.left != None:
s.push(root.left)
root = root.left
else:
break
while not s.empty():
print(s.pop().value)
def preorder(rootNode): s = Stack() p = rootNode while(p or (not s.empty())): if p: BinaryTree._visit(p) if p.rightChild: s.push(p.rightChild) p = p.leftChild else: p = s.pop()
class Tower:
def __init__(self,index):
self.stack = Stack()
self.index = index
def addDisk(self, disk):
if self.stack.empty() or self.stack.peek() > disk:
self.stack.push(disk)
else:
print("Error in adding disk " + str(disk) + " to tower "+ str(self.index))
def removeDisk(self):
if not self.stack.empty():
return self.stack.pop()
else:
return -1
def printContents(self):
s = Stack()
print("Contents of Stack " + str(self.index))
while not self.stack.empty():
disk = self.stack.pop()
print(disk)
s.push(disk)
while not s.empty():
self.stack.push(s.pop())
def moveOneDisk(self, tower):
disk = self.removeDisk()
if disk != -1:
tower.addDisk(disk)
print("Moved disk "+ str(disk) + " from tower " + str(self.index) + " to tower " + str(tower.index))
# This is the important one
def moveDisks(self, destTower, bufferTower, n):
if n > 0:
self.moveDisks(bufferTower, destTower, n-1)
self.moveOneDisk(destTower)
bufferTower.moveDisks(destTower, self, n-1)
def divideBy2(decNumber):
remstack = Stack()
while decNumber > 0:
rem = decNumber % 2
remstack.push(rem)
decNumber = decNumber // 2
binString = ""
while not remstack.empty():
binString = binString + str(remstack.pop())
return binString
def depth_first_search(self, source, target):
stack = Stack()
found = None
self.set_all_nodes_unvisited()
stack.empty()
stack.push(source)
while not stack.is_empty():
current_node = stack.pop()
if current_node.is_visited():
continue
if current_node.data == target:
return target
current_node.set_visited(True)
for adjacent_node in current_node.get_adjacent_nodes():
if not adjacent_node.is_visited():
stack.push(adjacent_node)
return found
def dfs(self,vertex):
seen = set()
s = Stack()
s.push(self.startVertex)
while not s.empty():
v = s.pop()
if vertex == v:
print("Vertex Found")
return
seen.add(v)
adjList = self.graph[v]
for w in adjList:
if w not in seen and not s.contains(w):
s.push(w)
print("Vertex not found")
return
def iter_qsort(arr, p, q):
if p > q:
return None
task = Stack()
# pamietac zeby sciagac zadania w odwrotnej kolejnosci!
task.push(q)
task.push(p)
while not task.empty():
l = task.pop()
r = task.pop()
if l < r:
s = partition(arr, l, r)
task.push(s - 1)
task.push(l)
task.push(r)
task.push(s + 1)
def postorder(rootNode): s = Stack() p = rootNode lastVisit = None s.push() while(not s.empty()): p = s.top() #case1: the right child is visited, so left child must be visited #case2: left and right child are all null #case3: the left child is visited and the right child is null if(p.rightChild == lastVisit)or(p.rightChild == None and p.leftChild == None)or(p.rightChild == None and p.leftChild == lastVisit): BinaryTree._visit(p) lastVisit = p s.pop() else: if(p.rightChild): s.push(p.rightChild) if(p.leftChild): s.push(p.leftChild)
def spider(url):
try:
st = Stack()
st.push(url) # 第一个进栈
while st.empty() != True:
url_recive = st.pop()
html = urllib.request.urlopen(url_recive)
data = html.read()
data = data.decode()
soup = BeautifulSoup(data, 'lxml')
soup.prettify()
print(soup.find('h3').text)
links = soup.select('a')
# start,end,step
for i in range(len(links) - 1, -1, -1):
href = links[i]['href']
linksUrl = url + '/' + href
st.push(linksUrl)
except Exception as err:
print(err)
def spider(url):
global urls
stack = Stack()
stack.push(url)
while not stack.empty():
url = stack.pop() # 出栈
if url not in urls:
urls.append(url) # 如果url不在urls里，追加u到urls
try:
data = urllib.request.urlopen(url)
data = data.read()
data = data.decode()
soup = BeautifulSoup(data, 'lxml')
print(soup.find('h3').text)
links = soup.select('a')
for i in range(len(links) - 1, -1, -1):
link = start_url + '/' + links[i]['href']
stack.push(link)
except Exception as err:
print(err)
def sort_stack(s):
# r is the temporary stack
r = Stack()
while not s.empty():
# Get the top element
tmp = s.pop()
if r.empty():
r.push(tmp)
else:
if tmp >= r.peek():
r.push(tmp)
else:
flush(r, s)
r.push(tmp)
flush(r, s)
return s
class Screen:
def __init__(self):
self.config = ConfigParser()
self.config.read('config.ini')
self.size = int(self.load_var("size"))
self.theme = self.load_var("theme")
self.lang = self.load_var("lang")
self.size_of_stack = int(self.load_var("size_of_stack"))
self.screen_width = int(self.load_var("screen_width"))
self.screen_height = round(self.screen_width * 1.065)
self.langs = []
self.nof = 0
for num, img in enumerate(listdir("images\\flags")):
self.langs.append(img[:5])
self.nof = num
Square.add_theme(self.theme)
self.settings()
pygame.init()
self.icon = pygame.image.load("images\\icon.png")
pygame.display.set_icon(self.icon)
self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
self.fps = int(self.load_var("fps"))
self.flags_img = []
for num, img in enumerate(listdir("images\\flags")):
self.flags_img.append(pygame.image.load("images\\flags\\" + img).convert())
self.flags_img[num] = pygame.transform.scale(self.flags_img[num], (16, 10))
pygame.display.set_caption("2048 Game!")
self.background_color_play = (189, 173, 161)
self.background = pygame.image.load('images\\background.jpg').convert()
self.background = pygame.transform.scale(self.background,
(self.screen_width,
self.screen_height))
self.clock = pygame.time.Clock()
self.game = False
self.langb = []
for i in range(len(self.langs)+1):
self.langb.append(Button(x=self.screen_width-55, y=11+16*i, width=100, height=17,
color=(0, 0, 0), text="", change=0))
self.main_menu()
self.up_key = pygame.K_UP
self.left_key = pygame.K_LEFT
self.right_key = pygame.K_RIGHT
self.down_key = pygame.K_DOWN
self.backspace_key = pygame.K_BACKSPACE
self.width = (self.screen_width-40-10*(2*self.size-1))/self.size
self.tiles = []
self.score = 0
self.best = 0
self.pause_menu = False
for i in range(self.size):
for j in range(self.size):
x1 = j*20+20
y1 = i*20+20
self.tiles.append(Square(x1=x1+j*self.width, y1=y1+i*self.width+self.screen_height-self.screen_width,
x2=self.width, y2=self.width))
if self.size_of_stack:
self.stack = Stack(self.size_of_stack * self.size * self.size)
self.score_stack = Stack(self.size_of_stack)
self.best_score_stack = Stack(self.size_of_stack)
self.play()
def event_catcher(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
if not self.game:
Screen.quit()
elif self.pause_menu:
self.pause_menu = False
elif self.game:
self.pause_menu = True
self.pause()
elif self.game:
if event.key == self.up_key:
return "up"
elif event.key == self.left_key:
return "left"
elif event.key == self.right_key:
return "right"
elif event.key == self.down_key:
return "down"
elif event.key == self.backspace_key:
return "back"
def message_display(self, text, x, y, font_size, color=(0, 0, 0), font="Verdana", pos="center"):
font = "fonts\\{}.ttf".format(font)
font = pygame.font.Font(font, font_size)
text_surf, text_rect = Screen.text_objects(text, font, color)
text_rect.center = (x, y)
if pos == "left":
text_rect.left = x
elif pos == "right":
text_rect.right = x
self.screen.blit(text_surf, text_rect)
def check_lose(self):
points = 0
for k in range(self.size*self.size):
if self.tiles[k].value == 0:
points += 1
break
if not points:
Screen.quit()
def move(self, direction):
if direction != "back" and self.size_of_stack:
for tile in self.tiles:
self.stack.push(tile.value)
self.score_stack.push(self.score)
self.best_score_stack.push(self.best)
if direction == "up":
for k in range(self.size*self.size):
for l in range(1, k // self.size+1):
if self.tiles[k-self.size*l].value == 0 or \
self.tiles[k-self.size*l].value == self.tiles[k-self.size*(l-1)].value:
if self.tiles[k-self.size*l].value != 0 and self.tiles[k-self.size*(l-1)].value != 0:
self.score += self.tiles[k-self.size*l].value + self.tiles[k-self.size*(l-1)].value
self.tiles[k-self.size*l].value += self.tiles[k-self.size*(l-1)].value
self.tiles[k-self.size*(l-1)].value = 0
elif direction == "left":
for k in range(self.size*self.size):
for l in range(1, k % self.size+1):
if self.tiles[k-l].value == 0 or \
self.tiles[k-l].value == self.tiles[k-(l-1)].value:
if self.tiles[k-l].value != 0 and self.tiles[k-l].value != 0:
self.score += self.tiles[k-l].value + self.tiles[k-(l-1)].value
self.tiles[k-l].value += self.tiles[k-(l-1)].value
self.tiles[k-(l-1)].value = 0
elif direction == "right":
for k in range(self.size*self.size-1, -1, -1):
for l in range(1, self.size - k % self.size):
if self.tiles[k+l-1].value == self.tiles[k+l].value or \
self.tiles[k+l].value == 0:
if self.tiles[k+l-1].value != 0 and self.tiles[k+l].value != 0:
self.score += self.tiles[k+l].value + self.tiles[k+l-1].value
self.tiles[k+l].value += self.tiles[k+l-1].value
self.tiles[k+l-1].value = 0
elif direction == "down":
for k in range(self.size*self.size-1, -1, -1):
for l in range(1, self.size-k//self.size):
if self.tiles[k+(l-1)*self.size].value == self.tiles[k+l*self.size].value or \
self.tiles[k+l*self.size].value == 0:
if self.tiles[k+(l-1)*self.size].value != 0 and self.tiles[k+l*self.size].value != 0:
self.score += self.tiles[k+l*self.size].value + self.tiles[k+(l-1)*self.size].value
self.tiles[k+l*self.size].value += self.tiles[k+(l-1)*self.size].value
self.tiles[k+(l-1)*self.size].value = 0
elif direction == "back" and self.size_of_stack:
if not self.stack.empty():
for i in range(self.size * self.size, 0, -1):
self.tiles[i-1].value = self.stack.top()
self.stack.pop()
self.score = self.score_stack.top()
self.score_stack.pop()
self.best = self.best_score_stack.top()
self.best_score_stack.pop()
def random_field(self):
self.check_lose()
field = randint(0, self.size*self.size-1)
while True:
if not self.tiles[field].value:
x = randint(0, 10)
if not x:
self.tiles[field].value = 4
else:
self.tiles[field].value = 2
break
else:
field = randint(0, self.size*self.size-1)
def main_menu(self):
# PLAY BUTTON
play = Button(x=0.5*self.screen_width, y=0.5 * self.screen_height,
width=0.5*self.screen_width, height=0.1*self.screen_height,
color=(20, 163, 39), text="play")
# EXIT BUTTON
exitb = Button(x=0.5*self.screen_width, y=0.5 * self.screen_height+play.height+10,
width=0.5*self.screen_width, height=0.1*self.screen_height,
color=(204, 13, 0), text="exit")
while not self.game:
self.screen.blit(self.background, (0, 0))
self.event_catcher()
# LOGO
self.message_display("2048", 0.5 * self.screen_width, 0.2 * self.screen_height,
200, (242, 82, 31), "Clear Sans Bold")
# PLAY BUTTON
pygame.draw.rect(self.screen, play.color, [play.x, play.y, play.width, play.height])
self.message_display(Screen.req_word(play.text, self.lang), play.x+0.5*play.width,
play.y+0.475*play.height, 50, (0, 0, 0), "DejaVu Sans Mono")
if play.check(pygame.mouse.get_pos()):
self.game = True
# EXIT BUTTON
pygame.draw.rect(self.screen, exitb.color, [exitb.x, exitb.y, exitb.width, exitb.height])
self.message_display(Screen.req_word(exitb.text, self.lang), exitb.x+0.5*play.width,
exitb.y+0.475*exitb.height, 50, (0, 0, 0), "DejaVu Sans Mono")
if exitb.check(pygame.mouse.get_pos()):
Screen.quit()
self.show_languages()
self.clock.tick(self.fps)
pygame.display.update()
def play(self):
self.reset()
self.random_field()
while self.game:
self.screen.fill(self.background_color_play)
direction = self.event_catcher()
if direction:
self.move(direction)
if direction != "back":
self.random_field()
if self.score > self.best:
self.best = self.score
for i in range(self.size*self.size):
self.tiles[i].update_color()
pygame.draw.rect(self.screen, self.tiles[i].color, [self.tiles[i].x1, self.tiles[i].y1,
self.tiles[i].x2, self.tiles[i].y2])
if self.tiles[i].value:
self.message_display(text=str(self.tiles[i].value), x=(2*self.tiles[i].x1+self.tiles[i].x2)/2,
y=(2*self.tiles[i].y1+self.tiles[i].y2)/2, font_size=100,
color=self.tiles[i].font_color, font="Clear Sans Bold")
# UNDO
if self.size_of_stack:
self.message_display(text=Screen.req_word("undo", self.lang)+": {}".format(self.stack.size()//len(self.tiles)),
x=20, y=(self.screen_height-self.screen_width+10)/2, font="DejaVu Sans Mono", font_size=30,
color=(69, 69, 69), pos="left")
else:
self.message_display(text=Screen.req_word("undo", self.lang)+": 0",
x=20, y=(self.screen_height-self.screen_width+10)/2, font="DejaVu Sans Mono", font_size=30,
color=(69, 69, 69), pos="left")
# SCORE
self.message_display(text=Screen.req_word("score", self.lang)+": {}".format(self.score),
x=self.screen_width*0.5, y=(self.screen_height-self.screen_width+10)/2,
font="DejaVu Sans Mono", font_size=30, color=(69, 69, 69))
# BEST SCORE
self.message_display(text=Screen.req_word("best", self.lang)+": {}".format(self.best),
x=self.screen_width-20, y=(self.screen_height-self.screen_width+10)/2,
font="DejaVu Sans Mono", font_size=30, color=(69, 69, 69), pos="right")
self.clock.tick(self.fps)
pygame.display.update()
self.main_menu()
def pause(self):
# Resume button
resumeb = Button(x=0.5*self.screen_width, y=0.5 * self.screen_height,
width=0.5*self.screen_width, height=0.1*self.screen_height,
color=(20, 163, 39), text="resume")
# Back to menu button
endb = Button(x=0.5*self.screen_width, y=0.5 * self.screen_height+resumeb.height+10,
width=0.5*self.screen_width, height=0.1*self.screen_height,
color=(204, 13, 0), text="end")
while self.pause_menu:
self.screen.blit(self.background, (0, 0))
self.event_catcher()
# Pause logo
self.message_display(Screen.req_word("pause", self.lang), 0.5 * self.screen_width,
0.07 * self.screen_height, 100, (242, 82, 31), "Clear Sans Bold")
# Resume Button
pygame.draw.rect(self.screen, resumeb.color, [resumeb.x, resumeb.y, resumeb.width, resumeb.height])
self.message_display(Screen.req_word(resumeb.text, self.lang), resumeb.x+0.5*resumeb.width,
resumeb.y+0.475*resumeb.height, 50, (0, 0, 0), "DejaVu Sans Mono")
if resumeb.check(pygame.mouse.get_pos()):
self.pause_menu = False
# Back to menu Button
pygame.draw.rect(self.screen, endb.color, [endb.x, endb.y, endb.width, endb.height])
self.message_display(Screen.req_word(endb.text, self.lang), endb.x+0.5*endb.width,
endb.y+0.475*endb.height, 50, (0, 0, 0), "DejaVu Sans Mono")
if endb.check(pygame.mouse.get_pos()):
self.pause_menu = False
self.game = False
sleep(0.1)
self.show_languages(bg=None)
self.clock.tick(self.fps)
pygame.display.update()
def settings(self):
changed = False
while True:
Screen.cls()
print("\n{}:\n".format(Screen.req_word("current_settings", self.lang)))
print("1) {}: {}".format(Screen.req_word("size", self.lang), self.size))
print("2) {}: {}".format(Screen.req_word("theme", self.lang), self.theme))
print("3) {}: {}".format(Screen.req_word("language", self.lang), self.lang))
print("4) {}: {}".format(Screen.req_word("undo_moves", self.lang), self.size_of_stack))
print("5) {}".format(Screen.req_word("advanced_options", self.lang)))
print("\n6) {}".format(Screen.req_word("save_settings", self.lang)))
print("\n{}".format(Screen.req_word("instrucion", self.lang)))
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
choice = input()
if not choice:
if changed:
for i in range(10):
Screen.cls()
print("\n{}".format(Screen.req_word("req_change", self.lang)))
print("\n1) {}".format(Screen.req_word("yes", self.lang)))
print("2) {}".format(Screen.req_word("no", self.lang)))
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
choice = input()
if choice is "1":
sett_list = {"size": self.size, "theme": self.theme,
"lang": self.lang, "size_of_stack": self.size_of_stack}
self.save(sett_list)
elif choice is "2":
pass
else:
continue
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
break
elif choice is "1":
self.set_size()
elif choice is "2":
self.select_theme()
elif choice is "3":
self.set_lang()
elif choice is "4":
self.set_stack()
elif choice is "5":
self.advanced_settings()
elif choice is "6":
if changed:
changed = False
sett_list = {"size": self.size, "theme": self.theme,
"lang": self.lang, "size_of_stack": self.size_of_stack}
self.save(sett_list)
continue
if not changed:
changed = True
def advanced_settings(self):
while True:
Screen.cls()
print("\n{}:\n".format(Screen.req_word("current_settings", self.lang)))
print("1) {}: {}".format(Screen.req_word("width", self.lang), self.screen_width))
print("2) {}".format(Screen.req_word("load_default", self.lang)))
print("\n{}".format(Screen.req_word("instrucion", self.lang)))
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
choice = input()
if not choice:
break
elif choice is "1":
self.set_width()
elif choice is "2":
self.load_default()
def save(self, sett_list):
try:
self.config.add_section('settings')
except:
pass
for key, value in sett_list.items():
self.config.set('settings', key, str(value))
with open('config.ini', 'w') as f:
self.config.write(f)
f.close()
def load_default(self):
self.size = int(self.config.get('default_settings', "size"))
self.theme = self.config.get('default_settings', "theme")
self.lang = self.config.get('default_settings', "lang")
self.size_of_stack = int(self.config.get('default_settings', "size_of_stack"))
self.screen_width = int(self.config.get('default_settings', "screen_width"))
def set_size(self):
Screen.cls()
print("{}?".format(Screen.req_word("req_size", self.lang)))
for i in range(10):
try:
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
self.size = int(input())
except ValueError:
print("{} 4 {} 16".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
if self.size > 16 or self.size < 4:
print("{} 4 {} 16".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
def select_theme(self):
Screen.cls()
print("{}?".format(Screen.req_word("req_theme", self.lang)))
for theme in listdir("Themes\\"):
if theme[:-4] != "Example":
print(theme[:-4])
for i in range(10):
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
self.theme = input()
if not isfile("Themes\\{}.txt".format(self.theme)):
print("{}".format(Screen.req_word("wrong_option", self.lang)))
continue
if self.theme == "Example":
print("{}".format(Screen.req_word("wrong_option", self.lang)))
continue
Square.add_theme(self.theme)
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
def set_lang(self):
Screen.cls()
print("{}?".format(Screen.req_word("req_lang", self.lang)))
for index, item in enumerate(self.langs):
print(f"{index}.", item)
for i in range(10):
try:
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
self.lang = int(input())
except ValueError:
print("{} 0 {} {}".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang),
self.nof))
continue
if self.lang > self.nof or self.lang < 0:
print("{} 0 {} {}".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang),
self.nof))
continue
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
self.lang = self.langs[self.lang]
def set_stack(self):
Screen.cls()
print("{}?".format(Screen.req_word("req_stack", self.lang)))
for i in range(10):
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
try:
self.size_of_stack = int(input())
except ValueError:
print("{} 0 {} 99".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
if self.size_of_stack > 99 or self.size_of_stack < 0:
print("{} 0 {} 99".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
def set_width(self):
Screen.cls()
print("{}?".format(Screen.req_word("req_width", self.lang)))
for i in range(10):
try:
print("\n{}: ".format(Screen.req_word("input", self.lang)), end='')
self.screen_width = int(input())
self.screen_height = int(self.screen_width*1.065)
except ValueError:
print("{} 600 {} 950".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
if self.screen_width > 950 or self.screen_width < 600:
print("{} 600 {} 950".format(Screen.req_word("inv_option1", self.lang),
Screen.req_word("inv_option2", self.lang)))
continue
break
else:
print("{}".format(Screen.req_word("critical", self.lang)))
Screen.quit()
def show_languages(self, bg=False):
# LANG BUTTON
for i in range(len(self.langs)+1):
if bg:
pygame.draw.rect(self.screen, self.langb[i].color, [self.langb[i].x, self.langb[i].y, self.langb[i].width, self.langb[i].height])
if self.langb[i].check(pygame.mouse.get_pos()) and i and self.langs[i-1] != self.lang:
self.lang = Screen.req_word("short_name", self.langs[i-1])
self.config.set('settings', "lang", str(self.langs[i-1]))
with open('config.ini', 'w') as f:
self.config.write(f)
f.close()
# Names of languages
s = 0
self.message_display(text=Screen.req_word("selected", self.lang) + ": " +
Screen.req_word("full_name", self.lang),
font_size=15, x=self.screen_width-25, y=10, pos="right")
self.screen.blit(self.flags_img[self.find()], (self.screen_width-20, 5))
for item in self.langs:
self.message_display(text=Screen.req_word("full_name", item),
font_size=15, x=self.screen_width-25, y=26+(16*s), pos="right")
self.screen.blit(self.flags_img[s], (self.screen_width-20, 21+(16*s)))
s += 1
def reset(self):
for i in range(self.size*self.size):
self.tiles[i].value = 0
self.score = 0
if self.size_of_stack:
while not self.stack.empty():
self.stack.pop()
def find(self):
i = 0
for element in self.langs:
if element == self.lang:
return i
else:
i += 1
def load_var(self, option):
try:
return self.config.get("settings", option)
except:
try:
return self.config.get("default_settings", option)
except:
raise ValueError("No option {} in section \'default_settings\'".format(option))
@classmethod
def text_objects(cls, text, font, color):
text_surface = 0
try:
text_surface = font.render(text, True, color)
except AttributeError:
font = pygame.font.SysFont("Arial", 50)
text_surface = font.render(text, True, color)
finally:
return text_surface, text_surface.get_rect()
@classmethod
def req_word(cls, requested_word, language):
full_path = path.abspath(path.join("lang", "{}.xml".format(language)))
for word in ElementTree.parse(full_path).findall(language):
return word.find(requested_word).text
@classmethod
def quit(cls):
pygame.quit()
sys.exit()
@classmethod
def cls(cls):
system('cls' if name=='nt' else 'clear')
def test_empty(self):
s = Stack()
self.assertTrue(s.empty())
s = Stack(1, 2, 3, "Hello", "World")
self.assertFalse(s.empty())
stack.push(1)
stack.push(2)
stack.push('oi')
stack.push('1.2')
stack.push(True)
stack.push('a')
#Print elements
print(stack)
#Erase two elements
stack.pop()
stack.pop()
#Print stack again
print(stack)
#Show queue size
print(stack.__len__())
#Check if stack is empty
print(stack.empty())
#Erase remaining elements
stack.pop()
stack.pop()
stack.pop()
stack.pop()
#Check again if stack is empty
print(stack.empty())
import random
from Stack import Stack
def SortStack(s):
temp = Stack()
while not s.empty():
x = s.pop()
while not temp.empty() and x > temp.peek():
s.push(temp.pop())
temp.push(x)
return temp
#######################################
q = Stack()
n = 20
for _ in range(n):
q.push(random.randint(1, n))
q = SortStack(q)
while not q.empty():
print(q.pop())
