jorgenicolas/Curso_de_Programacion_C
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

16/11/2022 ; 6:30 PM

Browse Source
This commit is contained in:
JNmeca
2022-11-16 18:28:01 -04:00
parent 77bcc9e8f9
commit 764066a5a9
17 changed files with 878 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
5. Arreglos unidimensionales/Programas/Programa 5.1/Programa 5.1.c Normal file
View File

@@ -0,0 +1,27 @@
#include <stdio.h>
/* Cuenta-números.
El programa, al recibir como datos un arreglo unidimensional de tipo
➥entero y un número entero, determina cuántas veces se encuentra el
➥número en el arreglo. */
void main(void)
{
int I = 0, NUM = 0, CUE = 0;
int ARRE[100]; /* Declaración del arreglo */
for (I = 0; I < 100; I++)
{
printf("Ingrese el elemento %i del arreglo: ", I + 1);
scanf("%i", &ARRE[I]); /* Lectura -asignación— del arreglo */
}
printf("\n\nIngrese el numero que se va a buscar en el arreglo: ");
scanf("%i", &NUM);
for (I = 0; I < 100; I++)
if (ARRE[I] == NUM) /* Comparación del número con los elementos del arreglo */
CUE++;
printf("\n\nEl %d se encuentra %i veces en el arreglo", NUM, CUE);
}

64
5. Arreglos unidimensionales/Programas/Programa 5.10/Programa 5.10.c Normal file
View File

@@ -0,0 +1,64 @@
#include <stdio.h>
/* Búsqueda secuencial en arreglos ordenados en forma creciente. */
#define MAX 100
void Lectura(int, int); /* Prototipos de funciones. */
int Busca(int*, int, int);
void main(void)
{
int RES, ELE, TAM, VEC[MAX];
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%d", &TAM);
} while (TAM > MAX || TAM < 1);
/* Se verifica que el tamaño del arreglo sea correcto. */
Lectura(VEC, TAM);
printf("\nIngrese el elemento a buscar: ");
scanf("%d", &ELE);
RES = Busca(VEC, TAM, ELE); /* Se llama a la función que busca en el arreglo. */
if (RES)
/* Si RES tiene un valor verdadero —diferente de 0—, se escribe la
➥posición en la que se encontró al elemento. */
printf("\nEl elemento se encuentra en la posicion: %d", RES);
else
printf("\nEl elemento no se encuentra en el arreglo");
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
int Busca(int A[], int T, int E)
/* Esta función se utiliza para localizar el elemento E en el arreglo unidimensional A.
Si se encuentra, la función regresa la posición correspondiente. En caso contrario regresa 0. */
{
int RES, I = 0, BAN = 0;
while ((I < T) && (E >= A[I]) && !BAN)
/* Observa que se incorpora una nueva condición. */
if (A[I] == E)
BAN++;
else
I++;
if (BAN)
RES = I + 1;
/* Se asigna I+1 dado que las posiciones en el arreglo comienzan des
de cero. */
else
RES = BAN;
return (RES);
}

63
5. Arreglos unidimensionales/Programas/Programa 5.11/Programa 5.11.c Normal file
View File

