UNIVERSIDAD NACIONAL AUTÓNOMA DE HONDURAS EN EL VALLE DE

SULA
UNAH-VS

SECCIÓN: 0700

TEMA: EJERCICIOS CAP 5

PRESENTADA POR:
CAROL LIZETH LOPEZ GARCIA CTA# 20152005774

FECHA 19 DE ABRIL 2021

EJERCICIOS DE AUTOEVALUACIÓN
5.1 Responda cada una de las siguientes preguntas:
a) A un módulo de programa en C, se le llama función.
b) Una función se invoca mediante una llamada a función.
c) A una variable que sólo se conoce dentro de la función en la que se definió se le
llama variable local.
d) La instrucción return dentro de una función se utiliza para pasar el valor de una
expresión hacia la función que la invoca.
e) La palabra reservada void se utiliza dentro de una función para indicar que ésta
no devuelve valor alguno, o para indicar que la función no contiene parámetros.
f) El alcance de un identificador se refiere a la porción del programa en la que se
puede utilizar dicho identificador.
g) Las tres formas de devolver el control desde la función invocada hasta la función
que llama son return, return expresión y al encontrar} de fin de función.
h) Un prototipo de función permite al compilador verificar el número, tipo y
orden de los argumentos que se pasan a una función.
i) La función rand se utiliza para producir números aleatorios.
j) La función srand se utiliza para establecer la semilla de los números aleatorios
para randomizar un programa.
k) Los especificadores de clase de almacenamiento son: auto, register, extern, y
static.
l) Se asume que las variables declaradas dentro de un bloque, o en la lista de
parámetros de una función, tienen una clase de almacenamiento auto, a menos
que se especifique lo contrario.
m) El especificador de clase de almacenamiento register es una recomendación al
compilador para que almacene una variable en uno de los registros de la
computadora.
n) Una variable definida fuera de cualquier bloque o función es una variable
externa, función.
o) Para que una variable local de una función retenga su valor entre las llamadas a
la misma, la variable se debe declarar con el especificador de clase de
almacenamiento static.
p) Los cuatro posibles alcances de un dentificador son alcance de función, alcance
de archivo, alcance de bloque y alcance de prototipo de función.
q) Una función que se invoca a sí misma de manera directa o indirecta es una
función recursividad.
r) Por lo general, una función recursiva tiene dos componentes: uno que
proporciona un medio para que termine la recursividad a través de la evaluación
de un caso base, y otro que expresa el problema como una llamada recursiva a
un problema ligeramente más sencillo que el de la llamada original.

5.2 Para el siguiente programa, establezca el alcance (si es alcance de función, de

archivo, de bloque o de prototipo de
función) de cada uno de los siguientes elementos.
a) La variable x en main.
Alcance de bloque.
b) La variable y en cubo.
Alcance de bloque.
c) La función cubo.
 Alcance de archivo.
d) La función main.
Alcance de archivo.
e) El prototipo de la función para cubo.
Alcance de archivo.
f) El identificador y en el prototipo de la función cubo.
Alcance de prototipo de función.

#include <stdio.h>
int cubo( int y );
int main ( )
{
int x;
for ( x = 1; x <= 10; x++ )
printf( “%d\n”, cubo( x ) );
return 0;
}
Int cubo(int y)
{
return y*y*y;
}
5.3 Escriba un programa que compruebe si los ejemplos sobre las llamadas a las
funciones matemáticas de la biblioteca que mostramos en la figura 5.2 producen
realmente los resultados indicados.

#include <stdio.h>
#include <math.h>

