Universidad Nacional de Salta Facultad de Ciencias Exactas

Programación (LAS – TUP) 2017

Trabajo Práctico Nº 3: Modularidad

Fecha de Inicio 28/8 - Fecha de Fin 4/9

Ejercicio 1: Para cada problema, crear un programa utilizando la librería <math.h>

a) Dada una cantidad no conocida de puntos en el plano, distintos del origen, calcular el punto
más cercano al origen. Suponer que este punto existe y es único.
b) Dados N números reales para cada uno de ellos calcular la parte entera del número. Si la
parte entera resulta ser par (y no cero) entonces crear un nuevo número calculando la
potencia del número ingresado elevado al primer dígito de la parte decimal. Cuando la parte
entera no sea par, crear un nuevo número calculando la raíz cuadrada de la parte entera. Si
la parte entera resulta ser cero, crear un nuevo número calculando el logaritmo del número
ingresado. Mostrar cada número generado indicando el tipo de transformación.
c) Dado un cateto y un ángulo agudo expresado en grados de un triángulo rectángulo, realizar
un programa que permita calcular la hipotenusa y la longitud del otro cateto. Modificar el
algoritmo anterior para que permita trabajar con N triángulos rectángulos.
Nota: tener en cuenta que las funciones trigonométricas trabajan con ángulos en radiantes.
Para pasar un ángulo expresado en grados a radianes, se multiplica los grados por pi y se
divide por 180. Pi = 3.14159.

d) Dados tres números reales a, b y c, realizar un algoritmo que calcule las raíces reales de una
ecuación de 2º grado. Cuando las raíces sean complejas mostrar un cartel que informe esta
situación. Modificar el algoritmo anterior para que permita trabajar con N ecuaciones.
Una ecuación de segundo grado es de la forma + + con ≠ 0. Las raíces se
±√
encuentran con la siguiente fórmula: , = . Para saber si las raíces son reales
se utiliza el discriminante: ∆= − 4 . Si ∆> 0 entonces las raíces son reales y distintas. Si
∆= 0 las raíces son reales e iguales. Si ∆< 0 entonces las raíces son complejas.

Ejercicio 2: Utilice la librería <stdlib.h> y <time.h> para crear un programa que simule la
espera de N clientes en una cola para hacer un trámite en el banco. Para cada uno de los N clientes
que llegan al banco, se asigna el tiempo de espera de forma aleatoria, siendo un número natural en
el rango [1,30]. El programa debe calcular:
a) Promedio total de espera
b) El tiempo de la menor espera
c) El tiempo de la mayor espera

Ejercicio 3: Divide y vencerás!

a) Para cada uno de los siguientes códigos marcar con distintos colores los subproblemas que lo
componen e indicar el nombre de cada subproblema identificado.

1
Universidad Nacional de Salta Facultad de Ciencias Exactas
Programación (LAS – TUP) 2017

1) Código 1:
#include<stdio.h>
int main() {
int N, num, i, PD,cont;
cont=0;
printf("Ingrese la cantidad de números a procesar: ");
scanf("%d",&N);
for (i=1;i<=N;i++){
printf("Ingrese un número: ");
scanf("%d",&num);
PD=2;
while ((PD<=num/2)&&(num%PD!=0))
PD+=1;
if ((num!=1)&&(PD>num/2))
cont+=1;
}
printf("La cantidad de primos ingresados es: %d\n,cont);
return 0;
}
Subproblemas identificados: _____________________________________
_____________________________________
_____________________________________
_____________________________________

2) Código 2:
#include<stdio.h>
int main() {
int num, aux, invertido, dig, acu, cant;
acu=0;
cant=0;
printf("Ingrese un numero: ");
scanf("%d",&num);
while (num>0) {
invertido=0;
aux=num;
while (aux!=0) {
dig=aux%10;
aux=aux/10;
invertido=invertido*10+dig;
}
if (invertido==num) {
acu+=+num;
cant+=1;
}
printf("Ingrese un numero: ");
scanf("%d",&num);
}
if (cant!=0) {
printf("el promedio de numeros primos es: %f\n", acu/cant);
} else printf("no hay numeroscapicuas\n");
return 0;
}