@@ -0,0 +1,63 @@
#include <stdio.h>
/* Búsqueda binaria. */
#define MAX 100
void Lectura(int, int); /* Prototipos de funciones. */
int Binaria(int*, int, int);
void main(void)
{
int RES, ELE, TAM, VEC[MAX];
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%i", &TAM);
} while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea
➥correcto. */
Lectura(VEC, TAM);
printf("\nIngrese el elemento a buscar: ");
scanf("%d", &ELE);
RES = Binaria(VEC, TAM, ELE); /* Se llama a la función que busca en el
➥arreglo. */
if (RES)
/* Si RES tiene un valor verdadero —diferente de 0—, se escribe la
➥posición en la que se encontró el elemento. */
printf("\nEl elemento se encuentra en la posicion: %d", RES);
else
printf("\nEl elemento no se encuentra en el arreglo");
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
int Binaria(int A[], int T, int E)
/* Esta función se utiliza para realizar una búsqueda binaria del elemento E en el arreglo unidimensional A de T elementos. Si se
➥encuentra el elemento, la función regresa la posición correspondiente.
➥En caso contrario, regresa 0. */
{
int ELE, IZQ = 0, CEN, DER = T - 1, BAN = 0;
while ((IZQ <= DER) && (!BAN))
{
CEN = (IZQ + DER) / 2;
if (E == A[CEN])
BAN = CEN;
else
if (E > A[CEN])
IZQ = CEN + 1;
else
DER = CEN - 1;
}
return (BAN);

62
5. Arreglos unidimensionales/Programas/Programa 5.12/Programa 5.12.c Normal file
View File

@@ -0,0 +1,62 @@
#include <stdio.h>
/* Ordenación por inserción directa. */
#define MAX 100
void Lectura(int*, int);
void Ordena(int*, int); /* Prototipos de funciones. */
void Imprime(int*, int);
void main(void)
{
int TAM, VEC[MAX];
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%d", &TAM);
} while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea
➥correcto. */
Lectura(VEC, TAM);
Ordena(VEC, TAM);
Imprime(VEC, TAM);
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
void Imprime(int A[], int T)
/* Esta función se utiliza para escribir un arreglo unidimensional
➥ordenado de T elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
printf("\nA[%d]: %d", I, A[I]);
}
void Ordena(int A[], int T)
/* La función Ordena utiliza el método de inserción directa para ordenar
➥los elementos del arreglo unidimensional A. */
{
int AUX, L, I;
for (I = 1; I < T; I++)
{
AUX = A[I];
L = I - 1;
while ((L >= 0) && (AUX < A[L]))
{
A[L + 1] = A[L];
L--;
}
A[L + 1] = AUX;

66
5. Arreglos unidimensionales/Programas/Programa 5.13/Programa 5.13.c Normal file
View File

@@ -0,0 +1,66 @@
#include <stdio.h>
/* Ordenación por selección directa. */
#define MAX 100
void Lectura(int*, int);
void Ordena(int*, int); /* Prototipos de funciones. */
void Imprime(int*, int);
void main(void)
{
int TAM, VEC[MAX];
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%d", &TAM);
} while (TAM > MAX || TAM < 1); /* Se verifica que el tamaño del arreglo sea
➥correcto. */
Lectura(VEC, TAM);
Ordena(VEC, TAM);
Imprime(VEC, TAM);
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
void Imprime(int A[], int T)
/* Esta función se utiliza para escribir un arreglo unidimensional
➥ordenado de T elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
printf("\nA[%d]: %d", I, A[I]);
}
void Ordena(int A[], int T)
/* La función Ordena utiliza el método de selección directa para ordenar
➥los elementos del arreglo unidimensional A. */
{
int I, J, MEN, L;
for (I = 0; I < (T - 1); I++)
{
MEN = A[I];
L = I;
for (J = (I + 1); J < T; J++)
if (A[J] < MEN)
{
MEN = A[J];
L = J;
}
A[L] = A[I];
A[I] = MEN;
}
}

102
5. Arreglos unidimensionales/Programas/Programa 5.14/Programa 5.14.c Normal file
View File

@@ -0,0 +1,102 @@
#include <stdio.h>
#include <math.h>
/* Estadístico.
El programa, al recibir como dato un arreglo unidimensional de enteros
➥que contiene calificaciones, calcula la media, la varianza, la
➥desviación estándar y la moda. */
#define MAX 100
void Lectura(int*, int);
void Frecuencia(int*, int, int*);
float Media(int*, int);
float Varianza(int*, int, float); /* Prototipos de funciones. */
float Desviacion(float);
int Moda(int*, int);
void main(void)
{
int TAM, MOD, ALU[MAX], FRE[11] = { 0 };
float MED, VAR, DES;
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%d", &TAM);
} while (TAM > MAX || TAM < 1);
/* Se verifica que el tamaño del arreglo sea correcto. */
Lectura(ALU, TAM);
MED = Media(ALU, TAM);
VAR = Varianza(ALU, TAM, MED);
DES = Desviacion(VAR);
Frecuencia(ALU, TAM, FRE);
MOD = Moda(FRE, 11);
printf("\nMedia: %.2f", MED);
printf("\nVarianza: %.2f", VAR);
printf("\nDesviacion: %.2f", DES);
printf("\nModa: %d", MOD);
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
float Media(int A[], int T)
/* Esta función se utiliza para calcular la media. */
{
int I;
float SUM = 0.0;
for (I = 0; I < T; I++)
SUM += A[I];
return (SUM / T);
}
float Varianza(int A[], int T, float M)
/* Esta función se utiliza para calcular la varianza. */
{
int I;
float SUM = 0.0;
for (I = 0; I < T; I++)
SUM += pow((A[I] - M), 2);
return (SUM / T);
}
float Desviacion(float V)
/* Esta función se utiliza para calcular la desviación estándar. */
{
return (sqrt(V));
}
void Frecuencia(int A[], int P, int B[])
/* Esta función se utiliza para calcular la frecuencia de calificaciones.
*/
{
int I;
for (I = 0; I < P; I++)
B[A[I]]++;
}
int Moda(int A[], int T)
/* Esta función se utiliza para calcular la moda. */
{
int I, MOD = 0, VAL = A[0];
for (I = 1; I < T; I++)
if (MOD < A[I])
{
MOD = I;
VAL = A[I];
}

21
5. Arreglos unidimensionales/Programas/Programa 5.15/Programa 5.15.c Normal file
View File

@@ -0,0 +1,21 @@
#include <stdio.h>
/* Apuntadores y arreglos */
void main(void)
{
int X = 5, Y = 8, V[5] = { 1, 3, 5, 7, 9 };
int* AY, * AX;
AY = &Y;
X = *AY;
*AY = V[3] + V[2];
printf("\nX = %d Y = %d V[0] = %d V[1] = %d V[2] = %d V[3] = %d V[4] = %d", X, Y, V[0], V[1], V[2], V[3], V[4]);
AX = &V[V[0] * V[1]];
X = *AX;
Y = *AX * V[1];
*AX = *AY - 3;
printf("\nX = %d Y = %d V[0] = %d V[1] = %d V[2] = %d V[3] = %d V[4] = %d", X, Y, V[0], V[1], V[2], V[3], V[4]);
}

21
5. Arreglos unidimensionales/Programas/Programa 5.16/Programa 5.16.c Normal file
View File

@@ -0,0 +1,21 @@
#include <stdio.h>
/* Apuntadores y arreglos */
void main(void)
{
int V1[4] = { 2, 3, 4, 7 }, V2[4] = { 6 };
int* AX, * AY;
AX = &V1[3];
AY = &V2[2];
V1[V2[0] - V1[2]] = *AY;
*AY = *AX - V1[0];
printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]);
V2[1] = ++ * AX;
V2[3] = (*AY)++;
*AX += 2;
printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]);
}

