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))
