ESTRUCTURAS ALTERNATIVAS Práctica #5 ESTRUCTURAS ALTERNATIVAS Grupo 1IL-701

Problema #1 Escriba un algoritmo para calcular la edad de una persona solicitando el año de nacimiento y el año actual. De a conocer el nombre de la persona, el año actual, el año de nacimiento, la edad y un mensaje con relación a si la persona es mayor o menor de edad.

clase Edad { privado ao_actual privado ao_nac publico void asig_val (entero AA, entero AN) { ao_actual = AA ao_nac = AN } publico entero calcular_edad() { entero edad edad = ao_actual - ao_nac retornar edad } }

INICIO caracter Nombre[20] entero AA, AN, edad Edad obj_ed imprimir (Ingrese el nombre) leer (nombre) imprimir (Ingrese el año actual) leer (AA) imprimir (Ingrese el año de nacimiento) leer (AN) obj_ed.asig_val (AA, AN) edad = obj_ed.calcular_edad() imprimir (La edad es:, edad) imprimir (Nombre:, nombre) si (edad >= 18) entonces imprimir (Mayor de Edad); de otro modo imprimir (Es menor de Edad) FIN

Problema #2 Escriba un algoritmo que transforme temperaturas dadas en grados Fahrenheit a Centígrados. Con ello de a conocer la temperatura e imprima el mensaje Hace Calor, si esta es mayor de 28º.

clase Temperatura { privado flotante Fahr publico void asignar_valores(flotante T1) { Fahr = T1 } publico flotante calcular_temperatura() flotante C { C = (Fahr - 32) * ( 5.0 / 9) retornar C } }

INICIO /*Declaración de variables */ Flotante gradosFahr Flotante C Imprimir (Entrar el valor de grados Fahrenheit) Leer (gradosFahr) /*Se crea el objeto de la clase */ Temperatura obj_temp /*Se instancia la clase */ obj_temp. asignar_valores(gradosFahr) /*Impresión de salida */ C = obj_temp.calcular_temperatura() Si(C> 28) Entonces Imprimir ( Hace Calor) Imprimir (la temperatura es :, C) FIN

Problema #3 Escriba un algoritmo que calcule el monto total de venta de un artículo, a partir de la entrada del código del artículo, la descripción, el precio unitario, la cantidad vendida y un campo para identificar si el artículo paga ITBM (Letra I) o si no lo paga (N). Si paga ITBM este corresponde al 5%.

/*definición de la clase*/ clase Venta { private entero producto, private flotante precio, private caracter campo, private cadena descripcion [20], private entero cantidad /*metodos*/ publico void asignar(flotante prec, caracter camp, cadena desc, entero cant) { precio=prec cantidad=cant} publico flotante monto } publico fllotante monto() { flotante mont mont = precio * cantidad Retornar mont } Publico flotante item () { retornar (precio* cantidad * precio * cantidad) } Publico void det_mont () Si (campo="I") }