28
5. Arreglos unidimensionales/Programas/Programa 5.17/Programa 5.17.c Normal file
View File

@@ -0,0 +1,28 @@
#include <stdio.h>
/* Apuntadores y arreglos */
void main(void)
{
int V1[4] = { 1, 3, 5, 7 }, V2[4] = { 2,4 };
int* AX, * AY;
AX = &V1[2];
AY = &V2[2];
V2[2] = *(AX + 1);
V2[3] = *AX;
AX = AX + 1;
V1[0] = *AX;
printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]);
V1[2] = *AY;
V1[1] = --*AY;
AX = AX + 1;
V1[3] = *AX;
printf("\nV1[0] = %d V1[1] = %d V1[2] = %d V1[3] = %d \tV2[0] = %d V2[1] = %d V2[2] = %d V2[3] = %d", V1[0], V1[1], V1[2], V1[3], V2[0], V2[1], V2[2], V2[3]);
}

25
5. Arreglos unidimensionales/Programas/Programa 5.2/Programa 5.2.c Normal file
View File

@@ -0,0 +1,25 @@
#include <stdio.h>
/* Elección.
El programa almacena los votos emitidos en una elección en la que hubo cinco
➥candidatos e imprime el total de votos que obtuvo cada uno de ellos. */
void main(void)
{
int ELE[5] = { 0 }; /* Declaración del arreglo entero ELE de cinco elementos. Todos sus elementos se inicializan en 0. */
int I = 0, VOT = 0;
printf("Ingresa el primer voto(0 - Para terminar): ");
scanf("%i", &VOT);
while (VOT)
{
if ((VOT > 0) && (VOT < 6)) /* Se verifica que el voto sea correcto. */
ELE[VOT - 1]++; /* Los votos se almacenan en el arreglo. Recuerda que la primera posición del arreglo es 0, por esa razón a la variable VOT se le descuenta 1. Los votos del primer candidato se almacenan en la posición 0. */
else
printf("\nEl voto ingresado es incorrecto.\n");
printf("Ingresa el siguiente voto(0 - Para terminar) : ");
scanf("%i", &VOT);
}
printf("\n\nResultados de la Eleccion\n");
for (I = 0; I <= 4; I++)
printf("\nCandidato %d: %d", I + 1, ELE[I]);
}

