EXAMEN PRACTICO
EXAMEN 03
30 DE OCTUBRE DE 2020
CRUZ GARCIA RAUL ALEJANDRO
MIGUEL ANGEL VILLANUEVA SOLORIO
PROBLEMA 1: Calcular la velocidad (m/s) de los corredores de la carrera de 1500
metros. La entrada consistirá en parejas de números (minutos, segundo) que dan
el tiempo del corredor, por cada corredor, el resultado debe visualizar el tiempo en
minutos y segundos, así como la velocidad media. Ejemplo de entrada de datos:
(3.53) (3.40) (3.46) (3.52) (4.0) (0.0); el ultimo par de datos se utilizará como fin de
entrada de datos.
Entrada: Dado el problema debemos identificar como vamos a resolverlo primero
empezando por identificar el razonamiento del algoritmo. Para el inicio de nuestro
programa ya hemos declarado dos variables una de tipo int y otra de tipo bolean,
la primera será llenada por el usuario para que pueda elegir una de las dos opciones
en el menú donde puede escoger entre “comenzar nueva carrera” o “salir”, la
primera opción manda a llamar una función para comenzar a llenar los datos para
la carrera, en caso contrario simplemente el programa acaba.
Proceso: Una vez el usuario seleccione la opción de comenzar carrera se le pedirá
que digite el número de corredores que le gustaría que compitan en la carrera, este
número es de tipo int y nos servirá como límite de iteraciones en nuestro ciclo for(),
dentro del for() vamos a crear los n corredores que el usuario elegio y apoyados
con la clase math() vamos a llenar los tiempos con valores de dos decimales que
representan los minutos y segundos. Al mismo tiempo por cada interacción se van
sumando en una variable dooble para posterior mente la suma dividirla entre el
número de corredores y así obtener la media de tiempo. Lo primer que hicimos fue
importar la librería de Scanner para poder capturar los datos que le vamos a pedir
al usuario, después de eso creamos el objeto de tipo Scanner para mandar a llamar
a la función, después de eso creamos otro objeto llamado opera de tipo Funciones
que es la función que se encarga de generar los tiempos, posterior a esto
declaramos dos variables, una de tipo de int llamada entrada con valor igual a 0,
esta variable es para que el usuario le asigne un valor del menú y la segunda
variable de tipo boolean es para finalizar el ciclo while() donde está el menú.
Aquí abrimos un ciclo do while() que solo termina si nuestra variable a es falsa,
después lo primero que vemos son dos salidas de texto con las dos diferentes
opciones, la primera es la de iniciar carrera y la segunda finalizar programa, luego
de eso abrimos un switch case, en caso de que el usuario seleccione el caso 1 lo
primero que vamos a hacer es preguntarle al usuario cuantos corredores quiere que
participen en la carrera, cachamos el digito del usuario y después llamamos a la
función con el objeto opera. En el otro caso solo cambiamos el valor de a en falso
para terminar el programa.
En esta otra clase llamada Funciones lo primero que hicimos fue importar la librería
DecimalFormat que mas adelante nos ayudara a restringir los decimales que nos
arrojen nuestros valores de tipo doble. En seguida declaramos un objeto del tipo
DecimalFormat, luego de esto abrimos nuestra función que va a cachar un int que
en este caso es numero de corredores que ya le pedimos al usuario. Declaramos
dos variables de tipo doble, la primera llamada aleatorio que va a ser la que nos
genere los tiempos random para cada corredor y la segunda variable llamada suma
que como su nombre lo dice va a estar sumando los tiempos generados por nuestra
variable random. Luego de esto mandamos un mensaje al usuario que dice que los
corredores obtuvieron los siguientes resultados en la carrera. Posterior a esto
abrimos el ciclo for() y vemos que se va a interar desde i que vale 1 hasta que sea
menor o igual a nuestra variable a, que es el numero de corredores que nos indico
el usuario. Despues la generación de numero aleatorios que va a estar condicionada
de 3 a 4 para que los corredores tengan tiempos ligeramente parecidos y no se vean
tan radicales los tiempos, una vez echo esto se imprime el numero del corredor con
el tiempo aleatorio asignado seguido de la variable suma guardando la suma de
todos los tiempos que obtengamos, por ultimo solo dividimos la variable suma entre
la cantidad de corredores totales para obtener la media de tiempo de la carrera y
mostrársela al usuario en una salida de texto.
Salida: El programa se va a ejecutar el numero de veces que el usuario quiera con
el numero de corredores que se desee colocar en cada interacion. Como e observa
el programa se ejecuto sin problema.
DIAGRAMA DE FLUJO:
PSEUDOCODIGO:
PROBLEMA 2: Se requiere un programa, que cuente el número de ocurrencias de
cada letra en una palabra leída como entrada (La declararemos después). Por
ejemplo “Mortimer” contiene dos “m”, una “o”, dos “r”, una “i”, una “t” y una “e”.
ENTRADA: Se le pide al usuario que digite la cadena que se va a analizar, esa
cadena se debe guardar en una variable (le asignaremos el nombre palabra),
crearemos un arreglo con todas las letras del abecedario en minúsculas (le
asignaremos el nombre abecedario), tendremos que analizar la longitud de la
cadena es decir cuantas letras contiene contando los espacios en blanco (le
asignaremos el nombre de lenPalabra), es evidente que ocuparemos de un
contador (después lo declararemos), por ultimo ocuparemos el total de letras que
tiene el abecedario que en este caso son 27.
PROCESO: Se hacen las declaraciones de nuestras variables y librerias, según el
lenguaje elegido es como estará dado la sintaxis de declaración, en este caso
ocuparemos el lenguaje C, declaramos palabra[60] como un arreglo de tipo char
con una longevidad de 60, es decir podrá recibir máximo 60 caracteres. Declaramos
contAbecedario[] como un arreglo de tipo int, el arreglo contendrá en total 27
valores (que es el total de letras que contiene el abecedario), cada letra tendrá su
contador iniciado en 0. Declaramos abecedario[] como un arreglo de tipo char, el
cual contendrá todas las letras del abecedario (en minúsculas para mayor facilidad).
Le pedimos al usuario que digite la palabra que quiera analizar (la cual es guardada
en palabra[60]), una vez teniendo la palabra guardada podremos manipularla como
queramos dentro del código, lo primero que haremos es sacar la longitud de la
cadena, para ello nos apoyaremos de una función llamada strlen(palabra) la cual
recibe como parámetro palabra (la que se digito desde teclado), y nos regresa el
total de longitud que tiene esa palabra en int, es decir si se digitó “hola” la función
strlen(palabra) nos regresara 4, esa longitud la guardamos en nuestra variable de
tipo int declarada como lenPalabra. Es evidente que ocuparemos de uno o más
bucles, así que declaramos nuestra variable i de tipo int y nuestra variable j de tipo
int, para cuando se ocupe evitar un exceso de líneas de código.
Ahora procederemos con la parte del algoritmo, se requiere de dos ciclos for(), para
poder ir analizando cada letra de la palabra digitada por el usuario, con cada letra
del arreglo abecedario[], en este caso como la cadena se guardó en un arreglo de
caracteres char, nos pondrá un poco más fácil la situación.
Como se mencionó anteriormente, el primer for() será el encargado de recorrer
carácter por carácter en nuestra cadena palabra se incrementara i por cada
iteración, parara hasta lenPalabra que es la longitud de palabra.
El segundo for() se encargara de recorrer nuestro arreglo de caracteres que
contiene todo el abecedario se incrementara j por cada iteración, parara hasta 27
que es el total de letras que contiene el abecedario, contara con una condición if(),
en la cual se evaluara si nuestra letra de la palabra[i] es igual a alguna letra del
abecedario[j], si la condición se cumple nuestro arreglo contAbecedario[j] se
incrementará, por lo tanto j que lleva el recorrido de abecedario[j] y de
contAbecedario[j] en la posición que se encuentra dejara de valer 0 para valer 1,
se incrementara de uno en uno por cada ocurrencia que tenga. Por ejemplo si
nuestra palabra tiene cuatro b, sabiendo que b es la segunda letra del abecedario
por lo tanto j = 2, el arreglo contAbecedario[2] ahora será igual a cuatro. Con este
algoritmo es como obtendremos todas las letras que tengan una o mas ocurrencias.
Después implementamos un ciclo for() que recorrerá i hasta 27, al mismo tiempo
se recorrerá el arreglo abecedario[i] y contAbecedario[i], el cual tendrá una
condicional if() que evaluara si contAbecedario[i] > 0, por lo cual si entra
estaremos confirmando que abecedario[i], se repitió una o mas veces, igual cada
vez que se cumpla imprimiremos abecedario[i] y contAbecedario[i], para así
mostrar en pantalla “La palabra contiene 3 a , 5 b, etc.”.
Salida: Se ejecuta el programa y se muestra en la pantalla el resultado esperado,
tanto para maysculas como minusculas.
DIAGRAMA DE FLUJO:
PSEDUDOCODIGO:
PROBLEMA 3: Un Cliente ejecuta un pedido a una fábrica. La fábrica examina en
su banco de datos la ficha del cliente, si el cliente es solvente entonces la empresa
acepta el pedido; en caso contrario, lo rechazara.
Entrada: Se creará una clase llamada Cliente, con los atributos requeridos para
tener información de cada cliente (nombre, edad, domicilio, cuenta, etc.), se le pide
al usuario que digite el total de clientes que analizará, ese valor lo guardaremos en
una variable (le asignaremos el nombre tClientes).
Proceso: En esta ocasión programaremos en el lenguaje java, lo primero que
haremos es crear nuestro objeto Cliente, para poder crear nuestra instancia desde
nuestra clase principal, nuestra clase Cliente, tendrá 5 atributos privados,
declaramos private String nombre, private int edad, private String domicilio,
private String cuenta, private string adeudos, los creamos en privado para poder
manipular mejor las operaciones, cuando se ocupan atributos privados es necesario
crear los set y get de cada atributo.
Despues crearemos nuestra clase principal donde se ejecutara el metodo main(),
lo primero sera pedir al usuario que nos digite el total de clientes que quiere
analiazar tClientes, una vez teniendo ese dato guardado, creamos la instancia del
objeto Cliente en este caso haremos un arreglo de objetos Cliente cliente[] = new
Cliente[tClientes], con esto podremos crear un objeto en cada posicion del arreglo
y cada objeto tendra los atributos de nuestra clase Cliente, es decir nuestro
cliente[1] tendra nombre, direccion, cuenta, adeudos y edad.
Ahora procederemos a la parte del algoritmo y razonamiento, crearemos un for()
que parara hasta que i sea menor a nuestra longitud de arreglo [Link] (este
método regresa en entero la longitud de nuestro arreglo), se incrementara i por cada
iteración, adentro del for() instanciaremos cada objeto, para que por cada iteración
nuestro apuntador se limpies y apunte a un objeto nuevo cliente[i] = new Cliente(),
así podremos tener los datos por cada arreglo del objeto, lo siguiente es pedir al
usuario que llene los datos requeridos para saber si el cliente es apto para hacer el
pedido o no. Ocupamos en cliente[i].set(nombre) para asignarle a ese posición en
el valor nombre, la cadena digitada.
Así con cada uno de los atributos que serán ingresados desde teclado.
Explicare el algoritmo para saber si es apto o no, esta línea del código debe de ir
dentro del for(), ya que por cada cliente lo tiene que evaluar, lo hicimos a la suerte
por cada cliente se genera un numero random [Link](), que va del 1 al 10
si el cliente se le genera un numero par le asignamos el valor de que tiene adeudos,
si tiene suerte y se genera un impar le asigna el valor de aceptado porque no tiene
adeudos. Ocupamos el operador ternario que tiene la misma funcionalidad que un
if(), para este tipo de análisis.
Ahora lo nico que nos queda es imprimir cada atributo de cada cliente, y su analisis
si el cliente fue aceptado o rechazado. Creamos un ciclo for(), que parara cuando i
sea menor a [Link], se incrementara i por cada iteracion, en este for solo
imprimimos cada atributo con el metodo de get, cliente[i].getNombre() obtenemos
el nombre del cliente i.
Salida: Se ejecuta el programa y se verifica que compila todo en orden.
DIAGRAMA DE FLUJO:
PSEUDOCODIGO:
PROBLEMA 4: Realizar la suma de todos los números pares entre 2 y 100. El
problema consiste en sumar 2+4+6+8...+100. Utilizaremos las palabras SUMA Y
NUMERO (variables, serán denominadas más tarde) para representar las sumas
sucesivas (2+4), (2+4+6), (2+4+6+8), etc.
Entrada: En esencia este tipo de problemas puede resultar bastante fácil de
principio, pero si no aplicamos bien nuestro razonamiento en un código podemos
complicar las cosas más de lo que deberían, hay muchas formas de resolver este
problema en este caso se nos ocurrió que podíamos separar todos los números
pares usando el residuo de dividir los números entre dos, aquellos número cullo
residuo sea diferente de 0 no es par y por lo tanto no se suma, y una vez finalizada
la suma de todos los pares lo único que corresponde es mostrarle al usuario el
resultado final. Lo primero que haremos será declarar una variable de tipo int
llamada suma, que en principio valga 0 de esta manera la variable se encuentra
lista para para almacenar la suma de los números pares y una vez finalizado el
proceso volver a utilizarla con todo lo que ya guardo.
Proceso: Declararemos un ciclo for()¸que parara hasta que i sea = 100, se
incrementara i, por cada iteración, proceso comienza en el momento que entramos
al for() donde nuestra variable i comienza con un valor de 1 esto para que no exista
un problema al dividir 0 entre 2, y cumpliendo la condición de que i siempre va a ser
menor o igual a 100, una vez la condición del for() se cumple, entramos en el
condicional if() ahí es donde separamos los pares, esto siempre que cumpla la
condición de que el residuo de dividir nuestro valor de i entre dos sea igual a 0, si
esto se cumple entonces a nuestra variable suma la guardamos el valor para que al
finalizar almacene la suma de los pares. Para esto suma fue declarada afuera del
ciclo para que por cada iteración fuera sumando y guardando el valor, sin
alteraciones.
Salida: Finalmente al usuario lo único que se le muestra es el resultado final de la
operación que posteriormente ya habíamos guardado en nuestra variable suma.
Inicio
DIAGRAMA DE FLUJO:
PSEUDCODIGO:
