Universidad Abierta y a Distancia de México

Curso:

Fundamentos de Programación

Nombre de la Actividad:

Unidad 5

Actividad 1. Estructuras de datos y arreglos en lenguaje C

Asesor Académico: Mtra. Nancy Rosalina Gutiérrez Soto

Docente en línea: Adriana Álvarez Gutiérrez

Alumno (a):

Blanca Adriana Barajas Ulloa ES172001648

Ing. en Desarrollo de Software

04 de marzo de 2018.
 Ejercicios

Ejercicio: A: arrregloNum
Análisis
Este programa se trata de solicitarle al usuario 3 números flotantes, los cuales serán almacenados
en un arreglo llamado elem que cuenta con 3 posiciones, se utiliza un “for” con un contador para ir
almacenando las respuestas en las diferentes posiciones, antes de finalizar se utiliza un “for” de
forma descendente para sacar los números almacenados y mostrárselos al usuario.

Pseudocódigo
Proceso arregloNum
Definir a Como entero;
Definir elem como real;
Dimension elem[3];

Para a<-0 Hasta 2 Con Paso 1 Hacer

Escribir 'Da un valor Flotante en posición: ', a;
Leer elem[a];
Fin Para

Para a<-2 Hasta 0 Con Paso -1 Hacer

Escribir 'Los elementos son: ', elem(a);
Fin Para
Esperar Tecla;
FinProceso
Prueba de Escritorio

EA-arregloNum.xlsx

Codificación
#include<stdio.h>
#include<conio.h>

int main() {
int a;
float elem[3];

for (a=0;a<=2;a++) {
printf("\nDa un valor Flotante en posici%cn %d: ",162,a);
scanf("%f",&elem[a]);
}
for (a=2;a>=0;a--) {
printf("\nLos elementos son: %.2lf\n",elem[a]);
}
getch();
}

Página 2
 Ejecución

Ejercicio: B promCalificaciones
Codificación
#include<stdio.h>
#include<stdlib.h>
#define TAM 10 //constante simbólica del tamaño del arreglo

int main() {
int calif[TAM], i;
double prom=0;

printf("************************************************\n");
printf("* El siguiente programa calcula el promedio de *\n");
printf("* un grupo de diez estudiantes *\n");
printf("************************************************\n");
for (i=0; i<TAM; i++)
{
printf("Proporciona calificaci%cn: ",162,i+1);
scanf("%d",&calif[i]);
prom=prom+calif[i];
}
//Cálculo e impresión del promedio
prom=prom/TAM;
printf("\nLas calificaciones ingresadas fueron: \n");
for (i=0; i<TAM; i++)
printf("\nCalificaci%cn %d: %d",162,i+1,calif[i]);

Página 3
 printf("\n\n\tPromedio= %.2f\n\n",prom);
system("pause");
}

Ejecución

Reflexión
Si no se utilizaran arreglos se tendrían que usar 10 diferentes variables para almacenar las
calificaciones, y poder mostrarlas y tendrían que solicitarse ya sea, una por una o todas a la vez y
asignarlas a las 10 diferentes variables, si fueran 1000 calificaciones sería un programa enorme y
demasiadas variables, mientras que con los arreglos solo es verificar que el arreglo si pueda
almacenar 1000 posiciones y el tamaño del código seria el mismo que ahorita, solo se modificaría
la variable TAM.

Página 4
Ejercicio: C determinante
Codificación

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

#define TAM 2 // Constante del tamaño de la matriz

main()
{
int i, j;
float det;
float A[TAM][TAM]; //declaración de la matriz

// Mensaje de bienvenida

printf("***************************************\n");
printf("* Determinante de una matriz A de 2x2 *\n");
printf("***************************************\n");
/* Lectura de la matriz A */

for(i=0; i<TAM; i++)

for(j=0; j<TAM; j++){
printf("\nProporciona el elemento A[%d][%d]: ", i,j);
scanf("%f", &A[i][j]);
}

det = A[0][0]*A[1][1] - A[0][1]*A[1][0];

printf("\nA: \n\t");

// Impresión de la matriz A

for(i=0; i<TAM; i++){

for(j=0; j<TAM; j++)
printf("%8.2f", A[i][j]);
printf("\n\t");
}
printf("\n\n\t\tDeterminante = %.2f\n\n", det);
system("pause");
}