2
Universidad Nacional de Salta Facultad de Ciencias Exactas
Programación (LAS – TUP) 2017

Subproblemas identificados: _____________________________________

_____________________________________
_____________________________________
_____________________________________

3) Código 3:
#include <stdio.h>

int main(int argc, char *argv[]) {

int num,i,N,PD,aux,dig,may;

printf("Ingrese la cantidad de números a procesar: ");

scanf("%d",&N);
for (i=1;i<=N;i++) {
printf("Ingrese un número: ");
scanf("%d",&num);
while ((PD<=num/2)&&(num%PD!=0))
PD+=1;
if ((num!=1)&&(PD>num/2)) {
aux=0;
while (num!=0) {
dig=num%10;
num=num/10;
aux=aux+dig;
}
num=aux;
} else {
dig=num%10;
num=num/10;
may=dig;
while (num!=0) {
dig=num%10;
if (dig>may) may=dig;
num=num/10;
}
num=may;
}
printf("El número transformado es: %d\n",num);
}

return 0;
}

Subproblemas identificados: _____________________________________

_____________________________________
_____________________________________
_____________________________________
_____________________________________

3
Universidad Nacional de Salta Facultad de Ciencias Exactas
Programación (LAS – TUP) 2017

b) Para cada uno de los subproblemas identificados en los programas del inciso a) definir la
cabecera de los módulos que sean necesarios construir, respondiendo las siguientes preguntas:
a) ¿Todos los subproblemas se podrán convertir en módulos? Indique para cada programa
cuáles subproblemas serán módulos del programa.
b) Para los subproblemas seleccionados en a) ¿Qué datos requiere procesar el subproblema?
¿Qué datos se obtienen luego de realizar las instrucciones del subproblema?
c) Analizados los datos que requiere y que se obtienen del subproblema, responder ¿el
subproblema sería un módulo de tipo función o procedimiento? ¿Por qué?
d) En base al análisis realizado definir los parámetros de cada módulo. Recordar que los
parámetros permiten la comunicación entre el módulo y el resto del programa.

Ejercicio 4: Modularizar los programas del ejercicio 3 utilizando las cabeceras de los módulos
definidas en el inciso b). Una vez modularizado los programas realizar las siguientes consignas:
a) Clasifique los identificadores en locales y globales según corresponda.
b) Observe en qué momento utiliza parámetros formales y cuándo actuales. Parámetros por
valor y por referencia.

Ejercicio 5: Crear un módulo que manipule dos números enteros suprimiendo la última cifra del
primero y añadiéndola al final del segundo. Realizar un programa que utilice dicho módulo para
invertir un número.

Ejercicio 6: Desarrollar los siguientes módulos:

a) Crear un módulo que determine la cantidad de divisores positivos de un número natural (sin contar
los divisores triviales) ¿En qué tipo de problemas podría utilizar este módulo? Brinde un ejemplo.
b) Crear un módulo que dado un número natural NUM en base 10 y una base B < 10 calcule el
equivalente de NUM en base B.

Realizar un programa utilizando los módulos anteriores y reutilizando el módulo de determinación de

primo trabajado en el ejercicio 3, en el que para un número natural, calcule su equivalente a base 2 si
la cantidad de divisores del número es primo y calcule su equivalente a base 9 si la cantidad de
divisores no es primo.
Importante: al reutilizar el módulo del inciso a) tener en cuenta que el valor retornado no contempla
todos los divisores del número y esto podría afectar la resolución del problema planteado.

Ejercicio 7: Desarrollar los siguientes módulos:

1. Dados dos números naturales determine si éstos son amigos.
Los números son amigos, si cada uno de ellos es igual a la suma de los divisores del otro
(tener en cuenta que no se debe tomar al mismo número como divisor). Por ejemplo, 220 y
284 son amigos, ya que:
Suma de divisores de 284: 1 + 2 + 4 + 71 + 142 = 220
Suma de divisores de 220: 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284
Nota: Si para la solución de este problema detecta alguna otra tarea que deba ser un módulo
debe implementarse.
2. Dado un número natural determine si es un número deficiente, abundante o perfecto.
Un número natural N se dice que es deficiente si la suma de sus divisores (sin contarse a sí
mismo) es menor a N. Si la suma de sus divisores es mayor a N se dice que el número es
abundante y si es igual a N se dice que es perfecto.