56
5. Arreglos unidimensionales/Programas/Programa 5.3/Programa 5.3.c Normal file
View File

@@ -0,0 +1,56 @@
#include <stdio.h>
/* Apuntadores, variables y valores. */
void main(void)
{
int X = 3, Y = 7, Z[5] = { 2, 4, 6, 8, 10 };
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
int* IX; /* IX representa un apuntador a un entero. */
IX = &X; /* IX apunta a X. IX tiene la dirección de X. */
Y = *IX; /* Y toma el valor de X, ahora vale 3. */
*IX = 1; /* X se modifica, ahora vale 1. */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
IX = &Z[2]; /* IX apunta al tercer elemento del arreglo Z. */
Y = *IX; /* Y toma el valor de Z[2], ahora vale 6. */
*IX = 15; /* Z[2] se modifica, ahora vale 15. */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
X = *IX + 5; /* X se modifica, ahora vale Z[2] + 5 = 20. Recuerda que *IX contiene el valor de Z[2]. */
*IX = *IX - 5; /* Z[2] se modifica, ahora vale 10. */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
++* IX; /* Z[2] se modifica, se incrementa en 1. Z[2] ahora vale 11. */
*IX += 1; /* Z[2] se vuelve a modificar, ahora vale 12. */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
X = *(IX + 1); /* X se modifica. El apuntador IX accede temporalmente a Z[3], por lo tanto X toma este valor (8). Observa que IX no se reasigna */
Y = *IX; /* Y se modifica, toma el valor de Z[2] (12). */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d\t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
IX = IX + 1; /* IX se modifica. Observa la forma de mover el apuntador.
Ahora IX apunta al cuarto elemento de Z (Z[3]). */
Y = *IX; /* Y se modifica, ahora vale Z[3] (8). */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] =% d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
IX = IX + 4; /* IX se modifica. Observa que el apuntador se mueve
➥4 posiciones y cae en una dirección afuera del arreglo. Esto ocasionará un
➥error. */ Y = *IX; /* Y se modifica, toma el valor (basura) de una celda
➥incorrecta. Es un error que no señala el compilador del lenguaje C. */
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
IX = &X; /* IX apunta a la variable entera X. */
IX = IX + 1; /* IX se mueve una posición y cae en una celda incorrecta. */
X = *IX; /* X toma el valor (basura) de la celda a la que apunta IX.*/
printf("\nX = %d \t Y = %d \t Z[0] = %d \t Z[1] = %d \t Z[2] = %d \t Z[3] = %d \t Z[4] = %d", X, Y, Z[0], Z[1], Z[2], Z[3], Z[4]);
}

53
5. Arreglos unidimensionales/Programas/Programa 5.4/Programa 5.4.c Normal file
View File