INICIO /*declaracion de las variables*/ flotante precio, caracter campo, cadena descripcion, entero cantidad /*se crea el objeto*/ venta obj_monto visualizar("introduzca el nombre del articulo, precio unitario, cantidad, y si paga ITBMS introducir "I" de lo contrario introducir "N") leer(descripcion, precio, cantidad, campo) obj_monto.asignar(cantidad, precio) mont = obj_monto.monto Si ( (campo == 'I') or (campo == 'i') ) { Entonces { imp = obj_monto.itbm() monto = monto + imp } Visualizar () } FIN

Problema #4 Escriba un algoritmo que determine si un número leído es par o impar. Envié un mensaje correspondiente.

/*Definición de la clase*/ Clase Numero { /*Declaración de los datos de la clase*/ privado flotante x /*Métodos*/ publico void asignar(flotante a) {x=a} publico booleano asignar_valor() {si (x%2 == 0) retornar verdadero De otro modo retornar falso Fin si } }

INICIO /*Declaración de variables*/ booleano n flotante a /*Se crea el objeto*/ Numero obj_cond /*Se crea el objeto con los valores leídos*/ visualizar( Introduzca el valor) Leer (a) /*Activación de mensaje*/ obj_cond.asignar(a) n= obj_cond.asignar_valor() /*Salida*/ si (n==verdadero) visualizar (El número es par) De otro modo visualizar (El número es impar) Fin si FIN

Problema #5 Escriba un algoritmo que determine el mayor de dos números enteros leídos. Visualice el valor y el mensaje es el mayor.

clase Mayor { /* declaración de datos de la clase */ privado entero a, b /* Implementación de métodos */ publico asignar_val (entero x, entero y) { a = x b = y } publico entero det_mayor ( ) { si(a>b) entonces retornar a de otro modo retornar b Fin si }

INICIO /* Declaración de Variables */ Entero x1,y1 Imprimir ( ENTRAR EL VALOR DE A : ) Leer ( x1 ) Imprimir ( ENTRAR EL VALOR DE B : ) Leer ( y1 ) /* Se crea el objeto de la clase */ Mayor obj_mayor /* Activación del mensaje */ obj_mayor.asignar_val( x1, y1 ) /* Impresión de salida */ Imprimir (Mayor es:, obj_mayor.det_mayor ( ) ) FIN

Problema #6 Escriba un algoritmo que determine si un número leído es positivo, cero o negativo. Envié el mensaje correspondiente.

Problema #7 Escriba un algoritmo que a partir del índice académico de un estudiante, visualice el índice acompañado de un mensaje Primera Condicional, si dicho índice este por debajo de 1.00.

/*Definición de la clase*/ clase Indice { /*Declaración de variables*/ privado flotante In /*Método*/ publico void asignar_valores (flotante I) { In = I } publico void mindice () si (In < 1.00) Entonces imprimir Primera Condicional } }

INICIO /*Declaración de variables*/ flotante I /*Se crea el objeto*/ Indice obj_ind /*Crear el objeto con valores leídos*/ Imprimir (Entre el Indice) Leer (I) obj_ind.asignar_valores (I) /* Mensaje*/ obj_ind.mindice () Imprimir (Su índice es:, i) FIN

Problema #8 Escriba un algoritmo que determine si un número leído es mayor o si es menor que 50.

/*Definicion de la Clase*/ Clase Deter_num { /*Declaracion de Variables*/ Privado flotante n /*Metodos de la Clase*/ Publico void asignar_valor(flotante num) {n=num} Publico flotante comp_valor() {si (n>50) Entonces Visualizar (n, es mayor que 50) Si (n<50) Visualizar (n, es menor que 50) Si (n=50) Visualizar (n, es igual a 50)} }

INICIO /*Declaracion de variables*/ Flotante num /*Se crea el objeto*/ Deter_num obj_num /*Se crea el objeto mediante valores leidos*/ Visualizar ( Introduzca el numero) Leer (num) Obj_num.asignar_valor(num) Obj_num.comp_valor() FIN

Problema #9 Escriba un algoritmo que divida dos números de forma real. Verifique que antes si la división se puede realizar, de lo contrario envié un mensaje de división entre cero es invalida.

/* Calcula division de dos numeros reales*/ Clase Division { /* Declaración de las variables */ privado flotante dids, didd /* Métodos*/ publico void dar_valor(flotante D, flotante AD) { dids=dv didd=ds} Publico flotante cal_div() { flotante rd /* Determina el valor, si es 0 es invalido*/ Si ( dids >= didd ) Entonces rd = dids/didd De Otro Modo Visualizar(El resultado es invalida) retornar rd} }

INICIO /* Declara las variables */ flotante D, AD, div /*crea el objeto*/ Division obj_reto /* Entrada de los datos */ Visualizar (Introduzca los números que deseas dividir) Leer(D, AD) obj_reto.asignar_valor(D, AD) /*Mensaje de calcular division*/ div=obj_reto.cal_div( ) /* salida */ Visualizar(El salario es:, div) FIN

Problema #10 Escriba un algoritmo que calcule el salario bruto de un empleado y determine si éste gana más de $500.00, para recibir un incentivo del 10%, de lo contrario recibe un incentivo del 15% adicional.

Clase Salario_bruto { Privado flotante ht,sh Publico void asignar_valor(flotante h_trabajo, flotante salario_h ) { ht=h_trabajo sh=salario_h } publico flotante calcular_salario() { flotante sal retornar sal }

INICIO flotante h_trabajo, salario_h Salario_bruto obj_sb Visualizar (Entre las horas trabajadas y el salario por hora) Leer(h_trabajo, salario_hora) Si(Salario_bruto>500) obj_sb.asignar(h_trabajo, salario_h) Entonces { sal= ht*sh+10% De otro modo sal= ht*sh +15% Visualizar(El salario es,obj_sb.calcular_salario()) } FIN