4-PADINI

Esta es una vista previa del archivo. Inicie sesión para ver el archivo original

4-PADINI/1/absoluto.c
#include <stdio.h>
#include <assert.h>
int main(void)
{
 int pedirEntero(void){
 int x;
 printf("ingresa un valor \n");
 scanf("%d",&x);
 return x;
 }
 int x = pedirEntero();
 if(x <= 0)
 {
 x = x * (-1);
 }else{
 }
printf("El valor absoluto es %d\n",x);
return 0;
}
4-PADINI/1/ejercicio01.c
#include <stdio.h>
#include <assert.h>
int main(void){
 int pedirEntero(void){
 int t;
 printf("ingresa el valor de hola \n");
 scanf("%d",&t);
 return t;
 }
 void imprimeEntero(void){
 printf("Hola\n");
 }
 void holaHasta(void){
 int i;
 int n;
 n = pedirEntero();
 assert(n>0);
 i = 0;
 while(i < n){
 imprimeEntero();
 i = i+1;
 }
}
holaHasta();
return 0;
}
4-PADINI/1/intercambio.c
#include <stdio.h>
#include <assert.h>
int main(void)
{
 int pedirEntero(void)
 {
 int x;
 printf("ingresa un valor \n");
 scanf("%d",&x);
 return x;
 }
 int e;
 int x = pedirEntero();
 int y = pedirEntero();
 int z = pedirEntero();
 e = z;
 z = x;
 x = y;
 y = e;
 
 printf ("los valores finales son: x= %d, y = %d y z = %d ", x,y,z);
 
return 0;
}
4-PADINI/1/intercambiovar.c
#include <stdio.h>
int pedirEntero(void){
 int x;
 printf("Ingrese un entero:\n ");
 scanf("%d", &x);
 return x;
}
int main()
{
 int x,y,z, X, Y;
 x = pedirEntero();
 y = pedirEntero();
 printf("ingrese x,y: ");
 scanf("%d %d", &x, &y);
 X = x;
 Y = y;
 
 z = x;
 x = y;
 y = z;
 printf("los valores finales son: %d %d %d\n",x,y);
 assert(x == Y && y == z);
 return 0;
}
4-PADINI/1/minimo.c
#include <stdio.h>
#include <assert.h>
int main()
{
 int pedirEntero(void) {
 int t;
 printf("ingresa un valor \n");
 scanf("%d",&t);
 return t;
 }
 int x,e,i;
 x = pedirEntero();
 e = pedirEntero();
 if (x>e)
 {
 i = e;
 } else {
 i = x;
 assert(i <= e || e<= i);
 }
 printf("el minimo es %d\n",i);
 return 0;
}
4-PADINI/10/stats.c
#include <stdio.h>
#include <stdbool.h>
#define TAM 5
int pedirEntero(void){
 int x;
 scanf("%d", &x);
 return x;
}
void pedirArreglo(float a[], int tam)
{
 int i= 0;
 while (i < tam)
 {
 printf("[%d/%d] ingrese el elemento %i: ", (i + 1), tam, i);
 a[i] = pedirEntero();
 i++;
 }
 
}
struct datos_t
{
 float maximo;
 float minimo;
 float promedio;
};
struct datos_t stats(float a[], int tam) 
{
 int i = 0;
 float suma = 0;
 struct datos_t res;
 res.maximo = a[0];
 res.minimo = a[0];
 res.promedio = 0;
 while (i < tam)
 { 
 if (a[i] < res.minimo){
 res.minimo = a[i];
 }else if (a[i] > res.maximo) {
 res.maximo = a[i];
 } 
 float suma = suma + a[i];
 i++;
 }
 res.promedio = suma / tam;
 return res;
 
}
int main(void){
 float a[TAM];
 pedirArreglo(a, TAM);
 struct datos_t res = stats(a, TAM);
 printf("el valor minimo del arreglo es %.2f\n\n", res.minimo);
 printf("el valor maximo del arreglo es %.2f\n\n", res.maximo);
 printf("el valor promedio del arreglo es %.2f\n\n", res.promedio);
 return 0;
}
4-PADINI/11/nprimo.c
#include <stdio.h>
#include <stdbool.h>
bool es_primo(int x)
{
 int i=2;
 bool res = true;
 while (i<x && res)
 {
 if(x % i == 0)
 res=false;
 i = i + 1;
 
 }
 return res;
}
int pedirEntero(void)
{
 int x;
 printf("ingrese el entero: ");
 scanf ("%d", &x);
 return x;
}
int nesimo_primo(int N)
{
 int x = 2;
 int i = 1;
 while (i < N)
 {
 if (es_primo(x))
 {
 i= i + 1;
 }
 x = x + 1;
 }
 return x;
}
int main(void)
{
 int x = pedirEntero();
 /* while (x<0)
 {
 printf("usted ingreso un negativo. ingrese un positivo\n");
 x = pedirEntero();
 }*/
 int i = 1;
 int primo = nesimo_primo(x);
 printf("el n-esimo primo es %d\n", primo);
 return 0;
}
 
 
 