Página 5
 Ejecución

A j0 j1
i0 1.2 3.4
i1 2.5 6.7

Ejercicio: D password
Análisis
Este programa le solicita al usuario su nombre y luego el password, posteriormente hace una
comparación entre el password introducido con el password que es el correcto, si el password es
correcto lo informa y a muestra un mensaje concatenando el mensaje de bienvenida más el
nombre introducido, si es incorrecto informa que es incorrecto.
Codificación
#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* se incluye la biblioteca de cadenas */

main( )
{

char pwscorrecto[9]="jk278la0"; // Clave correcta

char pwsingresado[9]; // para leer la clave que ingrese el usuario
char nombre[10]; // Para leer el nombre del usuario

Página 6
char mensaje[50]= "Bienvenido ";

/* Lectura de datos */
printf("Nombre: ");
gets(nombre); // Lectura de una cadena con espacios
printf("pasword: ");
scanf("%s",pwsingresado);

if (!strcmp(pwscorrecto,pwsingresado)){ /* comparación
de claves, si la función strmp regresa 0 si son iguales */
printf("Pasword Correcto \n");
strcat(mensaje,nombre); // pega al final de mensaje el nombre del usuario
puts(mensaje); // impresión de la cadena con salto de línea
}

else {
strcpy(mensaje, "Acceso Denegado"); // copia la cadena acceso denegado al mensaje
puts(mensaje); // imprime la cadena
}
system("pause");
}

Ejecución

Página 7
 Librería y sus funciones

La librería utilizada es string.h y es destinada a operaciones con cadenas.

Hace una comparación entre cadenas en este