@@ -0,0 +1,53 @@
#include <stdio.h>
/* Producto de vectores.
*
El programa calcula el producto de dos vectores y almacena el resultado en otro arreglo unidimensional. */
#define MAX 10 /* Se define una constante para el tamaño de los arreglos. */
void Lectura(int VEC[], int T);
void Imprime(int VEC[], int T); /* Prototipos de funciones. */
void Producto(int* X, int* Y, int* Z, int T); /* Observa que en los parámetros, para indicar que lo que se recibe es un arreglo, se puede escribir VEC[] o *VEC. */
void main(void)
{
int VE1[MAX], VE2[MAX], VE3[MAX];
/* Se declaran tres arreglos de tipo entero de 10 elementos. */
Lectura(VE1, MAX);
/* Se llama a la función Lectura. Observa que el paso del arreglo a la función
➥es por referencia. Sólo se debe incluir el nombre del arreglo. */
Lectura(VE2, MAX);
Producto(VE1, VE2, VE3, MAX);
/* Se llama a la función Producto. Se pasan los nombres de los tres arreglos. */
printf("\nProducto de los Vectores");
Imprime(VE3, MAX);
}
void Lectura(int VEC[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
printf("\n");
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &VEC[I]);
}
}
void Imprime(int VEC[], int T)
/* La función Imprime se utiliza para imprimir un arreglo unidimensional de T
➥elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
printf("\nVEC[%d]: %d", I + 1, VEC[I]);
}
void Producto(int* X, int* Y, int* Z, int T)
/* Esta función se utiliza para calcular el producto de dos arreglos
➥unidimensionales de T elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
Z[I] = X[I] * Y[I];
}

65
5. Arreglos unidimensionales/Programas/Programa 5.5/Programa 5.5.c Normal file
View File

@@ -0,0 +1,65 @@
#include <stdio.h>
/* Frecuencia de calificaciones.
El programa, al recibir como datos las calificaciones de un grupo de 50
➥alumnos, obtiene la frecuencia de cada una de las calificaciones y además
➥escribe cuál es la frecuencia más alta. */
#define TAM 50
void Lectura(int*, int);
void Frecuencia(int, int, int, int); /* Prototipos de funciones. */
void Impresion(int*, int);
void Mayor(int*, int);
void main(void)
{
int CAL[TAM], FRE[6] = { 0 }; /* Declaración de los arreglos. */
Lectura(CAL, TAM); /* Se llama a la función Lectura. */
Frecuencia(CAL, TAM, FRE, 6);
/* Se llama a la función Frecuencia, se pasan ambos arreglos. */
printf("\nFrecuencia de Calificaciones\n");
Impresion(FRE, 6);
Mayor(FRE, 6);
}
void Lectura(int VEC[], int T)
/* La función Lectura se utiliza para leer el arreglo de calificaciones. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese la calificacion - 0:5 - del alumno %d: ", I + 1);
scanf("%d", &VEC[I]);
}
}
void Impresion(int VEC[], int T)
/* La función Impresión se utiliza para imprimir el arreglo de frecuencias. */
{
int I;
for (I = 0; I < T; I++)
printf("\nVEC[%d]: %d", I, VEC[I]);
}
void Frecuencia(int A[], int P, int B[], int T)
/* Esta función calcula la frecuencia de calificaciones. */
{
int I;
for (I = 0; I < P; I++)
if ((A[I] >= 0) && (A[I] < 6)) /* Se valida que la calificación sea correcta. */
B[A[I]]++; /* Observa la forma de almacenar e incrementar las frecuencias. */
}
void Mayor(int* X, int T)
/* Esta función obtiene la primera ocurrencia de la frecuencia más alta. */
{
int I, MFRE = 0, MVAL = X[0];
for (I = 1; I < T; I++)
if (MVAL < X[I])
{
MFRE = I;
MVAL = X[I];
}
printf("\n\nMayor frecuencia de calificaciones: %d \tValor: %d", MFRE, MVAL);
}

43
5. Arreglos unidimensionales/Programas/Programa 5.6/Programa 5.6.c Normal file
View File

@@ -0,0 +1,43 @@
#include <stdio.h>
#include <math.h>
/* Suma-cuadrados.
El programa calcula la suma del cuadrado de los elementos de un arreglounidimensional de 100 elementos de tipo real. */
#define MAX 100
/* MAX se utiliza para reservar el espacio máximo que podrá ocupar el arreglo. */
void Lectura(float*, int); /* Prototipos de funciones. */
double Suma(float*, int);
void main(void)
{
float VEC[MAX];
double RES;
Lectura(VEC, MAX);
RES = Suma(VEC, MAX);
/* Se llama a la función Suma y se almacena el resultado en la variable RES. */
printf("\n\nSuma del arreglo: %.2lf", RES);
}
void Lectura(float A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo real. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%f", &A[I]);
}
}
double Suma(float A[], int T)
/* La función Suma se utiliza para calcular la suma del cuadrado de los
➥componentes de un arreglo unidimensional de T elementos de tipo real. */
{
int I;
double AUX = 0.0;
for (I = 0; I < T; I++)
AUX += pow(A[I], 2);
return(AUX);
}

76
5. Arreglos unidimensionales/Programas/Programa 5.7/Programa 5.7.c Normal file
View File

