def __init__(self, size): self.pila = Pila() self.pila.push('$') self.pila.push('0') self.columna = 0 self.cantidad = size self.accion = ""
def invertir_Pila(pila_a_invertir): aux_Pila = Pila() while (not pila_a_invertir.pila_vacia()): aux_Pila.apilar(pila_a_invertir.desapilar()) return aux_Pila
def palindromo(cola): piladerecha = Pila() pilaizquierda = Pila() t = cola.tamanio cont = 0 mitad = (t // 2) while (not cola_vacia(cola)): a = atencion(cola) cont += 1 if (t % 2 == 0): if (cont <= mitad): apilar(piladerecha, a) elif (cont >= mitad + 1): apilar(pilaizquierda, a) else: if (cont <= mitad): apilar(piladerecha, a) elif (cont >= mitad + 2): apilar(pilaizquierda, a) print(piladerecha.datos) print(invertirPila(pilaizquierda).datos) if (compararpilas(pilaizquierda, piladerecha) == True): print("La palabra es palindroma.") else: print("La palabra no es palindroma.")
class Semantico(): def __init__(self): self.tmp_index = 0 self.pila = Pila() self.codigo = [] self.archivo = 'codigo.3ac' def gen_temp(self): tmp = "_tmp" + str(self.tmp_index) self.tmp_index += 1 return tmp def push(self, item): self.pila.push(item) def pop(self): return self.pila.pop() def agregar_linea_3ac(self, linea): self.codigo.append(linea) def generar_archivo_3ac(self): with open(self.archivo, 'w') as f: for line in self.codigo: f.write('{}\n'.format(line))
def __init__(self, elemento): """ Inicializa el iterador a partir del nodo parametrizado. """ self.actual = elemento self.anteriores = Pila()
def apilarGenero(cola, genero): pila = Pila() while (cola.es_vacia() != True): pelicula = cola.desencolar() if (pelicula.genero == genero): pila.apilar(pelicula) return pila
def orden_topologico_dfs(grafo): visitados = set() pila = Pila() for v in grafo: if v not in visitados: _orden_topologico_dfs(grafo, v, pila, visitados) return pila.convertir_a_lista()
def dijkstra(self, ver_origen, ver_destino): """Algoritmo de Dijkstra para hallar el camino mas corto.""" no_visitados = HeapMin() camino = Pila() aux = 0 while (aux < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) vertice_aux = self.inicio.obtener_elemento(aux) vertice_aux['anterior'] = None if (vertice_aux['info'] == vertice['info']): no_visitados.arribo([vertice_aux['info'], None], 0) else: no_visitados.arribo([vertice_aux['info'], None], inf) aux += 1 while (not no_visitados.vacio()): dato = no_visitados.atencion() camino.apilar(dato) pos_aux = self.buscar_vertice(dato[1][0]) vertice_aux = self.inicio.obtener_elemento(pos_aux) aristas = 0 while (aristas < vertice_aux['aristas'].tamanio()): arista = vertice_aux['aristas'].obtener_elemento(aristas) pos_heap = no_visitados.busqueda(arista['destino']) if (pos_heap is not None and no_visitados.elementos[pos_heap][0] > dato[0] + arista['peso']): no_visitados.elementos[pos_heap][1][1] = dato[1][0] nuevo_peso = dato[0] + arista['peso'] no_visitados.cambiar_prioridad(pos_heap, nuevo_peso) aristas += 1 # print(no_visitados.elementos) return camino
def ejercicio_24(): Mat = None Vector = None obj_Personajes_Marvel_Pila = Pila() # MCU = [['Black Widow', 'Avengers Confidential', 'Iron Man: Rise of Technovore', 'Avengers: Infinity War'], # ['Iron Man', 'Iron Man I', 'Iron Man II','Avengers Confidential', 'Iron Man: Rise of Technovore', 'The Invincible Iron Man', 'Avengers: Infinity War'], # ['Hulk', 'Avengers Confidential', 'Hulk vs Thor', 'Avengers: Infinity War'], # ['Hawkeye', 'Avengers Confidential'], # ['Thor', 'Hulk vs Thor', 'Avengers: Infinity War'], # ['Groot', 'Infinity War'] # ['Rocket Raccoon', 'Infinity War']] MCU = [['Black Widow', 1, 3, 4, 5, 2, 4], ['Rocket Raccoon', 3, 7], ['Iron Man', 1, 3, 4, 5, 2, 4, 7, 9], ['Hulk', 9, 3, 4, 6], ['Hawkeye', 3], ['Groot', 2], ['Thor', 3, 4, 2, 1]] for i in range(0, len(MCU)): obj_Personajes_Marvel_Pila.apilar(MCU[i]) #A print('\nPosicion de Groot y Rocket en la pila\n') print( get_mensaje_Posicion_De_Groot_And_Rocket( get_Pos_Groot_And_Roket(obj_Personajes_Marvel_Pila))) #B print('\nPersonajes que aparecen en mas de 5 peliculas') Mat = get_Personajes_Que_Aparecen_En_Mas_De_5_Peliculas_And_La_Cantidad( obj_Personajes_Marvel_Pila) if ((len(Mat) - 1) > 0): for i in range(0, (len(Mat) - 1)): print('\nNombre: ', Mat[i][0], '\nTotal Peliculas: ', Mat[i][1]) else: print( '\nNingun personaje de MCU en la pila que aparezca en mas de 5 peliculas' ) #C print('\nCantidad de peliculas en las que aparece Black Widow') print( '\n', get_Mensaje_Black_Widow( get_Cantidad_Peliculas_En_La_Que_Aparece_Black_Widow( obj_Personajes_Marvel_Pila))) #D print('\nPersonajes que empiecen con C, D o G') Vector = get_Nombres_Que_Empiezan_Con_C_D_And_G(obj_Personajes_Marvel_Pila) if ((len(Vector) - 1) > 0): for i in range(0, (len(Vector) - 1)): print('\nNombre: ', Vector[i]) else: print( '\nNo hay personajes de MCU en la pila que empiecen con C, D o G') #-------------------------FIN#-------------------------
def ejercicio_5(): obj_Pila = Pila() palabra = input('Ingrese una palabra: ') for letra in palabra: obj_Pila.apilar(letra) print(es_Palindromo(obj_Pila))
def test_push(self): "Chequea que el elemento pusheado sea efectivamente el tope de la pila" y="2" x=1 pila1=Pila() pila1.push(x) pila1.push(y) self.assertEqual(pila1.body[0],y)
def ejercicio_3(): obj_Pila = Pila() for i in range(0, 100): num = randint(1, 10) obj_Pila.apilar(num) obj_Pila = sacar_Ocurrencias_De_La_Pila(obj_Pila)
def __init__(self): self.constante_entero = [] self.constante_flotante = [] self.constante_str = [] self.apuntador = Pila() self.globales = Memoria() self.main = Memoria() self.alcanceActual = 0 self.funciones = dict()
def __init__(self,size): self.pila = Pila() self.pila.push('$') self.pila.push('0') self.columna = 0 self.cantidad = size self.accion = "" self.list_tmp = list() self.arbol = []
def test_array(self): "Chequea que el array de la pila solo puede tener listas" pila1 = Pila() pila1.body="aaaa" self.assertTrue(type(pila1.body)==list) pila1.body=(1,2,3) self.assertTrue(type(pila1.body)==list) pila1.body=[1,2,3] self.assertTrue(type(pila1.body)==list)
def main(): libros = Pila() for datos in readFile('libros.csv'): libros.apilar(Libro(datos[0], datos[1], datos[2])) print(libros.items) print(len(libros.items)) print(buscar(libros, 'Anna Llenas')) print(len(libros.items))
def __init__(self, lista_enlazada): """ Crea un iterador para una lista enlazada. Pre: recibe una lista enlazada. """ self.lista = lista_enlazada self.anterior = None self.actual = lista_enlazada.prim self.pila_anteriores = Pila() self.posicion = 0
def sacar_Impares_De_Pila(datos_pila): aux_Pila = Pila() while (not datos_pila.pila_vacia()): elemento = datos_pila.desapilar() if (elemento % 2 == 0): aux_Pila.apilar(elemento) return aux_Pila
def ejercicio_1(): obj_pila = Pila() for i in range(0, 100): num = randint(1, 10) obj_pila.apilar(num) numero = int(input('ingrese un numero: ')) print(retornar_Numero_De_Ocurrencias(obj_pila, numero))
def __init__(self, lista_canciones=[]): """ Recibe una lista de objetos de clase Cancion con las canciones que se quieren reproducir.""" lista = ListaEnlazada() for cancion in lista_canciones: lista.insert(cancion) self.lista_canciones = lista self.acciones_tomadas = Pila() self.acciones_deshechas = Pila() self.actual = 0
def invertir(cola): pila1 = Pila() pilaInvertida = Pila() while not (cola_vacia(cola)): a = atencion(cola) apilar(pila1, a) while not (pila_vacia(pila1)): a = desapilar(pila1) apilar(pilaInvertida, a) return pilaInvertida
def generar_lista_partes(): """"No recibe nada. Devuelve una lista de partes random""" partes = {} for tipo_parte in TIPOS_PARTE: pila_tipo_parte = Pila() for _ in range(CANTIDAD_PARTES): parte = Parte(tipo_parte) agregar_armas_parte(parte) pila_tipo_parte.apilar(parte) partes[tipo_parte] = pila_tipo_parte return partes
def movimientos_pista(estado): '''Apila los movimientos de la solucion''' pistas = Pila() try: resuelto, solucion = buscar_solucion(estado) except: return pistas if resuelto: for movimiento in solucion: pistas.apilar(movimiento) return pistas
def generar_lista_armas(): """Devuelve una lista de armas random.""" armas={} tipos_arma=(Arma.MELEE,Arma.RANGO) tipos_municion=(Arma.MUNICION_FISICA,Arma.MUNICION_HADRON,Arma.MUNICION_LASER) for tipo_arma in tipos_arma: pila_tipo_arma=Pila() for _ in range(CANTIDAD_DE_ARMAS): pila_tipo_arma.apilar(Arma(random.choice(CLASES_ARMA),tipo_arma,random.choice(tipos_municion))) armas[tipo_arma]=pila_tipo_arma return armas
def __init__(self, estadoInicial, estadoAceptacion, simboloInicial): self.estadoInicial = estadoInicial self.estadoFinal = estadoAceptacion self.edges = None self.pila = Pila() self.pilas = [] self.proceso = [] # 1 para meter, 0 para sacar if simboloInicial != None: self.pila.apilar(simboloInicial) self.proceso.append([simboloInicial, 1, "", ""]) print(self.pila.verTope())
def sacar_Ocurrencias_De_La_Pila(datos_pila): aux_Pila = Pila() aux_Conjunto = list() while (not datos_pila.pila_vacia()): elemento = datos_pila.desapilar() if (not (elemento in aux_Pila)): aux_Conjunto.append(elemento) aux_Pila.apilar(elemento) return aux_Pila
def cfc(grafo): visitados = set() orden = {} p = Pila() s = Pila() cfcs = [] en_cfs = set() for v in grafo: if v not in visitados: orden[v] = 0 dfs_cfc(grafo, v, visitados, orden, p, s, cfcs, en_cfs) return cfcs
def calculadora_polaca(elementos): """ Dada una lista de elementos que representan las componentes de una expresion en notacion polaca inversa, evalua dicha expresion. Si la expresion esta mal formada, levanta ValueError """ p = Pila() for elemento in elementos: print(f"\nDEBUG: entra {elemento}") # Intenta convertirlo a numero try: numero = float(elemento) p.apilar(numero) print(f"DEBUG: apila {numero}") # si no se puede convertir, deberia ser un operando except ValueError: if elemento not in ('+', '-', '/', '*'): raise ValueError("Operando inválido") # Si es un operando válido, intenta desapilar y operar try: a1 = p.desapilar() print(f"\nDEBUG: desapila {a1}") a2 = p.desapilar() print(f"\nDEBUG: desapila {a2}") except IndexError: raise ValueError("Faltan operandos..") if elemento == "+": resultado = a2 + a1 if elemento == "-": resultado = a2 - a1 if elemento == "/": resultado = a2 / a1 if elemento == "*": resultado = a2 * a1 print(f"\nDEBUG: apila {resultado}") p.apilar(resultado) # Al final el resultado debe ser lo unico en la pila resultado = p.desapilar() if not p.esta_vacia(): raise ValueError("Sobran operandos") return resultado
def es_Palindromo(palabra_pila): pila_Inversa = Pila() pila_Inversa = invertir_Pila_Sin_Perder_Elementos(palabra_pila) while ((not palabra_pila.pila_vacia()) and (palabra_pila.elemento_cima() == pila_Inversa.elemento_cima())): palabra_pila.desapilar() pila_Inversa.desapilar() if (palabra_pila.pila_vacia()): return True else: return False
def invertir_Pila_Sin_Perder_Elementos(pila_a_invertir): pila_Inversa = Pila() aux_Pila = Pila() #me da la pila invertida while (not pila_a_invertir.pila_vacia()): elemento = pila_a_invertir.desapilar() pila_Inversa.apilar(elemento) aux_Pila.apilar(elemento) #le devuelvo los elementos que desapile a la pila original while (not aux_Pila.pila_vacia()): pila_a_invertir.apilar(aux_Pila.desapilar()) return pila_Inversa
def orden_topologico(grafo): """Devuelve una lista con el orden topologico con el que se debe recorrer el grafo pasado por parametro. En caso de no existir devuelve None.""" if not grafo: return None visitados = set() pila = Pila() for vertice in grafo.obtener_vertices(): if vertice not in visitados: orden_topologico_dfs(grafo, vertice, pila, visitados) return pila.pila_a_lista()
def __init__(self): self.temp_booleano = 4000 self.temp_entero = 5000 self.temp_flotante = 6000 self.temp_dir = 7000 self.Bloque = 0 self.OPila = Pila() self.TPila = Pila() self.OpPila = Pila() self.salto = Pila() self.numCuad = 0 self.funcCuad = 0 self.cuad = [] self.DPila = Pila() self.IDPila = Pila() self.alcanceF = Pila() self.alcance = '' self.RT = '' self.cubo_semantico = { '=': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'error', 'flotante': 'flotante' } }, '>': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '<': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '>=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '<=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '!=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '==': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '+': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '-': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '*': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '/': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '$': { 'dir': { '-1': 'dir' } } }
class avail: cubo_semantico = None def __init__(self): self.temp_booleano = 4000 self.temp_entero = 5000 self.temp_flotante = 6000 self.temp_dir = 7000 self.Bloque = 0 self.OPila = Pila() self.TPila = Pila() self.OpPila = Pila() self.salto = Pila() self.numCuad = 0 self.funcCuad = 0 self.cuad = [] self.DPila = Pila() self.IDPila = Pila() self.alcanceF = Pila() self.alcance = '' self.RT = '' self.cubo_semantico = { '=': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'error', 'flotante': 'flotante' } }, '>': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '<': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '>=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '<=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '!=': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '==': { 'entero': { 'entero': 'bool', 'flotante': 'bool' }, 'flotante': { 'entero': 'bool', 'flotante': 'bool' } }, '+': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '-': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '*': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '/': { 'entero': { 'entero': 'entero', 'flotante': 'flotante' }, 'flotante': { 'entero': 'flotante', 'flotante': 'flotante' } }, '$': { 'dir': { '-1': 'dir' } } } #regresa el tipo de la operacion def get_tipo(self, argOper, uno, dos): esperado = self.cubo_semantico.get(argOper) if esperado != None: esperado = esperado.get(uno) if esperado != None: esperado = esperado.get(dos) return esperado print 'error' #se crea un nuevo valor temporal en base al resultado del cubo semantico def get_temporal(self, argOper, uno, dos): tempoTipo = self.get_tipo(argOper, uno, dos) if tempoTipo == 'entero': res = self.temp_entero self.temp_entero += 1 elif tempoTipo == 'flotante': res = self.temp_flotante self.temp_flotante += 1 elif tempoTipo == 'bool': res = self.temp_booleano self.temp_booleano += 1 elif uno == 'dir': res = self.temp_dir self.temp_dir += 1 res += (self.Bloque * 10000) return [res, self.get_tipo(argOper, uno, dos)] #regresa el bloque actual def getBloque(self): return self.Bloque #resetea la memoria para el siguiente bloque def setBloque(self, Bloque): self.Bloque = Bloque self.temp_booleano = 4000 self.temp_entero = 5000 self.temp_flotante = 6000 self.temp_dir = 7000 #regresa la memoria necesaria para las temporales def get_temporal_dirs(self): return [(self.temp_booleano-4000), (self.temp_entero-5000), (self.temp_flotante-6000), (self.temp_dir-7000)] #si hay una expresion para resolver def expresion(self): if(self.OpPila.size() > 0): if(self.OpPila.peek() == '>' or self.OpPila.peek() == '<' or self.OpPila.peek() == '!=' or self.OpPila.peek() == '==' or self.OpPila.peek() == '<=' or self.OpPila.peek() == '>='): self.quad() #si hay una operacion se suma o resta def sum_res(self): if(self.OpPila.size() > 0): if(self.OpPila.peek() == '+' or self.OpPila.peek() == '-'): self.quad() #si hay una operacion de multiplicacion o division def mult_div(self): if(self.OpPila.size() > 0): if(self.OpPila.peek() == '*' or self.OpPila.peek() == '/'): self.quad() #crea una asignacion def asign(self, dato): if(self.OPila.size() > 0): self.numCuad += 1 cuads = [101, self.OPila.pop(), -1, dato] self.cuad.append(cuads) #saca uno de los valores de la temporal def rep_salto(self, primDir, dirInic): valT = self.OPila.pop() cuads = ['-', valT, primDir, valT] self.numCuad += 1 self.cuad.append(cuads) salto = self.salto.pop() aux = self.get_temporal('==', self.TPila.pop(), 'entero') cuads = ['==', valT, dirInic, aux[0]] self.numCuad += 1 self.cuad.append(cuads) cuads = ['GOTOF', aux[0], -1, salto] self.numCuad += 1 self.cuad.append(cuads) #al inicio de una condicion se crea un gotof y se almacena el num de cuadruplo en la pila de saltos def condicion(self): estCondic = self.OPila.pop() tipoCondicion = self.TPila.pop() if(tipoCondicion != "bool"): print "Error, el tipo no coincide" sys.error(0) else: cuads = ['GOTOF', estCondic, -1, -1] self.cuad.append(cuads) self.numCuad += 1 self.salto.push(self.numCuad) #al final de una condicion llena el ultimo goto que fue creado con el cuadruplo actual def condicion_inicio(self): if(self.salto.size() > 0): salto = self.salto.pop() - 1 cuads = self.cuad[salto] cuads[3] = self.numCuad self.cuad[salto] = cuads #si hay un else, se debe llenar el goto del if y crear un nuevo goto def condition_else(self): salto = self.salto.pop() -1 cuads = self.cuad[salto] cuads[3] = self.numCuad +1 self.cuad[salto] = cuads cuads = ['GOTO', -1, -1, -1] self.cuad.append(cuads) self.numCuad += 1 self.salto.push(self.numCuad) #revisa si la funcion regreso, si no crea un cuadruplo en la pila de operadores def funcion_return(self, vacio, valDireccion): if(vacio): cuads = ['RETURN',-1, -1, -1] self.numCuad += 1 self.cuad.append(cuads) return False else: cuads = ['RETURN', self.OPila.pop(), -1, valDireccion] self.numCuad += 1 self.cuad.append(cuads) return True #final del cuadruplo def function_end(self): cuads = ['ENDPROC', 1, -1, 1] self.numCuad += 1 self.cuad.append(cuads) #checa los parametros de las funciones de acuerdo al orden def function_param(self, varParametro): numParams = len(varParametro) if self.OPila.size() < numParams: print "Faltan paramentros de la funcion" sys.exit(0) lista = [] numParams = len(varParametro) -1 while numParams >= 0: for key in varParametro: if numParams == varParametro[key][1]: cuads = ['PARAMETRO', self.OPila.pop(), -1, varParametro[key][2]] print cuads numParams -= 1 self.numCuad += 1 self.cuad.append(cuads) #cuadruplo que contiene el nombre de la funcion la cual se esta llamando def llama_funcion(self, param): cuads = ['ERA', -1, -1, param] self.numCuad += 1 self.cuad.append(cuads) self.OpPila.push('(') #se hace un go sub a la funcion de la gual se hizo el go, se hace una asignacion en caso de que se regrese un valor en una temporal def llama_funcion_final(self,param, valDire, valTempo): cuads = ['GOSUB', -1, -1, param] self.numCuad += 1 self.cuad.append(cuads) cuads = ['101', valDire, -1, valTempo] self.OPila.push(valTempo) self.numCuad += 1 self.cuad.append(cuads) self.OpPila.pop() #crea una copia del numero que representa las veces que el bloque fue creado, y almacena el valor en la pila def rep(self): aux = self.get_temporal('-', self.TPila.peek(), self.TPila.pop()) valT = aux[0] cuads = [101, self.OPila.pop(), -1, valT] self.numCuad += 1 self.cuad.append(cuads) self.salto.push(self.numCuad) self.OPila.push(valT) self.TPila.push(aux[1]) #para los arreglos, crea un cuad que checa que el valor ente en el rango def dim(self, tamDim, vapunta): cuads = ['DIM', tamDim, vapunta, -1] self.numCuad += 1 self.cuad.append(cuads) self.numCuad += 1 aux = self.get_temporal('$', 'dir', -1) valT = aux[0] cuads = ['DIR', self.OPila.pop(), vapunta, valT] self.cuad.append(cuads) self.OPila.push(valT) #para las matrices, pointer representa las filas def dmT(self, tamDim, vapunta): aux = self.get_temporal('+', 'entero', 'entero') valT = aux[0] cuads = ['*', vapunta, '40002', valT] self.cuad.append(cuads) vapunta = valT cuads = ['DIM', tamDim, vapunta, -1] self.cuad.append(cuads) aux = self.get_temporal('$', 'dir', -1) valT = aux[0] saleRes = self.OPila.pop() cuads = ['DIR', saleRes, vapunta, valT] uno = valT self.cuad.append(cuads) aux = self.get_temporal('+', 'entero', 'entero') valT = aux[0] cuads = ['+', vapunta, '40000', valT] self.cuad.append(cuads) self.OPila.push(valT) aux = self.get_temporal('$', 'dir', -1) valT = aux[0] cuads = ['DIR', saleRes, self.OPila.pop(), valT] self.cuad.append(cuads) tempo = self.OPila.pop() self.OPila.push(valT) self.OPila.push(tempo) self.OPila.push(uno) self.numCuad += 4 #al inicializar una matriz, revisa la dimension, crea un apuntador para que asigne algo al siguiente valor def dmTP(self, valDire, casilla, valTam): casilla *= 2 cuads = ['DIMC', valTam, casilla, -1] self.cuad.append(cuads) aux = self.get_temporal('$', 'dir', -1) valT = aux[0] cuads = ['DIRC', valDire, (casilla+1), valT] self.cuad.append(cuads) self.asign(valT) aux = self.get_temporal('$', 'dir', -1) valT = aux[0] cuads = ['DIRC', valDire, casilla, valT] self.cuad.append(cuads) self.asign(valT) self.numCuad += 3 #checa la dimension, obtiene la direccion del puntero, cuad que genera la direccion actual def dmP(self, valDire, casilla, valTam): cuads = ['DIMC', valTam, casilla, -1] self.cuad.append(cuads) aux = self.get_temporal('$', 'dir', -1) valT = aux[0] cuads = ['DIRC', valDire, casilla, valT] self.cuad.append(cuads) self.asign(valT) self.numCuad += 2 #crea el goto al main, gurda el numero de cuadruplo en la pila de saltos def princ(self): cuads = ['GOTO', -1, -1, -1] self.cuad.append(cuads) self.salto.push(self.numCuad) self.numCuad += 1 #hace el goto al programa principal def princ_goto(self): salto = self.salto.pop() cuads = self.cuad[salto] cuads[3] = self.numCuad self.cuad[salto] = cuads #concatena los cuadruplos def append_quad(self, cuadruplo): self.numCuad += 1 self.cuad.append(cuadruplo) #usado por las funciones que solo tienen un parametro def append_quad_uno(self, unoFuncion): self.numCuad += 1 cuads = [unoFuncion, self.OPila.pop(), -1, -1] self.TPila.pop() self.cuad.append(cuads) #usado por funciones que tienen dos parametros def append_quad_dos(self, dosFuncion): self.numCuad += 1 dosParam = self.OPila.pop() self.TPila.pop() cuads = [dosFuncion, self.OPila.pop(),dosParam, -1] self.TPila.pop() self.cuad.append(cuads) #usado por funciones con tres parametros def append_quad_tres(self, tresFuncion): self.numCuad += 1 uno = self.OPila.pop() self.TPila.pop() dos = self.OPila.pop() self.TPila.pop() cuads = [tresFuncion, self.OPila.pop(), dos, uno] self.TPila.pop() self.cuad.append(cuads) #usado por la funcion del triangulo def append_quad_tri(self, triaFuncion): self.numCuad += 2 y3 = self.OPila.pop() self.TPila.pop() x3 = self.OPila.pop() self.TPila.pop() y2 = self.OPila.pop() self.TPila.pop() x2 = self.OPila.pop() self.TPila.pop() y = self.OPila.pop() self.TPila.pop() x = self.OPila.pop() self.TPila.pop() spQuad = [triaFuncion, x, y, -1] self.cuad.append(spQuad) spQuad = [x2, y2, x3, y3] self.cuad.append(spQuad) #lo utilizan las expresiones para crear cuadruplos def quad(self): self.numCuad += 1 aux = self.get_temporal(self.OpPila.peek(), self.TPila.pop(), self.TPila.pop()) valT = aux[0] operando2 = self.OPila.pop() cuads = [self.OpPila.pop(), self.OPila.pop(), operando2, valT] self.cuad.append(cuads) self.OPila.push(valT) self.TPila.push(aux[1]) #imprime info def printS(self): print self.OPila.printi() #crea un apuntador a una direccion def get_temporal_point(self): aux = self.get_temporal('$', 'dir', -1) return aux[0] def OpPila_pop(self): self.OpPila.pop() def OpPila_push(self, op): self.OpPila.push(op) def TPila_push(self, op): self.TPila.push(op) def TPila_pop(self, ): self.TPila.pop() def OPila_push(self, op): self.OPila.push(op) def OPila_pop(self): return self.OPila.pop() def OPila_peek(self): return self.OPila.peek() def DPila_push(self, op): self.DPila.push(op) def DPila_pop(self): return self.DPila.pop() def IDPila_push(self, op): self.IDPila.push(op) def IDPila_pop(self): return self.IDPila.pop() def print_cuad(self): print self.cuad def get_cuad(self): return self.cuad def setalcance(self, alcance): self.alcance = alcance def getalcance(self): return self.alcance def setFuncalcance(self, alcance): self.alcanceF.push(alcance) def delFuncalcance(self): self.alcanceF.pop() def getFuncalcance(self): return self.alcanceF.peek() def setRT(self, RT): self.RT = RT def getRT(self): return self.RT def setfuncCuad(self): self.funcCuad = self.numCuad def getfuncCuad(self): return self.funcCuad
class ColaDeReproduccion: """Clase que representa la cola de reproduccion del reproductor. Permite agregar y remover canciones, ademas de poder hacer y deshacer estas acciones. Las canciones se guardan en la cola como objetos de clase Cancion.""" AGREGADA = 1 REMOVIDA = 0 def __init__(self, lista_canciones=[]): """ Recibe una lista de objetos de clase Cancion con las canciones que se quieren reproducir.""" lista = ListaEnlazada() for cancion in lista_canciones: lista.insert(cancion) self.lista_canciones = lista self.acciones_tomadas = Pila() self.acciones_deshechas = Pila() self.actual = 0 def cancion_actual(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion actual, o None si no hay canciones cargadas en la cola.""" if self.lista_canciones.esta_vacia(): return None try: cancion = self.lista_canciones.get_elemento(self.actual) except IndexError: return return cancion def cancion_siguiente(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion siguiente en la cola, o None si no hay mas canciones.""" if len(self.lista_canciones) < 1: return None try: cancion = self.lista_canciones.get_elemento(self.actual + 1) self.actual += 1 except IndexError: return return cancion def cancion_anterior(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion anterior en la cola, o None si no hay canciones en la misma o la actual es la primera de la cola.""" if len(self.lista_canciones) < 1: return None try: cancion = self.lista_canciones.get_elemento(self.actual - 1) self.actual -= 1 except IndexError: #No hay cancion anterior return return cancion def agregar_cancion(self, ruta_cancion): """ Agrega una Cancion a la cola a partir de su ruta. Devuelve True si se agrego correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse.""" try: self.agregar_cancion_sin_guardar(ruta_cancion) self.guardar_accion(ruta_cancion, self.AGREGADA) return True except (TinyTagException, LookupError, OSError): return False def remover_cancion(self, ruta_cancion): """ Remueve una Cancion de la cola a partir de su ruta. Devuelve True si se removio correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse.""" try: resultado = self.remover_cancion_sin_guardar(ruta_cancion) self.guardar_accion(ruta_cancion, self.REMOVIDA) return resultado except (TinyTagException, LookupError, OSError): return False def deshacer_modificacion(self): """ Deshace la ultima accion realizada. Devuelve True si pudo deshacerse, False en caso contrario.""" try: ruta_ultima_cancion, ultima_accion = self.acciones_tomadas.desapilar() if ultima_accion == self.AGREGADA: self.remover_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_deshechas.apilar((ruta_ultima_cancion, self.AGREGADA)) return True self.agregar_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_deshechas.apilar((ruta_ultima_cancion, self.REMOVIDA)) return True except (ValueError, IndexError): return False def rehacer_modificacion(self): """ Rehace la ultima accion que se deshizo. Devuelve True si pudo rehacerse, False en caso contrario.""" try: ruta_ultima_cancion, ultima_accion = self.acciones_deshechas.desapilar() if ultima_accion == self.AGREGADA: self.agregar_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_tomadas.apilar((ruta_ultima_cancion, self.AGREGADA)) return True self.remover_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_tomadas.apilar((ruta_ultima_cancion, self.REMOVIDA)) return True except (ValueError, IndexError): return False def obtener_n_siguientes(self, n_canciones): """ Devuelve una lista con las siguientes n canciones. Si en la cola de reproduccion quedan menos canciones que las pedidas, la lista contendra menos elementos que los pedidos.""" if self.lista_canciones.esta_vacia(): return None lista = [] for i in range(n_canciones): try: lista.append(self.lista_canciones.get_elemento(self.actual + 1 + i)) except IndexError: return lista return lista def __str__(self): return str(self.lista_canciones) def guardar_accion(self, ruta_cancion, accion): """Guarda la accion como una tupla (ruta_cancion, accion).""" self.acciones_tomadas.apilar((ruta_cancion, accion)) def agregar_cancion_sin_guardar(self, ruta_cancion): """Agrega la cancion a la lista de reproduccion.""" cancion = Cancion(ruta_cancion) self.lista_canciones.insert(cancion) def remover_cancion_sin_guardar(self, ruta_cancion): """Remueve la cancion de la lista de reproduccion. Devuelve True en caso que sea exitoso y False en caso contrario.""" cancion = Cancion(ruta_cancion) posicion = self.lista_canciones.index(cancion) if posicion: self.lista_canciones.pop(posicion) return True return False
class AdminMemoria: def __init__(self): self.constante_entero = [] self.constante_flotante = [] self.constante_str = [] self.apuntador = Pila() self.globales = Memoria() self.main = Memoria() self.alcanceActual = 0 self.funciones = dict() def constTamano(self, sizeE, sizeF, sizeS): #modifica la memoria necesaria por las constantes self.constante_entero = [0] * sizeE self.constante_flotante = [0.0] * sizeF self.constante_str = [0] * sizeS def setMemoriaPrinc(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP): #modifica la memoria del main self.main.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP)) def setMemoriaGlobales(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP): #modifica la memoria de las globales self.globales.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP)) def setFunciones(self, strP, enteroP, floatP, boolP, enteroPT, floatPT, pointerP): #crea memoria para la nueva funcion, modifica la memoria y la agrega al diccionario de funciones funcion = Memoria() funcion.setMemoria(int(strP), int(enteroP), int(floatP), int(boolP), int(enteroPT), int(floatPT), int(pointerP)) self.funciones[self.alcanceActual+1] = funcion def cambiaAlcance(self): #cambia el alcance actual al siguiente self.alcanceActual += 1 def borrar_funcion(self): #destruye la memoria asignada para la funcion y regresa al alcance anterior self.funciones[self.alcanceActual].dejarMemoria() del self.funciones[self.alcanceActual] self.alcanceActual -= 1 def escribeValor(self, dirV, valor): #escribe el valor de la direccion dada, si la direccion es un apuntador primero recupera la direccion real if dirV[1] == '7': dirV = int(dirV) if((dirV-10000) < 10000): #valores globales dirV = self.globales.leerValor(dirV-10000) elif((dirV-20000) < 10000): #valores del main dirV = self.main.leerValor(dirV-20000) elif((dirV-30000) < 10000): #valores de funciones dirV = self.funciones[self.alcanceActual].leerValor(dirV-30000) dirV = str(dirV) dirV = int(dirV) #imprime la direccion, dirV if((dirV-10000) < 10000): #valores globales dirV = dirV-10000 self.globales.escribeValor(dirV, valor) return if((dirV-20000) < 10000): #valores del main dirV = dirV-20000 self.main.escribeValor(dirV, valor) return if((dirV-30000) < 10000): #valores de funciones dirV = dirV-30000 self.funciones[self.alcanceActual].escribeValor(dirV, valor) return if((dirV-40000) < 10000): #constantes dirV = dirV-40000 if(dirV < 1000): self.constante_entero[dirV] = int(valor) elif(dirV < 2000): self.constante_flotante[dirV-1000] = float(valor) else: self.constante_str[dirV-2000] = str(valor) return def escribeValorS(self, dirV, valor): #escribe valores que solo son usados como por patamentros if dirV[1] == '7': dirV = int(dirV) if((dirV-10000) < 10000): #valores globales dirV = self.globales.leerValor(dirV-10000) elif((dirV-20000) < 10000): #valores del main dirV = self.main.leerValor(dirV-20000) elif((dirV-30000) < 10000): #valores de funciones dirV = self.funciones[self.alcanceActual+1].leerValor(dirV-30000) dirV = str(dirV) dirV = int(dirV) #imprime la direccion, dirV if((dirV-10000) < 10000): #valores globales dirV = dirV-10000 self.globales.escribeValor(dirV, valor) return if((dirV-20000) < 10000): #valores del main dirV = dirV-20000 self.main.escribeValor(dirV, valor) return if((dirV-30000) < 10000): #valores de funciones dirV = dirV-30000 self.funciones[self.alcanceActual+1].escribeValor(dirV, valor) return def getValor(self, dirV): #recupera el valor de la direccion dada, en caso de que sea un apuntador primero obtiene la direccion real if dirV[1] == '7': # si la diereccion es un apuntador se recuperar la direccion actual dirV = int(dirV) if((dirV-10000) < 10000): #valores globales dirV = self.globales.leerValor(dirV-10000) elif((dirV-20000) < 10000): #valores del main dirV = self.main.leerValor(dirV-20000) elif((dirV-30000) < 10000): #valores de funciones dirV = self.funciones[self.alcanceActual].leerValor(dirV-30000) dirV = str(dirV) dirV = int(dirV) #imprime la direccion, dirV if((dirV-10000) < 10000): #valores globales dirV = dirV-10000 return self.globales.leerValor(dirV) if((dirV-20000) < 10000): #valores del main dirV = dirV-20000 return self.main.leerValor(dirV) if((dirV-30000) < 10000): #valores de funciones dirV = dirV-30000 return self.funciones[self.alcanceActual].leerValor(dirV) if((dirV-40000) < 10000): #constantes dirV = dirV-40000 if(dirV < 1000): return int(self.constante_entero[dirV]) elif(dirV < 2000): return float(self.constante_flotante[dirV-1000]) else: return str(self.constante_str[dirV-2000]) def escribeValorApuntado(self, dirV, valor, alcance): #para almacenar el valor en un apuntador dirV = int(dirV) if((dirV-10000) < 10000): #valores globales dirV = dirV-10000 self.globales.escribeValor(dirV, valor) return if((dirV-20000) < 10000): #valores del main dirV = dirV-20000 self.main.escribeValor(dirV, valor) return if((dirV-30000) < 10000): #valores de funciones dirV = dirV-30000 self.funciones[self.alcanceActual+alcance].escribeValor(dirV, valor) return def getValorApuntado(self, dirV): #para leer el valor de un apuntador dirV = int(dirV) if((dirV-10000) < 10000): #valores globales dirV = dirV-10000 return self.globales.leerValor(dirV) if((dirV-20000) < 10000): #valores del main dirV = dirV-20000 return self.main.leerValor(dirV) if((dirV-30000) < 10000): #valores de funciones dirV = dirV-30000 return self.funciones[self.alcanceActual].leerValor(dirV) def imprimeFunciones(self): print self.alcanceActual def imprimePrinc(self): self.main.imprimeInfo() def imprimeGlobales(self): self.globales.imprimeInfo() def imprimeConstantes(self): print self.constante_entero, " ", self.constante_flotante def push_apuntador(self, valor): self.apuntador.push(valor) def pop_apuntador(self): return self.apuntador.pop()
def setUp(self): self.pila = Pila() self.d1 = 'dummy1' self.d2 = 'dummy2' self.d3 = 'dummy3' self.d4 = 'dummy4'
class TestPila(unittest.TestCase): def setUp(self): self.pila = Pila() self.d1 = 'dummy1' self.d2 = 'dummy2' self.d3 = 'dummy3' self.d4 = 'dummy4' def test_inicio(self): self.assertIsInstance(self.pila._datos, ListaConPyLista) def test_poner(self): self.pila.poner(self.d1) expected = str([self.d1]) self.assertEqual(expected, str(self.pila)) self.pila.poner(self.d2) expected = str([self.d1, self.d2]) self.assertEqual(expected, str(self.pila)) self.pila.poner(self.d3) expected = str([self.d1, self.d2, self.d3]) self.assertEqual(expected, str(self.pila)) self.pila.poner(self.d4) expected = str([self.d1, self.d2, self.d3, self.d4]) self.assertEqual(expected, str(self.pila)) def test_sacar(self): self.pila.poner(self.d1) self.pila.poner(self.d2) self.pila.poner(self.d3) self.pila.poner(self.d4) self.assertEqual(self.d4, self.pila.sacar()) self.assertEqual(self.d3, self.pila.sacar()) self.assertEqual(self.d2, self.pila.sacar()) self.assertEqual(self.d1, self.pila.sacar()) self.assertRaises(IndexError, self.pila.sacar) def test_tope(self): self.pila.poner(self.d1) self.assertEqual(self.d1, self.pila.tope()) self.pila.poner(self.d2) self.assertEqual(self.d2, self.pila.tope()) self.pila.poner(self.d3) self.assertEqual(self.d3, self.pila.tope()) self.pila.poner(self.d4) self.assertEqual(self.d4, self.pila.tope()) def test_EsVacia_si(self): self.assertTrue(self.pila.esVacia()) self.pila.poner(self.d1) elem = self.pila.sacar() self.assertTrue(self.pila.esVacia()) def test_EsVacia_no(self): self.pila.poner(self.d1) self.assertFalse(self.pila.esVacia()) self.pila.poner(self.d2) self.assertFalse(self.pila.esVacia()) elem = self.pila.sacar() self.assertFalse(self.pila.esVacia())
def __init__(self, s=""): self.__tokens = Pila() self.__string = s + " " self.__busqueda = -1 self.__actual = 0
class Lexico(): def __init__(self, s=""): self.__tokens = Pila() self.__string = s + " " self.__busqueda = -1 self.__actual = 0 def getTokens(self): return self.__tokens def dame(self): self.__busqueda += 1 if self.__busqueda >= len(self.__string): return "" else: return self.__string [self.__busqueda] def falla(self): self.__busqueda = self.__actual - 1 def retraer(self): self.__busqueda -= 1 def aceptar(self): self.__actual = self.__busqueda + 1 def getValor(self): return self.__string[self.__actual:self.__busqueda] def instalar(self, tipo, valor): tkn = {} tkn["type"] = tipo tkn["value"] = valor if tipo == "ID": if valor == "V" or valor == "F": tkn["type"] = "Logico" elif valor == "EVAL" or valor == "SI" or valor == "MIENTRAS"\ or valor == "IMPRIMIR" or valor == "LEER": tkn["type"] = "Res" self.__tokens.push(tkn) def esLetra(self, x): return "a" <= x <= "z" or "A" <= x <= "Z" or x == "_" def esDigito(self, x): return "0" <= x <= "9" def esOperadorMatematico(self, x): return x in ['+', '-', '*', '/', '%','=', '!', '>', '<', '|', '&'] def esEspacio(self, x): return x in [" ", "\n"] def esSigno(self, x): return x in ['+', '-'] def esDesconocido(self, x): return not (self.esDigito(x) or self.esOperadorMatematico(x) or \ self.esEspacio(x) or x == "" or self.esLetra(x) or self.esSigno(x) \ or x ==":" or x == ";") def analizar(self): while self.__actual < len(self.__string): c = self.dame() if c == ":": cont = True b = 1 while cont: c = self.dame() if c == ":": b += 1 elif c == ";": b -= 1 if b == 0: cont = False self.dame() self.instalar("Bloque", self.getValor()) self.retraer() self.aceptar() else: self.falla() c = self.dame() if self.esDigito(c) or self.esSigno(c): if self.esSigno(c): c = self.dame() if self.esDigito(c): while self.esDigito(c): c = self.dame() if c == ".": c = self.dame() if self.esDigito(c): while self.esDigito(c): c = self.dame() self.instalar("Flotante", float(self.getValor())) self.retraer() self.aceptar() else: self.instalar("Entero", int(self.getValor())) self.retraer() self.aceptar() else: self.falla() else: self.falla() c = self.dame() if self.esLetra(c): while self.esLetra(c) or self.esDigito(c): c = self.dame() self.instalar("ID", self.getValor()) self.retraer() self.aceptar() else: self.falla() c = self.dame() if self.esOperadorMatematico(c): while self.esOperadorMatematico(c): c = self.dame() self.instalar("Op", self.getValor()) self.retraer() self.aceptar() else: self.falla() c = self.dame() if self.esEspacio(c): while self.esEspacio(c): c = self.dame() self.retraer() self.aceptar() else: self.falla() c = self.dame() if c == "": self.instalar("Fin", "") else: self.falla() c = self.dame() if self.esDesconocido(c): self.instalar("Error", "%s -> %d"%(c, self.__busqueda)) self.aceptar() else: self.falla()