int main()
{
printf( “sqrt(%.1f) = %.1f\n”, 900.0, sqrt( 900.0 ) );
printf( “sqrt(%.1f) = %.1f\n”, 9.0, sqrt( 9.0 ) );

printf( “exp(%.1f) = %f\n”, 1.0, exp( 1.0 ) );

printf( “exp(%.1f) = %f\n”, 2.0, exp( 2.0 ) );

printf( “log(%f) = %.1f\n”, 2.718282, log( 2.718282 ) );

printf( “log(%f) = %.1f\n”, 7.389056, log( 7.389056 ) );
printf( “log10(%.1f) = %.1f\n”, 1.0, log10( 1.0 ) );
printf( “log10(%.1f) = %.1f\n”, 10.0, log10( 10.0 ) );
printf( “log10(%.1f) = %.1f\n”, 100.0, log10( 100.0 ) );
 printf( “fabs(%.1f) = %.1f\n”, 13.5, fabs( 13.5 ) );
printf( “fabs(%.1f) = %.1f\n”, 0.0, fabs( 0.0 ) );
printf( “fabs(%.1f) = %.1f\n”, -13.5, fabs( -13.5 ) );

printf( “ceil(%.1f) = %.1f\n”, 9.2, ceil( 9.2 ) );

printf( “ceil(%.1f) = %.1f\n”, -9.8, ceil( -9.8 ) );

printf( “floor(%.1f) = %.1f\n”, 9.2, floor( 9.2 ) );

printf( “floor(%.1f) = %.1f\n”, -9.8, floor( -9.8 ) );

printf( “pow(%.1f, %.1f) = %.1f\n”, 2.0, 7.0, pow( 2.0, 7.0 ) );

printf( “pow(%.1f, %.1f) = %.1f\n”, 9.0, 0.5, pow( 9.0, 0.5 ) );

printf( “fmod(%.3f/%.3f) = %.3f\n”, 13.675, 2.333,

fmod( 13.675, 2.333 ) );

printf( “sin(%.1f) = %.1f\n”, 0.0, sin( 0.0 ) );

printf( “cos(%.1f) = %.1f\n”, 0.0, cos( 0.0 ) );

printf( “tan(%.1f) = %.1f\n”, 0.0, tan( 0.0 ) );

return 0; /* indica terminación exitosa */

} /* fin de main */

5.4 Indique el encabezado para cada una de las siguientes funciones.

a) La función hipotenusa que toma dos argumentos de punto flotante de precisión
doble, lado1 y lado2, y devuelve un resultado de punto flotante de precisión
doble.
double hipotenusa( double lado1, double lado2 )

b) La función el Menor que toma tres enteros, x, y, z, y devuelve un entero.

int elMenor( int x, int y, int z )

c) La función instrucciones que no recibe argumentos y no devuelve valor alguno.

[Nota: Por lo general, dichas funciones se utilizan para desplegar instrucciones
para el usuario.]
void instrucciones( void )

d) La función intAfloat que toma un argumento entero, numero, y devuelve un

resultado en punto flotante.
float intAfloat ( int numero )

5.5 Escriba el prototipo para cada una de las siguientes:

a) La función descrita en el ejercicio 5.4a.
double hipotenusa( double lado1, double lado2 );
b) La función descrita en el ejercicio 5.4b.
 int elMenor( int x, int y, int z );
c) La función descrita en el ejercicio 5.4c.
void instrucciones( void );
d) La función descrita en el ejercicio 5.4d.
float intAfloat ( int numero );

5.6 Escriba una declaración para lo siguiente:

a) El entero cuenta que debe mantenerse en un registro. Inicialice cuenta con 0.
register int cuenta = 0;
b) La variable de punto flotante ultValor que debe retener su valor entre las
llamadas a la función en la que se definió.
static float ultVal;
c) El entero externo número cuyo alcance debe restringirse al resto del archivo en
el que se definió.
static int numero;

5.7 Encuentre el error en cada uno de los segmentos de programa y explique cómo
puede corregir dicho error (vea también el ejercicio 5.50):
a) int g( void )
{
printf( “Dentro de la funcion g\n” );
int h( void )
{
printf( “Dentro de la función h\n” );
}
}

int g( void ), h(void);

{
printf( “Dentro de la funcion g\n” );

{
printf( “Dentro de la función h\n” );
}
}

b) int suma( int x, int y )

{
int resultado;
resultado = x + y;
}

int suma( int x, int y )

{
int resultado;
return x + y;
}

c) int suma( int n )

{
if ( n == 0 )
return 0;
else
n + suma( n – 1 );
}

int suma( int n )

{
if ( n == 0 )
return 0;
else
return n + suma( n – 1 );
}

d) void f( float a )
{
float a;
printf( “%f”, a );
}

void f( float a );
{

printf( “%f”, a );
}

e) void producto( void )

{
int a, b, c, resultado;
printf( “Introduzca tres enteros: ” )
scanf( “%d%d%d”, &a, &b, &c );
resultado = a * b * c;
printf( “El resultado es %d”, resultado );
return resultado;
}

void producto( void )

