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