@@ -0,0 +1,76 @@
#include <stdio.h>
/* Arreglo sin elementos repetidos.
El programa, al recibir como dato un arreglo unidimensional desordenado de N
➥elementos, obtiene como salida ese mismo arreglo pero sin los elementos
➥repetidos. */
void Lectura(int*, int); /* Prototipos de funciones. */
void Imprime(int*, int);
void Elimina(int*, int*);
/* Observa que en el prototipo de Elimina, el segundo parámetro es por
➥referencia. Esto, porque el tamaño del arreglo puede disminuir. */
void main(void)
{
int TAM, ARRE[100];
/* Se escribe un do-while para verificar que el tamaño del arreglo que se
➥ingresa sea correcto. */
do
{
printf("Ingrese el tamaño del arreglo: ");
scanf("%d", &TAM);
} while (TAM > 100 || TAM < 1);
Lectura(ARRE, TAM);
Elimina(ARRE, &TAM);
/* Observa que el tamaño del arreglo se pasa por referencia.*/
Imprime(ARRE, TAM);
}
void Lectura(int A[], int T)
/* La función Lectura se utiliza para leer un arreglo unidimensional de T
➥elementos de tipo entero. */
{
printf("\n");
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%i", &A[I]);
}
}
void Imprime(int A[], int T)
/* La función Imprime se utiliza para escribir un arreglo unidimensional, sin
➥repeticiones, de T elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
printf("\nA[%d]: %d", I, A[I]);
}
void Elimina(int A[], int* T)
/* Esta función se utiliza para eliminar los elementos repetidos de un arreglo
➥unidimensional de T elementos de tipo entero. */
{
int I = 0, K, L;
while (I < (*T - 1))
{
K = I + 1;
while (K <= (*T - 1))
{
if (A[I] == A[K])
{
for (L = K; L < (*T - 1); L++)
A[L] = A[L + 1];
*T = *T - 1;
}
else
K++;
}
I++;
}
}

46
5. Arreglos unidimensionales/Programas/Programa 5.8/Programa 5.8.c Normal file
View File

@@ -0,0 +1,46 @@
#include <stdio.h>
/* Primos.
El programa almacena en un arreglo unidimensional los primeros 100 n<>meros primos. */
#define TAM 100
void Imprime(int, int); /* Prototipos de funciones. */
void Primo(int, int*);
void main(void)
{
int P[TAM] = { 1,2 };
int FLA, J = 2, PRI = 3;
while (J <= TAM)
{
FLA = 1;
Primo(PRI, &FLA); /* Se llama a la funci<63>n que determina si PRI es primo. */
if (FLA) /* Si FLA es 1, entonces PRI es primo. */
{
P[J] = PRI;
J++;
}
PRI += 2;
}
Imprime(P, TAM);
}
void Primo(int A, int* B)
/* Esta funci<63>n determina si A es primo, en cuyo caso el valor de *B no se altera. */
{
int DI = 3;
while (*B && (DI < (A / 2)))
{
if ((A % DI) == 0)
*B = 0;
DI++;
}
}
void Imprime(int Primos[], int T)
/* Esta funci<63>n imprime el arreglo unidimensional de n<>meros primos. */
{
int I;
for (I = 0; I < T; I++)
printf("\nPrimos[%i]: %d", I, Primos[I]);
}

60
5. Arreglos unidimensionales/Programas/Programa 5.9/Programa 5.9.c Normal file
View File

@@ -0,0 +1,60 @@
#include <stdio.h>
/* B<>squeda secuencial en arreglos desordenados. */
#define MAX 100
void Lectura(int, int); /* Prototipos de funciones. */
int Busca(int*, int, int);
void main(void)
{
int RES, ELE, TAM, VEC[MAX];
do
{
printf("Ingrese el tama<6D>o del arreglo: ");
scanf("%d", &TAM);
} while (TAM > MAX || TAM < 1); /* Se verifica que el tama<6D>o del arreglo sea correcto. */
Lectura(VEC, TAM);
printf("\nIngrese el elemento a buscar: ");
scanf("%d", &ELE);
RES = Busca(VEC, TAM, ELE); /* Se llama a la funci<63>n que busca en el arreglo. */
if (RES)
/* Si RES tiene un valor verdadero <20>diferente de 0<>, se escribe la posici<63>n en la que se encontr<74> el elemento. */
printf("\nEl elemento se encuentra en la posicion %d", RES);
else
printf("\nEl elemento no se encuentra en el arreglo");
}
void Lectura(int A[], int T)
/* La funci<63>n Lectura se utiliza para leer un arreglo unidimensional de T elementos de tipo entero. */
{
int I;
for (I = 0; I < T; I++)
{
printf("Ingrese el elemento %d: ", I + 1);
scanf("%d", &A[I]);
}
}
int Busca(int A[], int T, int K)
/* Esta funci<63>n localiza en el arreglo un elemento determinado. Si el elemento es encontrado, regresa la posici<63>n correspondiente. En caso contrario, regresa 0. */
{
int I = 0, BAN = 0, RES;
while (I < T && !BAN)
if (A[I] == K)
BAN++;
else
I++;
if (BAN)
RES = I + 1;
/* Se asigna I+1 dado que las posiciones en el arreglo comienzan desde cero. */
else
RES = BAN;
return (RES);
}