{
int a, b, c, resultado;
printf( “Introduzca tres enteros: ” )
scanf( “%d%d%d”, &a, &b, &c );
resultado = a * b * c;
printf( “El resultado es %d”, resultado );

5.9 Un estacionamiento cobra la cuota mínima de $2.00 por las tres primeras horas de
estacionamiento. El estacionamiento cobra $0.50 adicional por hora o fracción después
del tiempo mínimo. El cobro máximo para cualquier periodo de 24 horas es de $10.00.
Suponga que ningún automóvil se estaciona por más de 24 horas, al mismo tiempo que
otro. Escriba un programa que calcule e imprima los cobros por cada uno de los tres
clientes que se estacionaron ayer en el estacionamiento. Debe introducir el número de
horas que cada cliente pasó estacionado ahí. Su programa debe imprimir los resultados
en una forma tabular, y debe calcular e imprimir los recibos de las percepciones de ayer.
El programa debe utilizar la función calculaImporte para determinar el importe de cada
cliente. Sus salidas deben ser semejantes al formato siguiente:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

float calculaImporte(float horas);

int main()
{
float horas=0;
float importe=0;
float totalHoras=0;
float totalImporte=0;
int c=1;

printf("Ingrese horas de estacionamiento de cada automovil (0 para terminar):

");
scanf("%f",&horas);
printf("Automovil horas importe\n");

while(horas!=0){
importe=calculaImporte(horas);
printf("%-9d %10.1f %11.2f\n",c,horas,importe);
totalHoras+=horas;
totalImporte+=importe;
c++;
scanf("%f",&horas);
}

printf("Total%15.1f %7.2f\n",totalHoras,totalImporte);

return 0;
}

float calculaImporte(float horas)

{
float costo=0;

if(horas<=3) costo=2;
if(horas>3 && horas<19) costo=2+0.5*(ceil(horas)-3);
if(horas>=19) costo=10;
 return costo;
}

5.11 La función floor puede utilizarse para redondear un número a una posición decimal
determinada. La instrucción:
y = floor( x * 10 + .5 ) / 10; redondea x a la posición de las décimas (la primera
posición a la derecha del punto decimal). La instrucción y = floor( x * 10 + .5 ) / 100;
redondea x a la posición de las centésimas (la segunda posición a la derecha del punto
decimal). Escriba un programa que defina cuatro funciones para redondear al número x
de distintas maneras:
a) redondeaAentero( numero )
#include<stdio.h>
float floor(float)
Void main()
{
Float a;
Int x;
Printf( “Numero ”);
Scanf(“%f”,&a);

x= floor(a+.5);
Printf( “El valor es :”,x);
}

b) redondeaAdecimas ( numero )
#include<stdio.h>
float floor(float)
Void main()
{
float a;
Int x;
Printf( “Numero ”);
Scanf(“%f”,&a);

x= floor( a * 10 + .5 ) / 10
Printf( “El valor es :”,x);
}

c) redondeaAcentesimas ( numero )
#include<stdio.h>
float floor(float)
Void main()
{
float a;
Int x;
Printf( “Numero ”);
Scanf(“%f”,&a);

n= floor( a * 10 + .5 ) / 100
Printf( “El valor es :”,x);
 }

d) redondeaAmilesimas ( numero )
#include<stdio.h>
float floor(float)
int] main()
{
float a;
Int n1,n2,n3;
Printf( “Numero ”);
Scanf(“%f”,&a);

n1= floor(x+.5);
n2= floor( a * 10 + .5 ) / 10;
n3= floor( a * 10 + .5 ) / 100;
Printf( “El valor es :”,n1);
Printf( “El valor es :”,n2);
Printf( “El valor es :”,n3);

Por cada valor leído, su programa debe imprimir el valor original, el número
redondeado al entero más cercano, el número redondeado a la décima más cercana, el
número redondeado a la centésima más cercana, y el número redondeado a la milésima
más cercana.

#include<iostream>
#include<math>

using namespace std;

double redonunidades(double v)
{
return floor((v*10+.5)/10);
double redondecenas(double v);
{
return floor((v*100+.5)/100);
double redoncentenas(double v);
{
return floor((v*1000+.5)/1000)

double redonmillar(double v);

{
return floor((v*10000+.5)/10000);
int main ()
{
double cantidad;
cout<<"Ingresar numero decimal";
cin>>cantidad;
cout<<redonunidades(cantidad)<<"redondea unidades"<<endl;
cout<<redondecenas(cantidad)<<"redondea unidades"<<endl;
cout<<redoncentenas(cantidad)<<"redondea unidades"<<endl;
 cout<<redonmillar(cantidad)<<"redondea unidades"<<endl;

return 0;
}

5.13 Escriba instrucciones que asignen enteros de manera aleatoria a la variable n en los
siguientes rangos:
a) 1 ≤ n ≤ 2
b) 1 ≤ n ≤ 100
c) 0 ≤ n ≤ 9
d) 1000 ≤ n ≤ 1112
e) _1 ≤ n ≤ 1
f) _3 ≤ n ≤ 11