Realizar un programa que genere una lista de N números aleatorios en el rango [A, B] (con A y B
naturales) y muestre aquellos números aleatorios que cumplan con no ser deficientes y posean un
número amigo en el intervalo [A, B].

4
Universidad Nacional de Salta Facultad de Ciencias Exactas
Programación (LAS – TUP) 2017

Ejercicio 8:
2 i
a) Para X e i dados, diseñar un módulo que calcule la siguiente sucesión: Si = 1 + X + X /2! + ...+ X /i!
X
Cada Si es una aproximación de la función e ; cuanto más grande es el valor de i, más cerca es el
X
valor de Si del valor real de la función e .
b) Realizar un módulo en el que dado un valor para X y un error E devuelva el primer valor de i que
X
cumpla una aproximación de e con un error máximo de E.
Utilizando los módulos desarrollados en a) y b), realizar un programa que para N errores dados por el
usuario, muestre el valor de i de la aproximación.

Ejercicio 9: Crear los siguientes módulos

a) Calcule los valores de mantisa y exponente de un número real para expresarlo en notación punto
flotante normalizado.
b) Dada una mantisa normalizada y un exponente entero calcule el número real en notación punto
fijo. ¿Existe una función pre definida en alguna librería de C que pueda ser usada para resolver esta
tarea? En el caso de existir y utilizarla ¿Es necesario construir este módulo?

Utilizando los módulos desarrollados en a) y b) realizar un programa que a través de un menú de

opciones permita al usuario obtener el valor normalizado de un número real u obtener el valor en
punto fijo de una mantisa normalizada y un exponente.

Ejercicio 10: Realizar un programa que, para cada una de las N fechas ingresadas por el usuario,
genere una fecha al azar mayor a esta y luego indique la cantidad de días promedio entre cada una
las fechas ingresadas y la fecha generada al azar.

Ejercicio 11: Piedra, papel o tijeras: Este es un juego muy antiguo en el que intervienen dos
personas. Cada jugador hace su elección entre las tres alternativas existentes (piedra, papel o tijeras)
y el ganador se determina atendiendo a las siguientes reglas:
I. La piedra gana a las tijeras.
II. Las tijeras ganan al papel
III. El papel gana a la piedra.
IV. Si las dos elecciones son iguales se produce un empate.
Escribe un programa que permita a la máquina jugar contra un humano todas las veces que el
quiera. Máquina y humano harán su elección y la máquina será la que decida quién gana.

Ejercicio 12: En una agencia espacial que transmite y recibe números binarios representados
mediante vectores de bits (0 ó 1), se requiere un programa que permita codificar dichos números
binarios. La codificación consiste en reemplazar grupos de bits de un mismo valor por la cantidad de
bits del grupo, seguida del valor del bit. Por ejemplo si el número es=(1100001111100111000100) su
codificación resulta: (2140512031301120). Dado un número binario, de una cantidad de bits
desconocida, mostrar el resultado de su codificación.
Nota: Asumir que los números binarios a codificar siempre empiezan con al menos un bit 1. Utilizar
como tipo de dato long int para el número binario y su codificación. Hacer pruebas con números no
muy grandes pues de otra manera la memoria se desbordará. Más adelante se podrán utilizar otros
tipos de datos que permitan una mejor solución al problema.

Ejercicio 13: Construir una calculadora que trabaje solo con fracciones y que permita realizar las
siguientes operaciones:
a) Operaciones de lectura y escritura de fracciones en la entrada/salida estándar.
b) Operaciones aritméticas entre fracciones: suma, incremento de una fracción con otra, resta,
decremento de una fracción con otra, producto, cociente y simplificar una fracción a irreducible.
c) Operaciones de comparación de fracciones, tales como: igualdad, mayor, menor, mayor o
igual y menor o igual.
Crear un programa que mediante un menú de opciones permita trabajar con diferentes operaciones.
5