strcmp(pwscorrecto,pwsingresado)
strcat(mensaje,nombre)
strcpy(mensaje, "Acceso
Denegado")
caso compara pwscorrecto con pwsingresado,
previamente se le asigno valor a pwscorrecto
Concatena dos cadenas, mensaje con un valor
previamente asignado + nombre un valor
solicitado al usuario.
Esta función reescribe el valor que tiene la
cadena mensaje, por uno nuevo “Acceso
Denegado”

Ejercicio: E perros
Codificación
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main(){

// Declaración de la estructura perro

struct perro{
char raza[20];
int edad;
float peso;
} fido, pluto = {"labrador", 7, 20} ; // inicialización de lavariable pluto

printf("*********************");
printf("\n* Comparando perros *");
printf("\n*********************");

printf("\n\nIngresa la raza de fido: ");

scanf("%s",&fido.raza); // lectura de la raza de fido

printf("Ingresa la edad de fido en a%cos: ", 164);

scanf("%d",&fido.edad); // lectura de la edad de fido

printf("Ingresa el peso de fido en kilos de fido: ");

scanf("%f",&fido.peso); // lectura de el peso de fido

// impresión de los elementos de las estructuras

printf("\nFido es de raza %s, tiene %d a%cos y pesa %.2f
kilos\n",fido.raza,fido.edad,164,fido.peso);
printf("\nPluto es de raza %s, tiene %d a%cos y pesa %.2f
kilos\n",pluto.raza,pluto.edad,164,pluto.peso);

Página 8
// comparación de los nombres que son cadenas
if(!strcmp(pluto.raza,fido.raza))
printf("\nPluto Y Fido son de la misma raza \n");
else
printf("\nFido y Pluto son de razas distintas\n");

// comparación de elementos de tipo numérico

if(pluto.peso > fido.peso)
printf("Pluto es m%cs pesado que Fido\n",160);
else if(pluto.peso < fido.peso)
printf("Fido es m%cs pesado que Pluto\n",160);
else
printf("Fido y Pluto pesan lo mismo\n");

if(pluto.edad > fido.edad)

printf("Pluto es mas viejo que Fido\n");
else if(pluto.edad < fido.edad)
printf("Fido es mas pesado que Pluto\n");
else
printf("Fido y Pluto tienen la misma edad \n");

getch();
}
Ejecución

Reflexión
La diferencia básica entre los arreglos y las estructuras es principalmente el tipo de datos que se
manejan en ellos, los arreglos deben ser de uno solo tipo de dato, mientras que las estructuras
están compuestas por diferentes tipos de datos, así mismo la forma de almacenar y mandar llamar
la información contenida en ellos, es un poco diferente, en los arreglos se debe especificar la
posición, mientras que en la estructura se debe especificar el nombre de la variable.nombre de la
variable dentro de la estructura.

Página 9
Ejercicio: F ARRNOM
Análisis
Este programa consiste en solicitarle al usuario su nombre, se saca la longitud del nombre
introducido y sabiendo la longitud, se recorre toda la cadena y se transforma carácter por carácter
en su homologo en mayúsculas y lo almacena en la misma cadena y posición, al final se muestra
la cadena solicitada en un principio y ahora transformada en mayúsculas.

Codificación
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

main(){

int x, longitud;
char nombre[50];
char c;

printf ("Da tu nombre: ");

scanf("%s",nombre);
longitud=strlen(nombre); //strlen obtiene la longitud de la variable nombre

for (x=0;x<=longitud;x++) { //el ciclo recorrerá el total de la longitud

nombre[x]=toupper(nombre[x]);
}
printf ("\n\n Conversi%cn: %s\n\n", 162, nombre);

system("pause");
}
Ejecución

Página 10
Ejercicio: G ARRSUM
Análisis
Es programa trata de solicitar al usuario números enteros y llegar el arreglo con ellos, así como ir
sumando los números conforme se van solicitando, al finalizar nos muestra la suma de los
números ingresados dentro del arreglo.

Codificación
#include <stdio.h>
#include <conio.h>

main(){

int f,c,x[2][2],suma=0;

for (f=0;f<=1;f++)
for (c=0;c<=1;c++)
{
printf ("x [%d][%d]: ",f,c);
scanf("%d",&x[f][c]);
suma=suma+x[f][c];
}

printf ("\nSuma de los elementos del arreglo x: %d\n", suma);

getch();
}

Ejecución

x c0 c1
f0 54 25
f1 4 9

Página 11
 Librería Función Instrucción Descripción

Lee un carácter sin hacer

uso del buffer, y sin mostrar
salida, aunque en el ejercicio
conio.h getch(); getch();
1 funciono el getch sin
necesidad de agregar esta
librería.

Hace una comparación entre

strcmp(cadena1,
strcmp() cadenas, si regresa 0 es que
cadena2)
son iguales.
Concatena los valores de
strcat() strcat(cadena1, cadena2) dos cadenas, cadena1 +
string.h cadena2
Esta función copia o
strcpy() strcpy(cadena1, "Texto") reescribe un nuevo valor a la
cadena existente
Calcula el número de
Strlen() strlen(cadena) caracteres, hasta el carácter
nulo, de la cadena solicitada
Convierte caracteres a-z en
sus equivalentes en
ctype.h Toupper() Toupper(cadena) mayúsculas A-Z, caracteres
acentuados, con diéresis y la
ñ no se cambian

Conclusión

Todavía me confundo un poco en los arreglos en como identificar en el cuadrito

exactamente donde se guarda el dato que estoy introduciendo, creo que hizo falta un

poco más de ejercicios de estructuras solo hubo 1 y son los que usare en el proyecto

final ☹, me quedo la duda en las estructuras si también se almacenan los datos como

en los arreglos, así como utilizando el cuadrito.

Página 12
Bibliografía

Nekszer. (17 de Oct de 2012). Pseint #10 - Arreglos y Caracteres [Entrada y Salida de
Datos]. Obtenido de Video de YouTube:
https://www.youtube.com/watch?v=w3fUjAhaU5A

R. Davidson, S. (Abr de 2001). Librerías Ansi C. Obtenido de Librerías Ansi C:

http://c.conclase.net/librerias/?ansilib=string#inicio

UnADM. (s.f). Unidad 5. Estructuras de datos. Obtenido de UnADM:

https://unadmexico.blackboard.com/bbcswebdav/institution/DCEIT/2016_S2_B1/
DS/01/DFPR/U5/Unidad_5_Estructuras_de_datos_.pdf

Página 13