#include<iostream>
#include <ctime>
#include<cstdlib>

using namespace std;

void aleatorio(){

int x, y, z, a, b, c;

srand(time(NULL));
a = rand()%(1 - 2 + 1);
b = rand()%(1 - 100 + 1);
c = rand()%(0 - 9 + 1);
d = rand()%(1000 - 1112 + 1);
e = rand()%(-1 - 1 + 1);
f = rand()%(-3 - 11 + 1);

cout << "Rando x " << a << endl;

cout << "Rando y " << b << endl;
cout << "Rando z " << c << endl;
cout << "Rando a " << d << endl;
cout << "Rando b " << e << endl;
cout << "Rando c " << f << endl;

int main(){

void aleatorio();

return 0;
}

5.15 Defina una función llamada hipotenusa que calcule la longitud de la hipotenusa de
un triángulo recto, cuando se introducen los otros dos lados. Utilice esta función en un
programa que determine la longitud de la hipotenusa para cada uno de los siguientes
triángulos. La función debe tomar dos argumentos de tipo double y devolver la
hipotenusa como double. Verifique su programa con los valores de los lados
especificados en la figura 5.18.

#include<iostream>
#include<cmath>

using namespace std;

double hipotenusa(double l0, double l1){

double hipo;

hipo = pow(l0,2) + pow(l1, 2);

cout << "La hipotenusa es " << hipo;

int main(){

double l0, l1;

cout << "Ingrese la longitud del primer lado" << endl;

cin >> l0;
cout << "Ingrese la longitud del segundo lado" << endl;
cin >> l1;

hipotenusa(l0, l1);

return 0;
}

5.17 Escriba una función multiplo que determine para un par de enteros, si el segundo
es múltiplo del primero. La función debe tomar dos argumentos enteros y devolver 1
(verdadero) si el segundo es un múltiplo del primero, y de lo contrario 0 (falso). Utilice
esta función en un programa que introduzca una serie de pares de enteros.

#include<iostream>

using namespace std;

int multiplos(int n1, int n2){

if(n1 % n2 == 0){
 return 1;
}else{
return 0;
}
}

int main(){

int n1, n2;

cout << "Ingrese dos numeros " << endl;

cin >> n1 >> n2;

cout << "El resultado es " << multiplos(n1,n2);

return 0;
}

5.19 Escriba una función que despliegue en el margen izquierdo de la pantalla un

cuadrado sólido de asteriscos cuyas medidas se especifiquen mediante el parámetro
lado. Por ejemplo, si lado es 4, la función despliega:

#include <stdio.h>
int main()
{
int lado;
printf("Introduzca la medida de los lados de un cuadrado: ");
scanf("%d",&lado);
if(lado>=1 && lado<=20){
int contador =1;
while(contador<=lado){
int contador1 = 1;
while(contador1<=lado){
printf("*");
contador1++;
};
printf("\n");
contador++;

}
}
return 0;
}

5.21 Utilice técnicas similares a las empleadas en los ejercicios 5.19 y 5.20 para
producir un programa que grafique un número variado de figuras.
#include <stdio.h>
int main()
{
int lado;
printf("Introduzca la medida de los lados de un cuadrado: ");
scanf("%d",&lado);
if(lado>=1 && lado<=20){
int contador =1;
while(contador<=lado){
int contador1 = 1;
while(contador1<=lado){
printf("*");
printf("#");
printf("&");
printf("$");
contador1++;
};
printf("\n");
contador++;

}
}
return 0;
}

5.23 Escriba una función que tome el tiempo en tres argumentos enteros (para horas,
minutos, y segundos), y que devuelva el número de segundos desde la última vez que el
reloj “marcó las 12”. Utilice esta función para calcular los segundos que existen entre
dos horas, las cuales se miden con el ciclo de 12 horas del reloj.

5.25 Escriba una función que devuelva el más pequeño de tres números de punto
flotante.
#include<iostream.h>

int main()
{
Int n1,n2,n3;
Printf( “Primer Numero ”);
Scanf(“%f”,&n1);
Printf( “segundo Numero ”);
Scanf(“%f”,&n2);
Printf( “segundo Numero ”);
Scanf(“%f”,&n3);
If (n1<= n2 && n1<=n3)
Printf( “Numero Menor ”,n1);
else
If (n2>n3)
Printf( “Numero Menor ”,n2);
else
Printf( “Numero Menor ”,n3);
 return 0;
}

5.27 Se dice que un entero es primo si sólo es divisible entre 1 y entre sí mismo. Por
ejemplo, 2, 3, 5 y 7 son primos, pero 4, 6, 8 y 9 no lo son.
a) Escriba una función que determine si un número es primo.
#include <stdio.h>

int esPrimo (int n)

{
int r, res;

if(n != 1)

b) Utilice esta función en un programa que determine e imprima todos los números
primos entre 1 y 10,000. ¿Cuántos de estos 10,000 números tiene que verificar
realmente antes de que esté seguro de que encontró todos los números primos?
#include<iostream>
#include<iomanip>
using namespace std;
int primos();

int main()
{
primos();
}
int primos()
{

cout<<"Numeros primos entre 20 y 100:"<<endl;

int i;
for(int n=2; n<10000; n++)
{
for(i=2; n%i; i++);
if(i==n) cout<<setw(6)<<n;
}
cout<<endl;
getchar();
return 0;
}
c) Inicialmente podría usted pensar que n/2 es el límite máximo que debe probar para
ver si un número es primo, pero sólo necesita ir tan arriba como la raíz cuadrada de n.
¿Por qué? Rescriba el programa, y ejecútelo de ambas maneras. Estime la mejora en el
rendimiento.
5.29 El máximo común divisor (MCD) de dos enteros es el entero más grande que
divide cada uno de los números. Escriba un programa mcd que devuelva el máximo
común divisor de dos enteros.

