EXAMEN PARCIAL Estructura de Datos 2022-2

PROBLEMA 1

El programa se desarrolla con el llenado de datos de cada departamento para después pasar a cada uno de los querys. Se utilizo registros para obtener los datos de un departamento y para enlistar los datos se utilizo arreglos dinámicos que van aumentando de acuerdo a los departamentos que cumplan las condiciones.

///////////////////////////////////////////////////

PRECONDICIONES

        REGISTRO Departamento

                ENTERO clave

                Real extension

                ENTERO ubicación

                Real precio

                Booleano disponible

        FIN-REGISTRO

        Departamento dep[ cant ]

POSTCONDICIONES

        Datos mostrados

//////////////////////////////////////////////////

Accion Mostrar_porprecio( )

ENTERO k=0, p=0, listos[k]

REAL P=0

        Escribir(“Digite el precio ( P ) : “ )

        Leer P

        Para I=0 hasta I<cant entonces

                SI ( ( dep [ i ].precio <= P ) Y ( dep[i].disponible = Verdadero ) )

                        K <- k+1

                        Redimensionar listos[k]

                        Listos[p] <- dep[i].clave

                        P <- p+1

                SINO

                FIN-SI

        Fin-Para

        Escribir ( “ las claves de los departamentos que cumplen son: “)

        Para I=0 hasta I<K entonces

                Escribir( listos[i] , “ \n” )

        Fin-Para

Fin-accion

Accion Mostrar_porextension()

ENTERO k=0, p=0, listos[k]

REAL E=0

        Escribir(“Digite la extension ( E ) : “ )

        Leer E

        Para I=0 hasta I<cant entonces

                SI ( ( dep [ i ].extension >= E ) Y ( dep[i].ubicacion = 4 ) )

                        K <- k+1

                        Redimensionar listos[k]

                        Listos[p] <- dep[i].clave

                        P <- p+1

                SINO

                FIN-SI

        Fin-Para

        Escribir ( “ las claves de los departamentos que cumplen son: “)

        Para I=0 hasta I<K entonces

                Escribir( listos[i] , “ \n” )

        Fin-Para        

FIN-Accion

Accion monto_alquilados()

ENTERO k=0, p=0

REAL listos[k], monto=0

Escribir ( “ Los departamentos con su monto respectivo son: “)

        Para I=0 hasta I<cant entonces

                SI ( dep[i].disponible == falso  )

                        K <- k +1

                        Escribir ( “Departamento : “ , dep[i].clave , “ “)

                        Escribir ( “ Renta: “ , dep[i].precio , “ \n” )

                        Redimensionar listos[k]

                        Listos[p] <- dep[i].precio

                        P <- p+1

                SINO

                FIN-SI

        Fin-Para

        Para I=0 hasta I<k entonces

                Monto = monto + listos[i]

        Fin-Para

        Escribir ( “ El monto total de todos los departamentos alquilados es: “, monto)

Fin-Accion

Accion Solicitar_depa()

        REAL E=0 , P=0

        ENTERO U=0, M=0

        Hacer

                Escribir ( “ Digitar extensión del departamento mayor igual a: “ )

                Leer E

        Mientras ( E <= 0 )

        Fin-Hacer

        Hacer

                Escribir ( “ Digitar el precio del departamento menor igual a: “)

                Leer P

        Mientras ( P <= 0 )

        Fin-Hacer

        Hacer

                Escribir ( “ Ubicación deseada [ 1 ] mala ,[2] regular ,[3] buena ,[4] excelente:”)

                Leer U

        Mientras ( (U <> 1) o (U <> 2) o (U <> 3) o (U <> 4) )

        FIN-hacer

        Para I=0 hasta I < cant entonces

                Si ( ( dep[i].extension >= E ) Y ( dep[i].precio <= P ) Y ( dep[i].ubicacion = U ) Y ( dep[i].disponible = verdadero )

                        M = 1

                        Escribir ( “ Departamento de clave : “, dep[i].clave , “ cumple “ )

                        Hacer

                                Escribir ( “ Desea rentar el departamento? [1] = si , [ 2] = no “)

                                Leer rspt

                        Mientras ( rspt <> 1 o rspt <> 2 )

                        Si ( rspt = 1 )

                                Dep[i].disponible = falso

                        Sino

                                Escribir ( “ Renta no aceptada “ )

                        FIN-Si

                Sino

                Fin-Si

        Fin-Para

        Si ( M = 0 )

                Escribir ( “ no hay departamentos con los requisitos enviados “ )

        Sino

        Finsi

Fin-Accion

Accion Aumentar_rentas()

        Real X=0

        Hacer

                Escribir ( “ el porcentaje que se aumentara en las rentas: “)

                Leer X

        Mientras ( X <= 0 )

        Fin – Hacer

        Para I = 0 hasta I < cant  entonces

                Si ( dep[i].disponible = verdadero )

                        Dep[i].precio = (1+(X/100))*dep[i].precio

                Sino

                Fin-si

        Fin-para

Fin-Accion

Accion Principal ()

        Entero cant=0, disp

        Hacer

                Escribir ( “ cantidad de departamentos : “ )

                Leer cant

        Mientras ( cant <= 0 )

        Fin-hacer

        Para I =0 hasta I<cant entonces

                Hacer

                        Escribir ( “digitar el código del departamento “ , I+1 )

                        Leer dep[i].codigo

                Mientras ( dep[i].codigo <= 0 )

                Fin-hacer

                Hacer

                        Escribir ( “digitar la extension del departamento “ , I+1 )

...