4-PADINI/12/persona.c
#include <stdio.h>
#include <stdbool.h>
typedef struct _persona {
 char nombre;
 int edad;
 float altura;
 float peso;
}persona_t;
float peso_promedio (persona_t a[], unsigned int longitud){
 float promedio_pesos;
 float suma_pesos = 0;
 unsigned int i = 0;
 while (i < longitud){
 suma_pesos = suma_pesos + a[i].peso;
 i++;
 }
 promedio_pesos = suma_pesos / longitud;
 return promedio_pesos;
 
}
persona_t persona_de_mayor_edad(persona_t a[], unsigned int longitud){
 unsigned int i = 0;
 float mayor = -1000;
 persona_t mayorPersona;
 while (i < longitud){
 if (a[i].edad > mayor){
 mayor = a[i].edad;
 mayorPersona = a[i];
 }
 i++;
 }
 return mayorPersona;
}
persona_t persona_de_menor_altura(persona_t a[], unsigned int longitud){
 unsigned int i = 0;
 float menor = 1000;
 persona_t menorAlturaPersona;
 while (i < longitud) {
 if (a[i].altura < menor ){
 menor = a[i].altura;
 menorAlturaPersona = a[i];
 }
 i++;
 }
 return menorAlturaPersona;
}
int main(void){
 persona_t p1 = {"paola", 23, 1.67, 60};
 persona_t p3 = {"julio", 45, 1.78, 80};
 persona_t p2;
 persona_t p4;
 persona_t p5;
 p2.nombre = "pablo";
 p2.edad = 54;
 p2.altura = 1.80;
 p2.peso = 79;
 persona_t a[] = {p1,p2,p3};
 printf("el peso promedio es %f\n", peso_promedio(a,3));
 p4= persona_de_mayor_edad(a,3);
 printf("la edad de la persona de mayor edad es %d\n", p4.edad);
 p5= persona_de_menor_altura(a,3);
 printf("la persona de menor altura es %f\n", p5.altura);
 return 0;
}
4-PADINI/2/multiple1.c
#include <stdio.h>
int main(){
 int X,Y;
 int x;
 int y;
 printf("ingrese un valor para X:\n", X);
 scanf("%d", &X);
 printf("ingrese un valor para Y:\n");
 scanf("%d", &Y);
 x= X;
 y= Y;
 x = X + 1;
	y = X + y;
 if ((x== x + 1) && (y= X + Y)){
 printf("True\n");
 }else
 {
 printf("False\n");
 }
 return 0;
}
4-PADINI/2/multiple2.c
#include <stdio.h>
#include <assert.h>
int pedirEntero();
int main(){
 int y, x, z, yaux, X, Y, Z;
 x = pedirEntero();
 y = pedirEntero();
 z = pedirEntero();
 X = x;
 Y = y;
 Z = z;
 assert(x==X && y == Y && z == Z);
 yaux=y;
 y = Y + X + Z;
 z = yaux + x;
 x = yaux;
 assert(x==Y && y == X + Y + Z && z == X + Y);
 printf("el nuevo valor de x es: %d\n", x);
 printf("el nuevo valor de y es: %d\n", y);
 printf("el nuevo valor de z es: %d\n", z);
 return 0;
}
4-PADINI/3/suma_hasta.c
#include <stdio.h>
#include <assert.h>
int pedirEntero(void){
 int n;
 printf("ingrese un numero:\n");
 scanf("%d", &n);
 return n;
}
int suma_hasta(int n){
 int i = 1;
 int suma = 0;
 while (i <= n)
 {
 suma = suma + i;
 i = i + 1;
 }
 return suma;
}
int main (void){
 int num, res;
 num = pedirEntero();
 assert(num > 0);
 res = suma_hasta(num);
 assert(res == num * (num + 1)/2);
	printf("La sumatoria desde 1 hasta %d es: %d\n", num, res);
 
 /*
 if(N<0){
		printf("Error, el número debe ser positivo.\n");
	}
	else{
 res = suma_hasta(num);
		printf("La sumatoria desde 1 hasta %d es: %d", num, res);
	}
*/
 return 0;
}
4-PADINI/4/division.c
#include <stdio.h>
#include <assert.h>
int pedirEntero(){
 int x;
 printf("shut up and dame un entero: \n");
 scanf("%d", &x);
 return x;
}
struct div_t 
{
 int cociente;
 int resto
};
struct div_t division (int x, int y) {
 struct div_t res;
 res.cociente = x / y;
 res.resto = x % y;
 return res;
}
int main(void){
 int x = pedirEntero();
 int y = pedirEntero();
 if((x < 0 || y < 0))
 {
 printf("Error, siga participando\n");
 return
0;
 }else if (y== 0)
 {
 printf("Error, señore la division por cero no existe\n");
 return 0;
 }else
 {
 struct div_t res = division (x,y);
 printf("el cociente de dividir %d entre %d es %d \n", x, y, res.cociente);
 printf("el resto de dividir %d entre %d es %d \n", x, y, res.resto);
 }
 return 0;
}
4-PADINI/5/entsalidaarreglo.c
#include <stdio.h>
#include <assert.h>
void pedirArreglo (int a[], int n_max){
 int i = 0;
 while (i < n_max)
 {
 int elem;
 printf("ingrese el elemento en la posicion %d\n", i);
 scanf("%d", &elem);
 a[i] = elem;
 i = i +1;
 }
 
}
void imprimeArreglo (int a[], int n_max){
 int i=0;
 while (i< n_max)
 {
 printf("%d", a[i]);
 i = i + 1;
 }
 printf (" \n");
}
int main(void){
 
 int N, array [5];
 printf("ingrese el tamaño del array \n"), scanf("%d", &N);
 assert (N > 0 && N <= 5 );
 pedirArreglo (array, N);
 imprimeArreglo (array, N);
 return 0;
}
4-PADINI/6/sumatoria.c
#include <stdio.h>
#include <assert.h>
#define TAM 5
int pedirEntero(void){
 int n;
 printf("ingrese un numero:\n");
 scanf("%d", &n);
 return n;
}
void pedirArreglo (int a[], int n_max){
 int i = 0;
 while (i < n_max)
 {
 int elem;
 printf("ingrese el elemento en la posicion %d\n", i);
 scanf("%d", &elem);
 a[i] = elem;
 i = i +1;
 }
 
}
void imprimeArreglo (int a[], int n_max){
 int i=0;
 while (i< n_max)
 {
 printf("%d", a[i]);
 i = i + 1;
 }
 printf ("\n");
}
int sumatoria (int a[], int n_max)
{
 int i = 0;
 int suma = 0;
 while (i < n_max)
 {
 suma = suma + a[i];
 i = i + 1;
 }
 
 return suma;
}
int main(void){
 
 int suma;
 int array[TAM];
 int N = pedirEntero();
 pedirArreglo(array, N);
 suma = sumatoria (array, N);
 printf("suma = %d\n", suma);
 return 0;
}
4-PADINI/7/positivo.c
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
int pedirEntero(void){
 int n;
 printf("ingrese un numero:\n");
 scanf("%d", &n);
 return n;
}
void pedirArreglo (int a[], int n_max){
 int i = 0;
 while (i < n_max)
 {
 int elem;
 printf("ingrese el elemento en la posicion %d\n", i);
 scanf("%d", &elem);
 a[i] = elem;
 i = i +1;
 }
 
}
bool existe_positivo(int a[], int tam) {
 bool res = false;
 int i = 0;
 while (i < tam && !res)
 {
 if(a[i] >= 0) {
 res = 1;
 
 }
 i++; 
 }
 return res;
 
}
bool todos_positivos(int a[], int tam) {
 bool res = true; // por rango vacio
 int i = 0;
 while (i < tam && res)
 {
 if(a[i] < 0) {
 res = false;
 
 } 
 i++; 
 }
 return res;
 
}
int main (){
 int N, array[1000];
 bool existePos, todosPos;
 N = pedirEntero();
 assert (N>0);
 pedirArreglo(array, N);
 printf("ingrese 1 si desea ejecutar todos_positivos u otro si desea que existan positivos: /n");
 int menu = pedirEntero();
 if (menu == 1) {
 todosPos = todos_positivos (array,N);
 printf("todosPos = %d\n", todosPos);
 }else {
 existePos = existe_positivo (array,N);
 printf("existePos = %d\n", existePos);
 }
 return 0;
 
}
4-PADINI/7/positivos.c
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main(void){
 
 int x; 
 printf("ingrese tamaño del arreglo \n");
 scanf("%d",&x);
 int b[x];
 
 void pedirArreglo(int a[], int n_max){
 
 int i;
 i=0;
 while(i < n_max){
 printf("ingrese el %dº elemento del arreglo \n",i+1);
 scanf("%d",&a[i]);
 i=i+1;
 }
 }
 pedirArreglo(b,x);
 bool existe_positivo(int a[], int tam){
 bool algo; // 0 false 1 true
 algo =false;
 int i;
 i=0;
 
 while (i < tam && algo == 0){
 if(a[i]>0){
 algo=true;
 }
 i=i+1;
 }
 return algo;
 }
 bool todos_positivos(int a[], int tam){
 bool algo;
 algo=true;
 int i;
 i=0;
 while (i<tam && algo==1){
 if(a[i]<0){
 algo=false;
 }
 i=i+1;
 }
 return algo; 
 }
 int g;
 printf("si desea ver si existen positivos en el arreglo ingrese 1 \nsi desea saber si todos los elementos del arreglo son positivos ingrese 2\n");
 scanf("%d",&g);
 bool h;
 
 if(g == 1){
 h = existe_positivo(b,x);
 }else{
 h = todos_positivos(b,x);
 }
 printf("%d \n",h);
 void imprimeArreglo(int a[], int n_max){
 
 printf("el arreglo resultante es \n");
 int i;
 i=0;
 printf("[");
 while(i<n_max){
 printf("%d,",a[i]);
 i=i+1;
 }
 printf("] \n");
 }
 imprimeArreglo(b,x);
 return 0;
}
4-PADINI/8/intercambio_arreglo.c
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
int main(){
	int N;
	printf("Ingrese el tamaño del arreglo:\n");
	scanf("%i",&N);
	int arreglo[N];
	int n = 0;
	while(n<N){
		printf("Ingrese el elemento %i/%i del arreglo.\n",n,N-1);
		scanf("%i",&arreglo[n]);
		n = n+1;
	}
	int i,j;
	
	printf("Ingrese la primera posición a intercambiar:\n");
	scanf("%i",&i);
	assert(i<=N);
	
	printf("Ingrese la segunda posición a intercambiar:\n");
	scanf("%i",&j);
	assert(j<=N);
	int x = arreglo[i];
	arreglo[i] = arreglo[j];
	arreglo[j] = x;
	n = 0;
	while(n < N){
		printf("Elemento en posición %i: %i \n",n,arreglo[n]);
		n = n+1;
	}
}
4-PADINI/8/intercambio_arreglos.c
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
int pedirEntero(void){
 int n;
 printf("ingrese un numero:\n");
 scanf("%d", &n);
 return n;
}
void pedirArreglo (int a[], int n_max){
 int i = 0;
 while (i < n_max)
 {
 int elem;
 printf("ingrese el elemento en la posicion %d\n", i);
 scanf("%d", &elem);
 a[i] = elem;
 i = i +1;
 }
 
}
void imprimeArreglo(int a[], int n_max){ 
int i=0;
 while (i< n_max)
 {
 printf("%d", a[i]);
 i = i + 1;
 }
 printf ("\n");
}
void intercambiar(int a[], int tam,int i, int j){
 int z;
 z = a[i];
 a[i] = a[j];
 a[j] = z;
}
int main (){
 int N, array[1000], pos1, pos2;
 printf("ingrese el tam del arreglo: \n"); scanf("%d", &N);
 assert(N>0);
 pedirArreglo(array,N);
 printf("ingrese las posiciones que desea intercambiar: \n"); scanf("%d", &pos1);scanf("%d", &pos2);
 assert (0<=pos1 && 0<=pos2 && pos1<N && pos2 < N);
 intercambiar(array,N,pos1,pos2);
 printf("su nuevo vector es: \n");
 imprimeArreglo(array, N);
 return 0;
 
}
4-PADINI/9/cuantos1.c
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main(void){
 
 int t; 
 printf("ingrese tamaño del arreglo \n");
 scanf("%d",&t);
 int b[t];
 
 void pedirArreglo(int a[], int n_max){
 
 int i;
 i=0;
 while(i<n_max){
 printf("ingrese el %dº elemento del arreglo \n",i+1);
 scanf("%d",&a[i]);
 i=i+1;
 }
 }
 pedirArreglo(b,t);
 struct comp_t {
 int menores;
 int iguales;
 int mayores;
 };
 struct comp_t esto;
 struct comp_t cuantos(int a[], int tam, int elem){
 int i;
 i=0;
 struct comp_t otro;
 otro.menores=0;
 otro.mayores=0;
 otro.iguales=0;
 while(i < tam){
 if(a[i]==elem){
 otro.iguales=otro.iguales+1;
 }
 if(a[i]<elem){
 otro.menores=otro.menores+1;
 }
 if(a[i]>elem){
 otro.mayores=otro.mayores+1;
 }
 i=i+1;
 }
 return otro;
 }
 int z;
 printf("elija un numero cualquiera\n");
 scanf("%d",&z);
 esto = cuantos(b,t,z);
 
 printf("los menores son: %d\n los iguales son: %d\n los mayores son: %d\n ",esto.menores,esto.iguales,esto.mayores);
 
 void imprimeArreglo(int a[], int n_max){
 
 printf("el arreglo resultante
es este \n");
 int i;
 i=0;
 printf("[");
 while(i<n_max){
 printf("%d,",a[i]);
 i=i+1;
 }
 printf("] \n");
 }
 imprimeArreglo(b,t);
 return 0;
}
4-PADINI/DERIVACIONES1b.pdf
4-PADINI/Proy4_2020.pdf
Algoritmos y Estructuras de Datos I - Laboratorio
Proyecto 4
Programación Imperativa en C
El objetivo de este proyecto es:
Extender los conceptos relacionados con el desarrollo de programas en lenguaje C en base al
formalismo visto en el teórico/práctico de la materia.
Introducir el uso de la libreŕıa assert.h para garantizar el cumplimiento de estados.
Familiarizarse con el uso de Arreglos en el lenguaje “C”;
Definir tipos abstractos nuevos básicos, utilizando el comando struct.
1. Lenguaje “C”
A lo largo de todo el proyecto, se utilizará el lenguaje C, y algunas herramientas como el
GDB: The GNU Project Debugger, para ayudar a la comprensión del concepto de estado y
del paradigma imperativo.
En el caso del lenguaje “C”, para poder ejecutar un programa, lo vamos a tener que “compilar”, y
de esa manera generamos un archivo binario que podrá ser ejecutado en la computadora.
Cómo compilar en C:
Para compilar un archivo .c escribir en la terminal:
$> gcc -Wall -Wextra -std=c99 miarchivo.c -o miprograma
Para ejecutar escribir:
$> ./miprograma
Para compilar para gdb se debe agregar el flag -g al momento de compilar .c escribir en la
terminal:
$> gcc -Wall -Wextra -std=c99 -g miarchivo.c -o miprograma
Ejercicios
1. (Funciones en C, Assert) Escrib́ı los programas siguientes:
a) ejercicio01.c que lee una variable n de tipo int e imprime por pantalla “hola” n
veces. En esta ocasión el programa debe utilizar dos funciones a definir (además de la
función main). Programá en un archivo .c la función de prototipo:
void holaHasta(int n)
1
que dado un int n, imprime n veces “Hola”. (Usar una bucle while). La función main
pide un número en la entrada antes de llamar holaHasta (¿qué función podes usar ya
implementada?). Usá la función assert (ver teórico) para chequear que x > 0.
b) Los ejemplos que siguen a continuación han sido vistos en el teórico práctico. Para cada
uno de ellos, se debe obtener la pre y post condición y la derivación. Luego, se debe
traducir a Lenguaje C el programa y las pre y post condiciones utilizando el comando
assert.
(Ḿınimo) Cálculo del ḿınimo entre dos variables enteras x e y. El programa en C
se debe llamar minimo.c.
(Valor Absoluto) Especificar un programa que calcule el valor absoluto de un
número entero. Verificar que el programa es correcto, y luego traducir el programa
a C en un archivo nuevo llamado absoluto.c.
(Intercambio de variables) Considera el siguiente programa que intercambia los
valores de dos variables x e y de tipo Int.
z := x;
x := y;
y := z;
Nota: En todos los casos el programa en C, debe solicitar los valores de las variables
de entrada, e imprimir el resultado para que lo pueda ver el usuario.
2. (Asignaciones múltiples) Considerar las siguientes asignaciones múltiples
{Pre: x = X, y = Y}
x, y := x + 1, x + y
{Post: x = X + 1, y = X + Y}
{Pre: x = X, y = Y, z = Z}
x, y, z := y, y + x + z, y + x
{Post: x = Y, y = Y + X + Z, z = Y + X}
a) Escribir un programa equivalente que sólo use secuencias de asignaciones simples.
b) Traducir los programas resultantes a C en archivos nuevos llamados multiple1.c y
multiple2.c respectivamente.
Recordar: Como C no tiene asignaciones múltiples, siempre será necesario traducirlas primero
a secuencias de asignaciones simples.
3. (Función suma hasta) Crear un archivo llamado suma hasta.c, que contenga la función
int suma_hasta(int N)
que toma un número entero N como argumento, y devuelve la suma de los primeros N
naturales. En la función main pedir al usuario que ingrese el entero N, si es negativo imprimir
un mensaje de error, y si es no negativo imprimir el resultado devuelto por suma_hasta.
Ayuda: La función puede hacer un ciclo o directamente usar la fórmula de Gauss.
4. (Algoritmo de la división) Crear un archivo llamado division.c que contenga la siguiente
función:
struct div_t division(int x, int y){
...
}
donde la estructura div_t se define como
struct div_t {
int cociente;
int resto;
};
2
Esta función recibe dos enteros no negativos (divisor no nulo) y devuelve el cociente junto
con el resto de la división entera. En la función main pedir al usuario los dos números enteros,
imprimir un mensaje de error si el divisor es cero, o imprimir tanto el cociente como el resto
en otro caso.
5. (Arreglos, entrada-salida) Escribir un programa que solicite el ingreso de un arreglo de enteros
int a[] y luego imprime por pantalla. El programa debe utilizar dos nuevas funciones con
prototipo además de la función main:
una que dado un arreglo y su tamaño, solicita los valores del arreglo y los devuelve en
el mismo arreglo int a[] con prototipo:
void pedirArreglo(int a[], int n_max)
otra que imprime cada uno de los valores de arreglo int a[].
void imprimeArreglo(int a[], int n_max)
6. (Arreglos, Función sumatoria). Hacer un programa en un archivo con nombre sumatoria.c
que contenga la función
int sumatoria(int a[], int tam)
que recibe un arreglo y su tamaño como argumento, y devuelve la suma de sus elementos.
En la función main pedir los datos del arreglo al usuario asumiendo un tamaño constante.
7. (positivos). Hacer un programa en un archivo positivos.c que contenga las siguientes
funciones:
bool existe_positivo(int a[], int tam)
bool todos_positivos(int a[], int tam)
Estas funciones reciben un arreglo y su tamaño como argumento, y devuelven respectivamente
verdadero si existe un número positivo en el arreglo o si todos los elementos son positivos. En
la función main pedirle al usuario los elementos del arreglo (asumiendo un tamaño constante)
y luego permitirle elegir qué función ejecutar.
8. (Procedimiento intercambio). Hacer un programa en el archivo nuevo intercambio_arreglos.c
que contenga la siguiente función:
void intercambiar(int a[], int tam, int i, int j)
que recibe un arreglo, su tamaño y dos posiciones como argumento, e intercambia los
elementos del arreglo en dichas posiciones. En la función main pedirle al usuario que ingrese
los elementos del arreglo y las posiciones, chequear que las posiciones esten en el rango
correcto y luego imprimir en pantalla el arreglo modificado.
9. (Función cuantos). Hacer un programa en un archivo nuevo cuantos.c que calcula cuántos
elementos menores, iguales y mayores a un número hay en un arreglo. La función tiene el
siguiente tipo:
struct comp_t cuantos(int a[], int tam, int elem)
donde la estructura comp_t se define como sigue:
struct comp_t {
int menores;
int iguales;
int mayores;
};
La función toma un arreglo, su tamaño y un entero, y devuelve una estructura con tres enteros
que respectivamente indican cuántos elementos menores, iguales o mayores al argumento
hay en el arreglo. La función cuantos debe contener un único ciclo.
3
10. (Función stats). Hacer un programa en un archivo nuevo stats.c, que calcula el ḿınimo, el
máximo, y el promedio de un arreglo no vaćıo de números flotantes (tipo float). La función
tiene el siguiente tipo:
struct datos_t stats(float a[], int tam)
donde la estructura datos_t se define como sigue:
struct datos_t {
float maximo;
float minimo;
float promedio;
};
La función pedida debe implementarse con un único ciclo. En la función main pedir al usuario
los datos del arreglo e imprimir en pantalla los tres valores devueltos por la función.
11. (Función nesimo primo) En un archivo nuevo primo.c hacer una función
int nesimo_primo(int N)
que devuelve el n-ésimo primo.
a) En la función main pedir al usuario que ingrese el entero n, si es negativo imprimir un
mensaje de error, y si es no negativo imprimir el resultado devuelto por
nesimo_primo.
b) Modificar la función main, para que al ingresar un valor negativo, solicite un nuevo
valor hasta que se ingrese un n no negativo.
12. (Punto estrella). Se define el tipo persona_t como sigue:
typedef struct _persona {
char *nombre;
int edad;
float altura;
float peso;
} persona_t;
Definir las siguientes funciones:
float peso_promedio(persona_t arr[], unsigned int longitud);
persona_t persona_de_mayor_edad(persona_t arr[], unsigned int longitud);
persona_t persona_de_menor_altura(persona_t arr[], unsigned int longitud);
Las tres funciones toman como argumento un arreglo de personas y su longitud. Devuelven
respectivamente el promedio de peso, la persona de mayor edad y la persona de menor altura
que se encuentra en el arreglo. Ayuda: Para probar las funciones, hacer una función main
como la siguiente:
int main(void) {
persona_t p1 = {"Paola", 21, 1.85, 75};
persona_t p2 = {"Luis", 54, 1.75, 69};
persona_t p3 = {"Julio", 40, 1.70, 80};
unsigned int longitud = 3;
persona_t arr[] = {p1, p2, p3};
printf("El peso promedio es %f\n", peso_promedio(arr, longitud));
persona_t p = persona_de_mayor_edad(arr, longitud);
printf("El nombre de la persona con mayor edad es %s\n", p.nombre);
p = persona_de_menor_altura(arr, longitud);
printf("El nombre de la persona con menor altura es %s\n", p.nombre);
return 0;
}
4
		Lenguaje ``C''