Practica Nº5

PROGRAMACION ALGORITMOS Y ESTRUCTURAS DE DATOS
PRACTICA N° 4
Ámbito de las variables. Utilización de punteros
1. Dados los siguientes programas. Indique las salidas por pantalla que generan.
1.a
int x;
void Calculo( );
int main( )
{
x = 10;
Calculo( );
printf(“x = %d\n”, x);
return 0;
}
void Calculo( )
{
int x;
x = x + 7;
return;
}
1. b
int x;
void Calculo(int *n);
int main()
{
x = 20;
Calculo(&x);
printf(“x = %d\n”, x);
return 0;
}
void Calculo(int *n)
{
x = x + 5;
*n = *n + 3;
return;
}
2. Dado el siguiente programa. Seleccione la salida correcta.
int x;
int f(int n);
int main( )
a) 10 10
{x = 6;
b) 10 6
printf(“%d %d”, f(x), x);
c) 6 10
}
int f(int n)
d) 6 6
{
n = n + 4;
return n;}
1
3. Sea el siguiente programa:
int x, y;
void fun1(int *x, int y);
int main()
{
x = 13; y = 12;
fun1(&x, y);
fun1(&y, x);
printf(“x = %d y = %d \n, x, y);
}
void fun1(int *x, int y)
{
y = *x;
*x = y;
}
4. Dado el siguiente programa:
int x, y;
void funx(int *x, int *y);
int main( )
{
x = 1; y = 2;
funx(&y, &x);
printf(“x = %d y = %d\n”, x, y);
}
void funx(int *x, int *y)
{
*x = *y + 2;
*y = *x + 2;
}
Indique la salida correcta
(a) 12 13
(b) 13 13
(c) 13 12
(d) 12 12
¿Cuál será la salida por
pantalla?
________________________
Trazas de Programas
5. Seguir la traza de los programas manualmente y determinar que imprimen en pantalla. Verifique
el resultado utilizando el duparador del IDE de Dev C++.
5.a)
int a, b;
void E2(int a, int b);
int main()
{
1 a = 1;
2 b = 2;
3 E2(b, a);
printf(“%d %d\n”,a,b);
return 0;
}
void E2(int a, int b)
{
4 a = 10;
printf(“%d %d\n”,a,b);
return;
}
2
5.b
int y, z;
void Cambiar(int *i, int j);
int main()
{
1 y = 21;
2 z = 7;
3 Cambiar(&y, z);
4 Cambiar(&z, y);
printf(“%z=%d y=%d\n”,z,y);
return 0;
}
void Cambiar(int *i, int j)
{
int k;
5 k = j;
6 *i = k + j;
7 k = *i;
return;
}
6.Escriba una función de nombre puntoscorte( ), que tenga como parámetros los centros y radios
de dos circunsferencias y retorne los puntos que tienen en común dichas circunferencias ( ninguno,
uno, dos o infinitos).
7.Realice una función de nombre Calcular( ) que tenga como primer argumento un arreglo de
elementos tipo double y como segundo el tamaño del mismo. Complete los parámetros y el valor de
retorno para obtener de la función la media aritmética y la cantidad de veces que se repite el
máximo y la cantidad de veces que se repite el mínimo en el arreglo.
8.a) Hacer una función para conocer el número de veces que aparecen cada dígito decimal en un
determinado número natural. El primer argumento de la función será el valor del número a analizar
de tipo unsigned long int y el segundo será un arreglo de 10 elementos del tipo unsigned int donde
se guardarán las ocurrencias correspondientes a cada dígito. Por ejemplo, para el número 248282,
la función deberá devolver todo el array a cero, excepto la posición 2 que tendrá un 3, la posición
4 que tendrá un 1 y la posición 8 que tendrá un 2.
b) El programa principal deberá leer un número por teclado, llamar a la función anterior y mostrar
en pantalla el número de veces que se repite cada dígito entre 0 y 9 en el número dado, evitando
mostrar los dígitos que no existen en el número original. Al final, mostrará el número de dígitos
total del número introducido.
Por ejemplo, para el ejemplo anterior del número 248282 el programa deberá mostrar las
siguientes líneas:
Número de dígitos 2: 3
Número de dígitos 4: 1
Número de dígitos 8: 2
Número total de dígitos: 6
3
Cadenas de Caracteres.
9. a) Realice una función de nombre cadlen( ) que retorne la cantidad de caracteres presentes en una
cadena pasada como argumento.
b)Realice una función de nombre cadcat( ), que tenga como primer argumento la cadena destino y
como segundo la cadena origen a añadir al final de la cadena destino.
c) Realice un programa que verifique el funcionamiento de las funciones. Utilice un archivo de
cabecera cadenas.h que contenga las definiciones de dichas funciones.
Recursividad.
10. Escribir una función recursiva que reciba como parámetro un valor numérico entero y positivo
en base 10, y lo pase al sistema de numeración binario, mostrando el resultado en pantalla.
11. Escribir una función recursiva que muestre en pantalla los dígitos de un valor numérico en
orden inverso.
12. Calcular el términa enésimo de la sucesión de Fibonacci en forma recursiva.
la sucesión de Fibonacci es 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
13. Calcular en forma recursiva el MCD máximo común divisor de dos números m y n.
• Problema Especial Grupo Miércoles
Una pila es un tipo especial de estructura de datos abierta en la que sólo se pueden insertar y
eliminar datos desde uno de los extremos de la misma. Las operaciones que podemos realizar
sobre una pila son: Insertar un dato, Leer un dato con la correspondiente eliminación del mismo e
Imprimir. Estas características implican un comportamiento LIFO (Last In First Out), el último
en entrar es el primero en salir. El símil del que deriva el nombre de la estructura es una pila de
platos. Sólo es posible añadir platos en la parte superior de la pila, y sólo pueden tomarse del
mismo extremo.
El problema especial consiste en implementar una pila simple utilizando arreglos de datos y
manejando punteros. El programa deberá presentar un menú al usuario como el que se detalla a
continuación:
Operaciones sobre una pila:
1. Insertar
2. Leer
3. Imprimir
4. Salir
Entre una Opción:
El alumno deberá implementar las tres funciones Insertar ( int pila[],int *frente, int dato);
Int Leer (int pila[ ], int *frente, int *final) e Imprimir (int pila[], int frente, int final);
•
Problema Especial Grupo Viernes
Una cola es un tipo especial de arreglo en la que sólo se pueden insertar datos por uno de los
extremos del arreglo y sólo se pueden eliminar datos por el otro. Las escrituras de datos siempre
son inserciones de elementos del arreglo, y las lecturas siempre eliminan el elemento leído. ste
tipo de estructura es conocido como FIFO (First In First Out), el primero en entrar es el primero
en salir.
El símil cotidiano es una cola para comprar as entradas del cine. Los nuevos compradores sólo
pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.
4
El problema especial consiste en implementar una cola simple utilizando arreglos de datos y manejo
de punteros. El programa deberá presentar un menú al usuario como el que se detalla a
continuación:
Operaciones sobre una pila:
1. Insertar
2. Leer
3. Imprimir
4. Salir
Entre una Opción:
El alumno deberá implementar las tres funciones Insertar ( int pila[ ],int *frente, int dato);
Int Leer (int pila[ ], int *frente, int *final) e Imprimir (int pila[ ], int frente, int final);
5