def analizarSintactico(self): a = self.Lexico.siguienteComponenteLexico( self.tablaSimbolos ) #a es un vector con el componente lexico y el lexema en este orden resultado = 0 # resultado =0 indica que el analizador Sintactico debe seguir analizando while resultado == 0: X = self.pila.popp() #desapila if X != lex.peso: self.nodoActual = self.pila2.popp( ) #desapila segunda pila y lo asigna a nodo actual if X == a[0] == lex.peso: resultado = 1 #proceso terminado con exito elif X in Terminal: #si X es terminal if X == a[0]: #y es el componente lexico leido self.nodoActual.agregarHijo(ar.Nodo( a[1])) #se agrega como hijo al nodo actual a = self.Lexico.siguienteComponenteLexico( self.tablaSimbolos ) #y se obtiene el siguiente componente else: resultado = -1 #error elif X in Variables: #si X es variable v = tas.tas( X[0], a[0] ) #se obtiene el vector con la variable y el componente correspondiente if tas.tVecTASVacio(v): #si esta v vacio print("Error sintactico") resultado = -1 #error else: i = 0 auxPila = p.Pila() #se crea dos auxiliares pila auxPila2 = p.Pila() while i < len(v) and v[ i] != []: #mientras no se pase de rango y no quede vacio self.nodoActual.agregarHijo(ar.Nodo( v[i])) # se agrega el hijo ial arbol nodo = self.nodoActual.getHijos()[ -1] #se obtiene su nodo auxPila.push( v[i] ) #se apila en la primera pila auxiliar el elemento auxPila2.push( nodo ) # se apila en la segunda pila auxiliar el nodo i += 1 #se suma al contador while i >= 0: #mientras sea mayor igual a cero, como un for de i..0 aux = auxPila.popp( ) #se desapilan en auxiliares las pilas auxiliares aux2 = auxPila2.popp() if aux != None and aux != lex.epsilon: #no se apila epsilon self.pila.push( aux ) # se apilar los auxiliares de forma que quedan apiladas de manera invertida if aux2 != None and aux != lex.epsilon: self.pila2.push(aux2) i -= 1 #se descuenta contador return self.arbol #se devuelve el arbol
def __init__(self, cadena): self.pila = Pila() self.bandera = False self.i = -1 self.transicion_p = True self.transicion_q = False self.transicion_r = False self.palabra = cadena self.verificar() self.definir()
def __init__(self, cadena): self.pila = Pila() self.bandera = False self.i = -1 self.transicion_p = True self.transicion_q = False self.transicion_r = False self.palabra = cadena self.verificar() self.definir() """self.arcos.append(Arco('p','p','#','a','#a'))
def __init__(self, archivoAEjecutar): self.tablaSimbolos = ts.crearTS() #crea la tabla de simbolos self.arbol = ar.Nodo(lex.S) #crea el arbol con raiz S self.pila = p.Pila( ) #crea pila para apilar lo que contiene un vector de la tas self.pila2 = p.Pila( ) #crea pila para apilar el nodo del arbol en el que se encuentra un elemento apilado de la primer pila self.pila.push(lex.peso) # apilamos el simbolo final self.pila.push(lex.S) # apilamos primer Variable self.pila2.push(self.arbol) #apilamos raiz self.nodoActual = self.arbol # el nodo inicial es la raiz self.archivo = open(archivoAEjecutar) self.Lexico = lex.Lexico( self.archivo) # creacion del analizador Lexico
def inicio(): pila = Pila() m = input("ingreso en post-orden:").split(" ") k = len(m) for j in range(0, k): y = m[j] if y in ["+", "-", "*", "/"]: if (len(pila.items) >= 2): der = pila.desapilar() izq = pila.desapilar() nodo = Nodo(y, izq, der) x = evaluar(nodo) pila.apilar(x) else: print("estructura incorrecta") else: y = int(y) pila.apilar(y) print(pila.desapilar())
def __init__(self): self.metodos = Metodos() self.pila = pi.Pila() self.codigo = "" self.errores = L_Error.L_Error() self.continuar = True self.actual = None
def __init__(self, palabra): self.pila = Pila.Pila() self.resultado = [] self.transiciones = [] self.p_1 = True self.q_2 = False self.r_final = False self.palabra = palabra
def generarDigraph(self): self.pilaIni = Pila.Pila() self.pilaFin = Pila.Pila() for i in self.posfija: if(i in self.alfabeto): self.crearTupla(i) elif(i == (".")): self.concatenar() elif(i == ("+")): self.operadorsuma() elif(i == ("*")): self.operadorasterisco() elif(i == ("?")): self.operadorInterrogacion() elif(i == ("|")): self.operadorO() self.actualizarInicialyFinal()
def generar_partes(): ''' Devuelve un diccionario cuyas claves son los tipos de partes disponibles y sus valores son pilas de partes de dicho tipo. ''' partes = {} for _ in range(CANTIDAD_PARTES): parte = Parte() #Se adosan las armas correspondientes a la parte segun sus slots disponibles. for _ in range(parte.get_cantidad_slots()): parte.attach_arma(Arma()) pila_tipo = partes.get(parte.get_tipo_parte(), Pila()) pila_tipo.apilar(parte) partes[parte.get_tipo_parte()] = pila_tipo #Se generan las armas partes['Arma'] = Pila() for _ in range(CANTIDAD_ARMAS): partes['Arma'].apilar(Arma()) return partes
def reversa(lista): long = len(lista) if long > 1: pila = Pila() i = 0 while i < long: pila.apilar(lista[i]) i = i + 1 j = 0 while (not pila.vacia()): lista[j] = pila.tope() pila.desapilar() j = j + 1
def __init__(self, raiz, consola, input, consoladebug): threading.Thread.__init__(self) self.paused = False self.pause_cond = threading.Condition(threading.Lock()) self.metodos = Metodos() self.pila = pi.Pila() self.codigo = "" self.errores = L_Error.L_Error() self.continuar = True self.debbuger = True self.raiz = raiz self.consola = consola self.detener = False self.input = input self.actual = None self.consoladebug = consoladebug self.cuentadebug = 1
def capicua(string): long = len(string) RV = True # si len es 1 entonces string="#" y por lo tanto es capicúa. # la precondición es que el string sea no vacío. if long > 1: pila = Pila() i = 0 while string[i] != "#": pila.apilar(string[i]) i = i + 1 i = i + 1 #para pasar el "#" while not pila.vacia() and i < long and string[i] == pila.tope(): pila.desapilar() i = i + 1 RV = (i == long and pila.vacia()) return RV
def __init__(self): self.cola = Cola.Cola() self.pila = Pila.Pila() self.lista = ListaSimple.ListaSimple()
import Lista import Cola import Pila from flask import Flask, request instanciaCola = Cola.Cola() instanciaLista = Lista.ListaSimple() instanciaPila = Pila.Pila() app = Flask("Practica") #------------------LISTA ENLAZADA---------------------- @app.route('/insertarLista', methods=['POST']) def insertarLista(): valor = str(request.form['palabra']) instanciaLista.insertarInicio(valor) return "se ha insertado el valor en la lista: " + str(valor) @app.route('/eliminarLista', methods=['POST']) def eliminarLista(): valor = int(request.form['numero']) instanciaLista.eliminarPorIndice(valor) return "se ha eliminado el valor: " + str(valor) @app.route('/buscarLista', methods=['POST']) def buscarLista(): valor = str(request.form['palabra']) valo1 = str(instanciaLista.obtenerPosicion(valor)) return str(valo1)
# Practica2s12017_201314359 from flask import Flask, request, Response import Lista import MDispersa import Cola import Pila app = Flask("EDD_codigo_ejemplo") #Ejemplo de una clase, todos los metodos de las clases deben de tener como parametro el "self", que es como el .this en Java lis=Lista.Lista() m=MDispersa.Matriz() col=Cola.Cola() p=Pila.Pila() @app.route('/metodoWeb',methods=['POST']) def hello(): parametro = str(request.form['dato']) dato2 = str(request.form['dato2']) lis.insertar(dato2,parametro) @app.route('/metodoWeb3',methods=['POST']) def hello3(): parametro = str(request.form['dato']) lis.Borrar(parametro)
def procesar(self): text = "Error en los datos ingresados, deben ser 1, 2, 3 o B y no repetirlos" Fin=[1,2,3,'B']; C=Pila(); X=[3,2,1,'B']; Found=Pila(); X[0]=str(_fromUtf8(self.lineEdit.text())) X[1]=str(_fromUtf8(self.lineEdit_2.text())) X[2]=str(_fromUtf8(self.lineEdit_3.text())) X[3]=str(_fromUtf8(self.lineEdit_4.text())) for i in range(len(X)): try: X[i]=int(X[i]) except(ValueError,TypeError): if X[i] == 'b' or X[i] == 'B': X[i] = 'B' pass else: QMessageBox.information(self.iface.mainWindow(),"test", "%s" % (text), QMessageBox.Ok) #self.lineEdit.clear #self.lineEdit_2.clear #self.lineEdit_3.clear #self.lineEdit_4.clear #self.label.clear #self.treeView.reset #break print X C.apilar(X); Found.apilar(False) An, Con = Resolv(Fin, X, 'R') C.apilar(An); Found.apilar(Con) Bn, Con = Resolv(Fin, X, 'I') C.apilar(Bn); Found.apilar(Con) Cn, Con = Resolv(Fin, An, 'R') C.apilar(Cn); Found.apilar(Con) Dn, Con = Resolv(Fin, An, 'I') C.apilar(Dn); Found.apilar(Con) En, Con = Resolv(Fin, Bn, 'R') C.apilar(En); Found.apilar(Con) Fn, Con = Resolv(Fin, Bn, 'I') C.apilar(Fn); Found.apilar(Con) print C.items print Found.items print Found.items.index(True);
import Pila as p pila = p.Pila() class AVL: def __init__(self,dato,izq,der): self.__dato = dato self.__izq = izq self.__der = der self.__delta = 0 def getDato(self): return self.__dato def getIzq(self): return self.__izq def getDer(self): return self.__der #altura: None -> int #entrega la altura del arbol correspondiente al self. #Ejemplo: (2,(1,None,None),(3,None,None)).altura() == 2 def altura(self): if self.__izq is None and self.__der is None: return 1 elif self.__izq is None: return 1 + self.__der.altura() elif self.__der is None: return 1 + self.__izq.altura() else: return 1+max(self.__izq.altura(),self.__der.altura())
def solve_it(input_data): Item = namedtuple("Item", ['index', 'value', 'weight', 'density']) Nodo = namedtuple("Nodo", ['index', 'value', 'room', 'bound', 'taken']) tiempo1 = time() # parse the input lines = input_data.split('\n') firstLine = lines[0].split() item_count = int(firstLine[0]) capacity = int(firstLine[1]) items = [] for i in range(1, item_count + 1): line = lines[i] parts = line.split() items.append( Item(i - 1, int(parts[0]), int(parts[1]), float(parts[0]) / float(parts[1]))) taken = [] taken_optimo = [] items.sort(key=lambda c: c.density, reverse=True) for item in items: taken.append([item.index, 0]) taken_optimo = deepcopy(taken) bound = calcular_bound(items, 0, capacity, 0) pila = Pila.Pila() pila.incluir(Nodo(0, 0, capacity, bound, 1)) max_beneficio = 0 while not pila.estaVacia(): nodo = pila.extraer() if nodo.taken == 0: taken[nodo.index - 1][1] = 0 elif nodo.value > max_beneficio: for i in range(0, nodo.index): taken_optimo[i][1] = taken[i][1] for i in range(nodo.index, len(items)): taken_optimo[i][1] = 0 max_beneficio = nodo.value if nodo.index < len(items): aux_bound = calcular_bound(items, nodo.value, nodo.room, nodo.index) if aux_bound > max_beneficio: pila.incluir( Nodo(nodo.index + 1, nodo.value, nodo.room, aux_bound, 0)) if nodo.room >= items[nodo.index].weight: value = items[nodo.index].value + nodo.value taken[nodo.index][1] = 1 pila.incluir( Nodo(nodo.index + 1, value, nodo.room - items[nodo.index].weight, nodo.bound, 1)) taken_optimo.sort(key=lambda c: c[0]) taken_optimo_ordenado = np.array(taken_optimo) tiempo2 = time() output_data = str(max_beneficio) + ' ' + str(0) + '\n' output_data += ' '.join(map(str, taken_optimo_ordenado[:, 1])) + '\n' output_data += str(tiempo2 - tiempo1) return output_data
class Automata_impar: """automata_act=['p','p','p','q','q','q'] automata_api=['#','a','b','#','a','b'] automata_MH=['a','b','c','e'] automata_Mt=[['p','p','q',' '], ['p','p','q',' '], ['p','p','q',' '], [' ',' ',' ','r'], ['q',' ',' ',' '], [' ','q',' ',' ']] automata_Ma=[['#a','#b','#',' '], ['aa','ab','a',' '], ['ba','bb','b',' '], [' ',' ',' ','#'], ['e',' ',' ',' '], [' ','e',' ',' ']]""" transicion_p = None transicion_q = None transicion_r = None arcos = [] def __init__(self, cadena): self.pila = Pila() self.bandera = False self.i = -1 self.transicion_p = True self.transicion_q = False self.transicion_r = False self.palabra = cadena self.verificar() self.definir() """self.arcos.append(Arco('p','p','#','a','#a')) self.arcos.append(Arco('p','p','#','b','#b')) self.arcos.append(Arco('p','q','#','c','#')) self.arcos.append(Arco('p','p','a','a','aa')) self.arcos.append(Arco('p','p','a','b','ab')) self.arcos.append(Arco('p','q','a','c','a')) self.arcos.append(Arco('p','p','b','a','ba')) self.arcos.append(Arco('p','p','b','b','bb')) self.arcos.append(Arco('p','q','b','c','b')) self.arcos.append(Arco('q','r','#','e','#')) self.arcos.append(Arco('q','q','a','a','e')) self.arcos.append(Arco('q','q','b','b','e'))""" def verificar(self): if (self.palabra.count("c") == 1): cad1, cad2 = self.palabra.split("c") if (cad1 == cad2[::-1]): self.bandera = True def definir(self): arco = Arco('p', 'p', '#', 'a', '#a') self.arcos.append(arco) arco = Arco('p', 'p', '#', 'b', '#b') self.arcos.append(arco) arco = Arco('p', 'q', '#', 'c', '#') self.arcos.append(arco) arco = Arco('p', 'p', 'a', 'a', 'aa') self.arcos.append(arco) arco = Arco('p', 'p', 'a', 'b', 'ab') self.arcos.append(arco) arco = Arco('p', 'q', 'a', 'c', 'a') self.arcos.append(arco) arco = Arco('p', 'p', 'b', 'a', 'ba') self.arcos.append(arco) arco = Arco('p', 'p', 'b', 'b', 'bb') self.arcos.append(arco) arco = Arco('p', 'q', 'b', 'c', 'b') self.arcos.append(arco) arco = Arco('q', 'r', '#', 'e', '#') self.arcos.append(arco) arco = Arco('q', 'q', 'a', 'a', 'e') self.arcos.append(arco) arco = Arco('q', 'q', 'b', 'b', 'e') self.arcos.append(arco) def ejecucion(self, caracter_palabra, verifica): if (self.transicion_p == True and verifica == 0): print("estoy en p") verifica = 1 for arco in self.arcos: if (arco.estadoActual() == 'p' and arco.caracterTransicion() == self.pila.elementos[-1] and caracter_palabra == arco.nombreArco()): print(caracter_palabra + "\n") print(self.pila.elementos) self.pila.desapilar() print(self.pila.elementos) self.pila.apilar(arco.caracterApilar()) print(self.pila.elementos) if (arco.estadoSiguiente() == 'q'): self.transicion_p = False self.transicion_q = True self.transicion_r = False break if (self.transicion_q == True and verifica == 0): print("estoy en q") verifica = 1 for arco in self.arcos: if (arco.estadoActual() == 'q' and arco.caracterTransicion() == self.pila.elementos[-1] and caracter_palabra == arco.nombreArco()): print(self.pila.elementos) self.pila.desapilar() print(self.pila.elementos) self.pila.apilar(arco.caracterApilar()) print(self.pila.elementos) if (arco.estadoSiguiente() == 'r'): self.transicion_p = False self.transicion_q = False self.transicion_r = True break if (self.transicion_r == True): print("estoy en r") verifica = 1 def programa(self): for letras in self.palabra: if (self.transicion_r == False): print("lee " + letras + "\n") self.ejecucion(letras, 0) #print(self.transicion_p) #print(self.transicion_q) #print(self.transicion_r) if (self.transicion_r == True): break #self.i=self.i+1 else: break if (self.pila.elementos[-1] == '#' and self.transicion_r == False and len(self.pila.elementos) == 1): print("toma e") self.ejecucion('e', 0) self.conclusion() def conclusion(self): #print(self.i) #print(len(self.palabra)) if (self.transicion_r == True and self.bandera == True): print("es Palindromo") else: print("no es Palindromo")
def __init__(self): self.pila = Pila() self.operadores = ['-','+','*','/']
import Pila as p print ("\nProbamos el método que hay en el top.") miPila = p.Pila() miPila.vacia() miPila.push(1) miPila.push(2) miPila.push(3) miPila.push(4) miPila.mostrar() miPila.queHayEnTop()
from urllib.request import urlopen def internet_on(): try: conexionServ = os.system("ping -c 1 192.168.1.129") if conexionServ: return False else: return True except: return False p = pila.Pila() payload = { "turno": "M", "boletaje": "0", "encargado": "1", } p.incluir(payload) payload = { "turno": "V", "boletaje": "143", "encargado": "33", } p.incluir(payload)
class Compilador: def __init__(self): self.pila = Pila() self.operadores = ['-','+','*','/'] def posOrden(self,operacion): # Inicializa un nuevo objeto tipo Pila self.pila.__init__() for i in operacion: # Compara con un arreglo de operaciones definido if i in self.operadores: # Tienen que existir por lo menos dos numeros en la pila para una operación if self.pila.get_size() >= 2: a = self.pila.desapilar() b = self.pila.desapilar() if i == '-': self.pila.apilar(b-a) elif i == '+': self.pila.apilar(b+a) elif i == '*': self.pila.apilar(b*a) else: if a != 0: self.pila.apilar(round((b/a),2)) else: return "Error - Division por cero" else: return "Error - Operacion incompleta faltan operandos o valores" # Todo lo que no se una operación lo apila # TODO: Faltaria un elif para comparar si es una variable ej: x,y,z else: try: self.pila.apilar(float(i)) except ValueError: return "Error - Valor no valido: '" + i + "'" # Tiene que existir un unico valor en la pila al finalizar las operaciones if self.pila.get_size() == 1: return self.pila.desapilar() else: return "Error - Valores sin evaluar"
def inicio(): pila = Pila() pila2 = Pila() pila3 = Pila() token = Lex() exp_valor = re.compile('[0-9]+$') exp_operador = re.compile('[\+\*\-/=]{1,1}$') exp_variable = re.compile('([a-z]+)([A-Z0-9_]*)$') print("ingrese vacio para Terminar") while True: m = input("ingreso en post-orden:").split(" ") k = len(m) if (k < 2): break for j in range(0, k): y = m[j] if (token.operador(y)): if (y == "="): while len(pila2.items) != 0: variable = pila2.desapilar() pila3.apilar(variable) print(variable.Nombre, "=", variable.Valor) while len(pila3.items) != 0: variable = pila3.desapilar() pila2.apilar(variable) else: if (len(pila.items) >= 2): der = pila.desapilar() izq = pila.desapilar() nodo = Nodo(y, izq, der) x = evaluar(nodo) pila.apilar(x) else: print("estructura incorrecta") elif (token.valor(y)): y = int(y) pila.apilar(y) elif (token.variable(y)): if (m[j + 1] == "="): variable = Variable(y, pila.desapilar()) pila2.apilar(variable) else: while len(pila2.items) != 0: variable = pila2.desapilar() if (y == variable.Nombre): pila.apilar(variable.Valor) pila3.apilar(variable) while len(pila3.items) != 0: variable = pila3.desapilar() pila2.apilar(variable) else: print("entrada incorrecta para: ", y) print(pila.desapilar()) token.tabla()
class Automata_par: transicion_p = None transicion_q = None transicion_r = None arcos = [] def __init__(self, cadena): self.pila = Pila() self.bandera = False self.i = -1 self.transicion_p = True self.transicion_q = False self.transicion_r = False self.palabra = cadena self.verificar() self.definir() def verificar(self): mitad = int(len(self.palabra) / 2) if (len(self.palabra) % 2 == 0): cad1 = self.palabra[:mitad] cad2 = self.palabra[mitad:] if (cad1 == cad2[::-1]): self.bandera = True def definir(self): arco = Arco('p', 'p', '#', 'a', '#a') self.arcos.append(arco) arco = Arco('p', 'p', '#', 'b', '#b') self.arcos.append(arco) #arco=Arco('p','p','a','a','aa') #self.arcos.append(arco) arco = Arco('p', 'q', 'a', 'a', 'e') self.arcos.append(arco) arco = Arco('p', 'p', 'a', 'b', 'ab') self.arcos.append(arco) arco = Arco('p', 'p', 'b', 'a', 'ba') self.arcos.append(arco) #arco=Arco('p','p','b','b','bb') #self.arcos.append(arco) arco = Arco('p', 'q', 'b', 'b', 'e') self.arcos.append(arco) arco = Arco('q', 'r', '#', 'e', '#') self.arcos.append(arco) arco = Arco('q', 'q', 'a', 'a', 'e') self.arcos.append(arco) arco = Arco('q', 'q', 'b', 'b', 'e') self.arcos.append(arco) def ejecucion(self, caracter_palabra, verifica): if (self.transicion_p == True and verifica == 0): print("estoy en p") verifica = 1 for arco in self.arcos: if (arco.estadoActual() == 'p' and arco.caracterTransicion() == self.pila.elementos[-1] and caracter_palabra == arco.nombreArco()): print(caracter_palabra + "\n") print(self.pila.elementos) self.pila.desapilar() print(self.pila.elementos) self.pila.apilar(arco.caracterApilar()) print(self.pila.elementos) if (arco.estadoSiguiente() == 'q'): self.transicion_p = False self.transicion_q = True self.transicion_r = False break if (self.transicion_q == True and verifica == 0): print("estoy en q") verifica = 1 for arco in self.arcos: if (arco.estadoActual() == 'q' and arco.caracterTransicion() == self.pila.elementos[-1] and caracter_palabra == arco.nombreArco()): print(self.pila.elementos) self.pila.desapilar() print(self.pila.elementos) self.pila.apilar(arco.caracterApilar()) print(self.pila.elementos) if (arco.estadoSiguiente() == 'r'): self.transicion_p = False self.transicion_q = False self.transicion_r = True break if (self.transicion_r == True): print("estoy en r") verifica = 1 def programa(self): for letras in self.palabra: if (self.transicion_r == False): print("lee " + letras + "\n") self.ejecucion(letras, 0) print(self.transicion_p) print(self.transicion_q) print(self.transicion_r) if (self.transicion_r == True): break else: break if (self.pila.elementos[-1] == '#' and self.transicion_r == False and len(self.pila.elementos) == 1): print("toma e") self.ejecucion('e', 0) self.conclusion() def conclusion(self): if (self.transicion_r == True and self.bandera == True): print("es Palindromo") else: print("no es Palindromo")
from Pila import * class Libro: def __init__(self, nombre, cat, autor): self.nombre = nombre self.cat = cat self.autor = autor pila = Pila() pila.apilar(Libro("El Cartero de los Suenos", " Infantil", "Laura Gallego")) pila.apilar(Libro("Un fantasma en apuros", " Infantil", "Laura Gallego")) pila.apilar(Libro("Max ya no hace reir", " Infantil", "Laura Gallego")) pila.apilar(Libro("Donde esta Alba?", " Infantil", "Laura Gallego")) pila.apilar( Libro("Alba tiene una amiga muy especial", " Infantil", "Laura Gallego")) pila.apilar(Libro("Por una rosa", "Relatos", "Laura Gallego")) pila.apilar(Libro("Manana todavia. ", "Relatos", "Laura Gallego")) print("La pila tiene ", pila.tamano(), " libros \n") while pila.es_vacia() == False: Libro = pila.desapilar() print(pila.tamano() + 1, ")", Libro.nombre) print("Categoria: ", Libro.cat) print("Autor: ", Libro.autor) print("\n")
def __init__(self): palo1 = Pila() palo2 = Pila() palo3 = Pila() self.hanoi = [palo1, palo2, palo3]
#!/usr/bin/python # -*- coding: utf-8 -*- import sys from Pila import * class Libro: def __init__(self,nombre,genero,autor): self.nombre=nombre self.genero=genero self.autor=autor pila = Pila() pila.apilar(Libro("El Cartero de los Sueños","cuentos infantiles","Laura Gallego")) pila.apilar(Libro("Un fantasma en apuros","cuentos infantiles","Laura Gallego")) pila.apilar(Libro("Max ya no hace re¡r","cuentos infantiles","Laura Gallego")) pila.apilar(Libro("Donde est Alba?","cuentos infantiles","Laura Gallego")) pila.apilar(Libro("Alba tiene una amiga muy especial","cuentos infantiles","Laura Gallego")) pila.apilar(Libro("Por una rosa","relatos","Laura Gallego")) pila.apilar(Libro("Mañana todavia. ","relatos","Laura Gallego")) pila.apilar(Libro("El viaje del polizón","relatos","Laura Gallego")) pila.apilar(Libro("Relatos insólitos","relatos","Laura Gallego")) pila.apilar(Libro("Relatos de hoy II","relatos","Laura Gallego")) pila.apilar(Libro("Atlántico. 30 historias de los dos mundos","relatos","Laura Gallego")) pila.apilar(Libro("Historias para girar","relatos","Laura Gallego")) pila.apilar(Libro("Topito Terremoto","cuentos ilustrados","Anna Llenas")) pila.apilar(Libro("El Monstruo de Colores","cuentos ilustrados","Anna Llenas")) pila.apilar(Libro("El buit","cuentos ilustrados","Anna Llenas")) pila.apilar(Libro("Diario de las emociones","cuentos ilustrados","Anna Llenas"))
import Cola import Pila cola = Cola.Cola() cola.enqueue("Marcos") cola.enqueue("Ivan") cola.enqueue("Rey") cola.enqueue(19) print "" print "" print cola.peek() print cola.dequeue() print cola.dequeue() print cola.dequeue() print cola.dequeue() print "------------------------" print "" print "" pila = Pila.Pila() pila.push("Marcos") pila.push("Ivan") pila.push("Rey") pila.push(19) print pila.peek() print pila.pop() print pila.pop() print pila.pop() print pila.pop()
def capicua(string) : # RV = False long = len(string) listaDer = [] listaIzq = [] pila = Pila() i = 0 while i < long : pila.apilar(string[i]) i = i + 1 while pila.tope() != "#" : listaDer = listaDer + [pila.tope()] pila.desapilar() # print listaDer pila.desapilar() # desapilo el # while not pila.vacia() : listaIzq = listaIzq + [pila.tope()] pila.desapilar() # print listaIzq reversa(listaDer) # print listaDer RV = (listaIzq == listaDer) # print RV return RV
def inicio(): pila = Pila() pila2 = Pila() pila3 = Pila() print("ingrese vacio para Terminar") while True: m = raw_input("ingreso en post-orden:").split(" ") k = len(m) if m == '': break print("final") if k == 0: break print("final") for j in range(0, k): y = m[j] if (y == "="): while len(pila2.items) != 0: variable = pila2.desapilar() pila3.apilar(variable) print(variable.Nombre, "=", variable.Valor) elif y in ["+", "-", "*", "/"]: if (len(pila.items) >= 2): der = pila.desapilar() izq = pila.desapilar() nodo = Nodo(y, izq, der) x = evaluar(nodo) pila.apilar(x) else: print("estructura incorrecta") else: try: y = int(y) pila.apilar(y) except: if (m[j + 1] == "="): variable = Variable(y, pila.desapilar()) pila2.apilar(variable) print("variable correcta") else: while len(pila2.items) != 0: variable = pila2.desapilar() pila3.apilar(variable) if (y == variable.Nombre): pila.apilar(variable.Valor) while len(pila3.items) != 0: variable = pila3.desapilar() pila2.apilar(variable) print(pila.desapilar())
def procesar(self): text = "Error en los datos ingresados, deben ser 1, 2, 3 o B y no repetirlos" k = 0; C=Pila(); cont = 0; final=[0]*4; pilaf=[0]*4; Found=Pila(); pilaf[0]=str(_fromUtf8(self.lineEdit.text())) pilaf[1]=str(_fromUtf8(self.lineEdit_2.text())) pilaf[2]=str(_fromUtf8(self.lineEdit_3.text())) pilaf[3]=str(_fromUtf8(self.lineEdit_4.text())) for i in range(len(pilaf)): try: pilaf[i]=int(pilaf[i]) except(ValueError,TypeError): if pilaf[i] == 'b' or pilaf[i] == 'B': pilaf[i] = 'B' pass else: QMessageBox.information(self.iface.mainWindow(),"test", "%s" % (text), QMessageBox.Ok) final[0]=str(_fromUtf8(self.lineEdit_5.text())) final[1]=str(_fromUtf8(self.lineEdit_6.text())) final[2]=str(_fromUtf8(self.lineEdit_7.text())) final[3]=str(_fromUtf8(self.lineEdit_8.text())) for i in range(len(final)): try: final[i]=int(final[i]) except(ValueError,TypeError): if final[i] == 'b' or final[i] == 'B': final[i] = 'B' pass else: QMessageBox.information(self.iface.mainWindow(),"test", "%s" % (text), QMessageBox.Ok) C.apilar(pilaf) while(pilaf != final or k < 20): C.desapilar() derecha, sux = Resolv(final, pilaf, 'R') if C.vacia(): C.apilar(derecha) else: for i in range(len(C.items)): if sonListasIguales(C.items[i], derecha) == False: cont += 1 if cont == len(C.items): C.apilar(derecha) cont = 0 izq, sux1 = Resolv(final, pilaf, 'I') if C.vacia(): C.apilar(izq) else: for i in range(len(C.items)): if sonListasIguales(C.items[i], izq) == False: cont += 1 if cont == len(C.items): C.apilar(izq) cont = 0 for i in range(len(pilaf)): pilaf[i] = derecha[i] self.textBrowser.append("%s" % C.items) k += 1