#include<stdio.h>

int main ()
{
int n1,n2;
int residuo, mcd;

printf("Ingresar un numero");
scanf("%d",&n1);

printf("Ingresar un numero");
scanf("%d",&n2);

do{
residuo=n1%n2;
if(residuo !=0)
{
n1=n2;
n2=residuo;
}
else
{
mcd=n2;
}
} while(residuo != 0);

printf("MCD:%d\n", mcd);

return 0;

5.30 Escriba una función puntosCalidad que tome el promedio de un estudiante y

devuelva 4 si el promedio del estudiante está entre 90-100, 3 si el promedio es 80-89, 2
si el promedio es 70-79, 1 si el promedio es 60-69, y 0 si el promedio es menor que 60.

#include <iostream.h>
#include <conio.h>

template <class T>

T promedio(T cal1, T cal2, T cal3, T cal4);
template <class T>
int puntosCalidad(T cal1, T cal2, T cal3, T cal4);

void main (){

float c1, c2, c3, c4;
char nombre[15];
int puntos;
char continuar;
float prom;

do{
clrscr();
cout<<"Nombre del estudiante: ";
cin>>nombre;
cout<<"Calificacion 1: ";
cin>>c1;
cout<<"Calificacion 2: ";
cin>>c2;
cout<<"Calificacion 3: ";
cin>>c3;
cout<<"Calificacion 4: ";
cin>>c4;

prom=promedio(c1,c2,c3,c4);

cout<<"Nombre del estudiante: "<<nombre<<" promedio "<<prom<<" puntos de

calidad "<<puntosCalidad(c1,c2,c3,c4)<<endl;

cout<<"Registar otro alumno: ";

cin>>continuar;
}
while(continuar=='s'||continuar=='S');

getch();
}

template <class T>

T promedio(T cal1, T cal2, T cal3, T cal4){

return (cal1+cal2+cal3+cal4)/4;
}

template <class T>

int puntosCalidad(T cal1, T cal2, T cal3, T cal4){

T p=promedio(cal1,cal2, cal3, cal4);
if(p>=90&&p<=100)
return 4;
else{
if(p>=80)
return 3;
else{
if(p>=70)
return 2;
else{
if(p>=60)
return 1;
else{
return 0;
}