def cambioOrden(self, inorden): P = pila.Pila() S = pila.Pila() inorden = self.depurador(inorden) #arraglo valores try: for x in range(0, inorden.__len__()): actual = inorden[x] if self.operadores(actual) == 1: #1 para operador if P.isEmpty(): P.add(actual) else: cimaP = P.peek() if self.pref(cimaP) < self.pref(actual): P.add(actual) else: aux = [] cond1 = self.pref(cimaP) >= self.pref(actual) cond2 = not (cimaP == "(") # cond3= not(P.isEmpty()) while (cond1 or cond2): aux.append(P.pop()) cimaP = P.peek() cond1 = self.pref(cimaP) >= self.pref(actual) cond2 = not (cimaP == "(") cond3 = not (P.isEmpty()) P.add(actual) for a in aux: S.add(a) # print actual elif self.operadores(actual) == 2: #2 para ( P.add(actual) elif self.operadores(actual) == 3: #3 para ) while (P.peek() != "("): S.add(P.pop()) P.pop() else: S.add(actual) #print actual # print "-------POSTFIJA-------" pos = "" for x in range(0, S.tama): pos = S.pop() + " " + pos return pos except Exception: print "Error en la EXPRESION ALGEBRAICA" print Exception.message return "(0)"
def reporteGramatical(self): gramatical = PILA.Pila() gramatical = g.reporteGramatical gram = " " gram += "digraph H {\n" gram += "aHtmlTable [\n" gram += "shape=plaintext\n" gram += "label=<\n" gram += "<table border='1' cellborder='1'>\n" gram += "<tr>\n" gram += "<td>Produccion</td>\n" gram += "<td>Derivacion</td>\n" gram += "<td>Regla semantica</td>\n" gram += "</tr>\n" while gramatical.estaVacia() == False: Diccionario = gramatical.pop() gram += "<tr>\n" gram += "<td>" + str(Diccionario['produccion']) + "</td>\n" gram += "<td>" + str(Diccionario['regla']) + "</td>\n" gram += "<td>" + str(Diccionario['semantica']) + "</td>\n" gram += "</tr>\n" gram += "</table>\n" gram += ">];\n" gram += "}\n" f = open("gramatical.dot", "w") f.write(gram) f.close() cmd("dot -Tpng gramatical.dot -o gramatical.png") tab = self.tabWidget.widget(self.tabWidget.currentIndex()) items = tab.children() items[4].append( "***********Se genero el reporte gramatical***************")
def __init__(self): self.lista = [] self.Cola = cola.Cola() self.pila = pila.Pila() self.equis = var("x", 1) self.ye = var("y", 2) self.zeta = var("z", 3)
def reporteErrorSintactico(self): sintactivos = PILA.Pila() sintactivos = g.erroresSintacticos sintac = " " sintac += "digraph H {\n" sintac += "aHtmlTable [\n" sintac += "shape=plaintext\n" sintac += "label=<\n" sintac += "<table border='1' cellborder='1'>\n" sintac += "<tr>\n" sintac += "<td>VALOR</td>\n" sintac += "<td>TIPO</td>\n" sintac += "<td>FILA</td>\n" sintac += "<td>COLUMNA</td>\n" sintac += "</tr>\n" while sintactivos.estaVacia() == False: Diccionario = sintactivos.pop() sintac += "<tr>\n" sintac += "<td>" + str(Diccionario['Error']) + "</td>\n" sintac += "<td>" + str(Diccionario['Tipo']) + "</td>\n" sintac += "<td>" + str(Diccionario['Fila']) + "</td>\n" sintac += "<td>" + str(Diccionario['Columna']) + "</td>\n" sintac += "</tr>\n" sintac += "</table>\n" sintac += ">];\n" sintac += "}\n" f = open("sintacticos.dot", "w") f.write(sintac) f.close() cmd("dot -Tpng sintacticos.dot -o sintactico.png") tab = self.tabWidget.widget(self.tabWidget.currentIndex()) items = tab.children() items[4].append( "***********Se genero el reporte de errores sintacticos***************" )
def __init__(self, palab): self.pila = pila.Pila() self.resultado = [] self.transiciones = [] self.estado_1 = True self.estado_2 = False self.estado_final = False self.palabra = palab
def mostrarNumsIngresados(): indice = int(input("¿Cuantos números desea ingresar?")) pila2 = pila.Pila(indice, int) #Ingreso de datos for i in range(indice): numero = int(input("Ingrese un número:")) pila2.push(numero) #Programa for i in range(indice): pila2.pop() pila2.printStack()
def operar(): ip = str(request.form['ip']) bus = listadoIP.buscar(listadoIP.ipServidor) pre = bus.mensajes.pre() primero = bus.mensajes.pop() if primero == "COLA VACIA": return "false" else: pilita = pila.Pila() cadena = pilita.calcular(primero) + "," + pre + "," + primero return cadena
def crear_svg(destino, sistema, angulo, iteraciones): """ Recibe como parametros el archivo .svg de destino, el sistema de comandos y el angulo de giro. Pre-condiciones: el sistema debe haber sido generada previamente a partir de un axioma y un diccionario de traducciones. Post: Se genera el archivo .svg indicado contiendo las etiquetas xml generadas a partir de dibujar la secuencia de comandos utilizando la clase tortuga. """ unidad = 3 with open(destino, 'w') as f: f.write( f'<svg viewBox="-500 -500 1024 768" xmlns="http://www.w3.org/2000/svg">\n' ) tortuguero = pi.Pila() tortuguero.apilar(t.Tortuga(0, 0, 270, p.Pluma())) dibujar(sistema, tortuguero, unidad, angulo, f) f.write('</svg>\n')
def main(): peliculas = pila.Pila() #Pila de Peliculas en general #Peliculas actualmente almacenadas peliculas.apilar( pelicula.Pelicula("The Avengers", ['accion', 'aventura', 'ciencia ficcion'])) peliculas.apilar( pelicula.Pelicula("Thor: Ragnarok", ['accion', 'aventura', 'comedia'])) peliculas.apilar(pelicula.Pelicula("It (Eso)", ['terror', 'suspenso'])) peliculas.apilar(pelicula.Pelicula("La naranja mecánica", ['drama'])) peliculas.apilar( pelicula.Pelicula("El Padrino", ['drama', 'crimen', 'gangsters'])) #Parametro de busqueda por genero en la Pila de peliculas busqueda = 'drama' print( 'A continuacion se muestran las peliculas que pertenecen al genero: ' + busqueda) myAlmacen = almacen.Almacen(peliculas) myAlmacen.buscar_peliculas_por_genero(busqueda)
else: raise Exception else: raise Exception #Crear discos numero_discos = int(input('Introduce número de discos: ')) array_discos = [] for i in range(numero_discos, 0, -1): array_discos.append(disco.Disco(i)) #Crear torres tor_o = pila.Pila(numero_discos, 'ORIGEN') tor_a = pila.Pila(numero_discos, 'AUXILIAR') tor_d = pila.Pila(numero_discos, 'DESTINO') #Inicialización. Añadir discos a la torre Origen y las demás vacías for i in range(numero_discos): tor_o.push(array_discos[i]) #Lógica del juego printJuego(numero_discos) paso = 0 ult_jugada = '' while (tor_d.getPointer()<numero_discos-1):
import cola import tot import pila x = cola.Cola() y = pila.Pila() z = tot.Lista() from flask import Flask, request, Response app = Flask("EDD_jossie_server") #Ejemplo de una clase, todos los metodos de las clases deben de tener como parametro el "self", que es como el .this en Java class Usuario(): def __init__(self, password, correo, nombre): self.nombre = nombre self.password = password self.correo = correo @app.route('/metodoWeb', methods=['POST']) def hello(): parametro = str(request.form['dato']) dato2 = request.form['dato2'] return "Hola que tal " + str(parametro) + "!" @app.route('/AddCola', methods=['POST']) def AgregarCola(): T = str(request.form['valor']) x.queue(T) x.graficar()
def resolver_indice_valor(expArray, ts): global erroresSemanticos flag = ts.buscar(expArray.id) if flag == True: valorId = ts.obtener(expArray.id).valor cola = PILA.Pila() for expArreglo in expArray.indices: val = resolver_expresion_aritmetica(expArreglo, ts) if val == "cadena": val = resolver_cadena(expArreglo, ts) cola.agregar(val) elif val == "declaracionarray": val = resolver_indice_valor(expArreglo, ts) if val != None: cola.agregar(val) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(expArray.id), 'Descripcion': 'Array o Struct inexistente' } erroresSemanticos.agregar(Diccionario) print("ERROR: Array o Struct no exist") elif val == "asignacionarray": val = resolver_indice_valor(expArreglo, ts) if val != None: cola.agregar(val) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(expArray.id), 'Descripcion': 'Array o Struct inexistente' } erroresSemanticos.agregar(Diccionario) print("ERROR: Array o Struct no exist") else: cola.agregar(val) if type(valorId) == str: valorAux = valorId[cola.pop()] return valorAux else: try: valorAux = valorId.get(cola.pop()) except: Diccionario = { 'Tipo': 'Semantico', 'Error': str(expArray.id), 'Descripcion': 'Indices inexistentes' } erroresSemanticos.agregar(Diccionario) print("Error: estos indices no existen") return None try: while cola.estaVacia() == False: valorAux = valorAux.get(cola.pop()) except: Diccionario = { 'Tipo': 'Semantico', 'Error': str(expArray.id), 'Descripcion': 'Indices inexistentes' } erroresSemanticos.agregar(Diccionario) print("Error: estos indices no existen") valorAux = None return valorAux else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(expArray.id), 'Descripcion': 'Esta arreglo o struct no existe' } erroresSemanticos.agregar(Diccionario) print("Error: Este arreglo o struct no existe")
def procesar_asignacion_array(instr, ts): global erroresSemanticos indices = PILA.Pila() bkindices = PILA.Pila() indicesCopia = [] flag = ts.buscar(instr.id) if flag == True: print("************ ", str(instr.id), " ***************") valorId = ts.obtener(instr.id).valor if isinstance(valorId, str): valorNew = resolver_expresion_aritmetica(instr.expNumerica, ts) ########## GET INDICES for expArray in instr.posicion: if isinstance(expArray, ExpresionArray): print("Expresion Array Indice") val = resolver_indice_valor(instr.expNumerica, ts) if (val != None): indicesCopia.append(val) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(instr.id), 'Descripcion': 'Indices inexistentes' } erroresSemanticos.agregar(Diccionario) print("ERROR: Array o Struct no exist") return elif isinstance(expArray, ExpresionNumerica): val = resolver_expresion_aritmetica(expArray, ts) if val == "cadena": val = resolver_cadena(expArray, ts) indicesCopia.append(val) else: indicesCopia.append(val) if valorNew == "cadena": valorNew = resolver_cadena(instr.expNumerica, ts) if indicesCopia[0] < len(valorId): arregloCadena = list(valorId) arregloCadena[indicesCopia[0]] = str(valorNew) cadena = "".join(arregloCadena) simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, cadena, instr.ambito) ts.actualizar(simbolo) else: arregloCadena = list(valorId) i = 0 while True: if (i == indicesCopia[0]): arregloCadena.append(str(valorNew)) break elif (i >= len(valorId)): arregloCadena.append(" ") i += 1 cadena = "".join(arregloCadena) simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, cadena, instr.ambito) ts.actualizar(simbolo) else: valorNew = resolver_expresion_aritmetica(instr.expNumerica, ts) ########## GET INDICES for expArray in instr.posicion: if isinstance(expArray, ExpresionArray): print("Expresion Array Indice") val = resolver_indice_valor(instr.expNumerica, ts) if (val != None): indices.push(val) bkindices.push(val) indicesCopia.append(val) else: print("ERROR: Array o Struct no exist") Diccionario = { 'Tipo': 'Semantico', 'Error': str(instr.id), 'Descripcion': 'Array o Struct inexistente' } erroresSemanticos.agregar(Diccionario) return elif isinstance(expArray, ExpresionNumerica): val = resolver_expresion_aritmetica(expArray, ts) if val == "cadena": val = resolver_cadena(expArray, ts) indices.push(val) bkindices.push(val) indicesCopia.append(val) else: indices.push(val) bkindices.push(val) indicesCopia.append(val) ########## GET VALOR if (valorNew == "asignacionarray"): print("Expresion Array Valor") val = resolver_indice_valor(instr.expNumerica, ts) if (val != None): valorNew = val else: print("ERROR: Array o Struct no exist") Diccionario = { 'Tipo': 'Semantico', 'Error': str(instr.id), 'Descripcion': 'Array o Struct inexistente' } erroresSemanticos.agregar(Diccionario) return elif (valorNew == "cadena"): valorNew = resolver_cadena(instr.expNumerica, ts) ##################### DICCIONARIO = VALOR valorAux = indices.pop() Diccionario = {valorAux: valorNew} while indices.estaVacia() == False: valorAux = indices.pop() auxDiccionario = {valorAux: Diccionario} Diccionario = auxDiccionario try: valorFinal = update(copy.deepcopy(valorId), Diccionario) simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.STRUCT, valorFinal, instr.ambito) ts.actualizar(simbolo) except: if type(valorId[indicesCopia[ len(indicesCopia) - 2]]) == str and type( indicesCopia[len(indicesCopia) - 1]) == int: if type(valorNew) == str: cadena = valorId[indicesCopia[len(indicesCopia) - 2]] arregloCadena = list(cadena) tamanio = len(arregloCadena) - int( indicesCopia[len(indicesCopia) - 1]) if tamanio >= 0: arregloCadena[indicesCopia[len(indicesCopia) - 1]] = valorNew cadena = "".join(arregloCadena) bkindices.pop() valorAux = bkindices.pop() Diccionario = {valorAux: cadena} while bkindices.estaVacia() == False: valorAux = bkindices.pop() auxDiccionario = {valorAux: Diccionario} Diccionario = auxDiccionario try: #print("Nuevo valor: ",str(Diccionario)) #print("Valor de ts: ",str(valorId)) valorFinal = update(copy.deepcopy(valorId), Diccionario) simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.STRUCT, valorFinal, instr.ambito) ts.actualizar(simbolo) except: Diccionario = { 'Tipo': 'Semantico', 'Error': str(valorNew), 'Descripcion': 'Indice ocupado' } erroresSemanticos.agregar(Diccionario) shell.append( ">> Error Indice ocupado: " + str(valorId) + "\n No se puede ingresar el valor: " + str(valorNew)) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(valorNew), 'Descripcion': 'Indice ocupado' } erroresSemanticos.agregar(Diccionario) shell.append(">> Error Indice ocupado: " + str(valorId) + "\n No se puede ingresar el valor: " + str(valorNew)) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(valorNew), 'Descripcion': 'Indice ocupado' } erroresSemanticos.agregar(Diccionario) shell.append(">> Error Indice ocupado: " + str(valorId) + "\n No se puede ingresar el valor: " + str(valorNew)) else: Diccionario = { 'Tipo': 'Semantico', 'Error': str(valorNew), 'Descripcion': 'Indice ocupado' } erroresSemanticos.agregar(Diccionario) shell.append(">> Error Indice ocupado: " + str(valorId) + "\n No se puede ingresar el valor: " + str(valorNew)) else: procesar_definicion_array(instr, ts) procesar_asignacion_array(instr, ts)
ts_global = TS.TablaDeSimbolos() procesar_instrucciones(instrucciones, 0, ts_global) archivoDot += "Digraph{\n p0[label=\"Main\"];\n" graficar_procesar_instrucciones(instrucciones, 0, ts_global) contadorPadre() archivoDot += "}" crearTS(ts_global) def Main2(input, consola): global archivoDot global idP archivoDot = "" idP = 0 global shell shell = consola instrucciones = g2.parse(input) ts_global = TS.TablaDeSimbolos() procesar_instrucciones2(instrucciones, len(instrucciones) - 1, ts_global) archivoDot += "Digraph{\n p0[label=\"Main\"];\n" graficar_procesar_instrucciones(instrucciones, 0, ts_global) contadorPadre2() archivoDot += "}" crearTS(ts_global) erroresSemanticos = PILA.Pila() shell = None archivoDot = "" id = 0 idP = 0
def __init__(self, info): self.info = info self.pila = pila.Pila() self.siguiente = None
('nonassoc', 'SHIFTI', 'SHIFTD'), ('nonassoc', 'IGUALQ', 'NIGUALQ'), ('nonassoc', 'MENORQ', 'MAYORQ', 'MENORIGUALQ', 'MAYORIGUALQ'), ('nonassoc', 'MAS', 'MENOS'), ('nonassoc', 'POR', 'DIVIDIDO', 'RESIDUO'), ('nonassoc', 'UMENOS'), ) # Definición de la gramática #from prueba import * from expresiones import * from instrucciones import * import pila as PILA ambito = PILA.Pila() ambito.push('main') def p_init(t): 'init : MAIN DOSPUNTOS instrucciones' #instrucciones x cuerpo Diccionario = { 'produccion': 'init', 'regla': 'MAIN DOSPUNTOS instrucciones', 'semantica': 'init.val = instrucciones.val' } reporteGramatical.push(Diccionario) t[0] = t[3] def p_lista_instrucciones(t):
#Ejercicio 6 ''' Escribir una funcion que invierta el orden de una pila. No debe devolver una nueva pila invertida, sino invertir lo valores de la pila que ingresa por parametros. ''' import pila import numpy as np pilaI = pila.Pila(5, int) for i in range(len(pilaI.pila)): pilaI.push(i*2) def invertirPila(pila): vector = np.zeros(shape=(pila.size()), dtype = int) print("Pila:") pila.printStack() for i in range(pila.size()): vector[i] = pila.top() pila.pop() for i in range(len(vector)): pila.push(vector[i]) print("") print("Pila invertida:") pila.printStack()
def __init__(self, cadena): self.cadena = cadena self.pila = pila.Pila() self.expre = cola.Cola()
#Ejercicio 16 ''' Escribir un programa que reciba una pila de enteros y genere dos pilas, una con solo los numeros pares y otra con solo los impares, provenientes de la pila de entrada. ''' import pila pila1 = pila.Pila(5, int) for i in range(5): pila1.push(i) pila2 = pila.Pila(5, int) pila3 = pila.Pila(5, int) def paresImpares(pila): while not pila1.isEmpty(): if pila1.top() % 2 == 0: pila2.push(pila1.pop()) else: pila3.push(pila1.pop())
import csv import libro import pila as pilita pilaLibros = pilita.Pila() pilaEncontrados = pilita.Pila() pilaAuxiliar = pilita.Pila() '''Procedemos a guardar en la pila los objetos de libros con los parametros dados por el archivo''' with open('libros.csv') as csvfile: reader = csv.reader(csvfile) for row in reader: linea = row[0] lineaSeparada = linea.split(";") objetoAux = libro.Libro(lineaSeparada[0], lineaSeparada[2], lineaSeparada[1]) pilaLibros.apilar(objetoAux) linea = "" def buscarAutor(parametro): while pilaLibros.es_vacia != 0: librito = pilaLibros.desapilar() if librito.autor == parametro: pilaEncontrados.apilar(librito) else: pilaAuxiliar.apilar(librito) if pilaLibros.es_vacia(): break def buscarGenero(parametro):
#Ejercicio 4 ''' Escribir un programa que permita incorporar en una pila 10 elementos de tipo persona que contenga nombre, apellido y edad. Pedir por pantalla la cantidad de elementos a desapilar y mostrar los datos correspondientes. ''' import pila import persona pila3 = pila.Pila(10, persona.Persona) def incorporarPersona(pila): for i in range(pila.length()): pila.push(persona.Persona) cantDesapilar = int(input("Ingrese cuantos elementos quiere desapilar:")) for i in range(cantDesapilar): pila.pop() print("Tamaño de pila:", pila3.size())
import Libro as lib import pila as pil pilaEnc = pil.Pila() pilaAux = pil.Pila() pilaCarg = pil.Pila() archivo = open("libros.csv", "r") lista = [(x.split(";")[0], x.split(";")[1], x.strip("\n").split(";")[2]) for x in archivo.readlines()] for x in lista: libro_pro = lib.Libro(x[0], x[1], x[2]) pilaCarg.apilar(libro_pro) def busqueda_titulo(titulo): while pilaCarg.es_vacia() == False: elemento = pilaCarg.desapilar() if elemento.titulo == titulo: pilaEnc.apilar(elemento) else: pilaAux.apilar(elemento) pilaAux == pilaCarg if pilaCarg.es_vacia(): break def busqueda_genero(genero): while pilaCarg.es_vacia() == False: elemento = pilaCarg.desapilar() if elemento.genero == genero:
('nonassoc', 'IGUALQ', 'NIGUALQ'), ('nonassoc', 'MENORQ', 'MAYORQ', 'MENORIGUALQ', 'MAYORIGUALQ'), ('nonassoc', 'MAS', 'MENOS'), ('nonassoc', 'POR', 'DIVIDIDO', 'RESIDUO'), #('nonassoc','UMENOS'), ) # Definición de la gramática #from prueba import * from expresiones import * from instrucciones import * import pila as PILA import subprocess ambito = PILA.Pila() simulador = PILA.Pila() instrucciones = PILA.Pila() ambito.push('main') def p_init(t): 'init : MAIN DOSPUNTOS instrucciones' t[0] = t[3] #print(t[0]) def p_lista_instrucciones(t): 'instrucciones : instruccion instrucciones2' if t[2] == "vacio": t[0] = [t[1]]
#Ejercicio 2 ''' Realizar un programa que muestre la cantidad de elementos de una pila de enteros. Mostrar y desapilar 2 elementos y volver a imprimir el tamaño de la pila. ''' import pila pila1 = pila.Pila(5, int) pila1.push(3) pila1.push(5) def cantidadElementos(pilaEnteros): print(pilaEnteros.size()) pilaEnteros.printStack() print("") for i in range(2): pilaEnteros.pop() print(pilaEnteros.size())
else: S.add(actual) #print actual # print "-------POSTFIJA-------" pos = "" for x in range(0, S.tama): pos = S.pop() + " " + pos return pos except Exception: print "Error en la EXPRESION ALGEBRAICA" print Exception.message return "(0)" if __name__ == '__main__': var = Cola() var.add("((8 / 3) * 7 + (7 * (6 + 1)))") #print str(var.pre()) pilita = pila.Pila() print pilita.calcular(var.pop()) #var.add("15 20 +") #var.add("2 3 5 - *") #var.add("2 8 + 4 * 7 -") #var.add("27 24 - 7 4 + *") #print("tama: "+str(var.tama)) #print(var.pop()) #print("tama: " + str(var.tama))