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

16/11/2022 ; 6:12 PM

Browse Source
This commit is contained in:
JNmeca
2022-11-16 18:12:40 -04:00
parent 2400289e61
commit b51d1043c8
21 changed files with 931 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
7. Caracteres y cadenas de caracteres/Programas/Programa 7.1/Programa 7.1/Programa 7.1.c Normal file
View File

@@ -0,0 +1,34 @@
#include <stdio.h>
/* Funciones para el manejo de caracteres de la biblioteca stdio.h */
void main(void)
{
char p1, p2, p3 = '$';
/* Declaración de las variables tipo caracter p1, p2 y p3. Observa que a p3 se le
➥asigna el símbolo $. */
printf("\nIngrese un caracter: ");
p1 = getchar(); /* Se utiliza la función getchar para leer un caracter. */
putchar(p1); /* Se utiliza la función putchar para escribir un caracter. */
printf("\n");
fflush(stdin);
/* Luego de leer un caracter siempre es conveniente escribir la función fflush
➥para limpiar el búfer, porque generalmente queda con basura y genera un error
➥en la ejecución del programa. El error se produce porque cuando se ingresa un
➥dato se oprime el return y luego cuando volvemos a leer un caracter o una
➥cadena de caracteres se toma a ese return como el nuevo dato ingresado. */
printf("\nEl caracter p3 es: ");
putchar(p3);/* Se utiliza la función putchar para escribir el caracter almacenado en p3. */
printf("\n");
printf("\nIngrese otro caracter: ");
fflush(stdin);
scanf("%c", &p2);/* Se puede utilizar scanf con el formato de variable %c para leer un caracter. */
printf("%c", p2);/* Se puede utilizar printf con el formato de variable %c para escribir un caracter. */
}

31
7. Caracteres y cadenas de caracteres/Programas/Programa 7.10/Programa 7.10/Programa 7.10.c Normal file
View File

@@ -0,0 +1,31 @@
#include <stdio.h>
#include <stdlib.h>
/* Suma y promedio.
El programa, al recibir como datos varias cadenas de caracteres que
➥contienen reales, los suma y obtiene el promedio de los mismos. */
void main(void)
{
char c, cad[10];
int i = 0;
float sum = 0.0;
printf("\nDesea ingresar una cadena de caracteres(S / N)? ");
c = getchar();
while (c == 'S')
{
printf("\nIngrese la cadena de caracteres: ");
fflush(stdin);
gets(cad);
i++;
sum += atof(cad);
printf("\nDesea ingresar otra cadena de caracteres(S / N)? ");
c = getchar();
}
printf("\nSuma: %.2f", sum);
printf("\nPromedio: %.2f", sum/i);
}

31
7. Caracteres y cadenas de caracteres/Programas/Programa 7.11/Programa 7.11/Programa 7.11.c Normal file
View File

@@ -0,0 +1,31 @@
# include <stdio.h>
# include <ctype.h>
/* Verifica.
El programa, al recibir como datos una cadena de caracteres y una posici<63>n espec<65>fica en la cadena, determina si el caracter correspondiente es una letra
min<EFBFBD>scula. */
void main(void)
{
char p, cad[50];
int n;
printf("\nIngrese la cadena de caracteres (maximo 50): ");
gets(cad);
printf("\nIngrese la posicion en la cadena que desea verificar: ");
scanf("%d", &n);
if ((n >= 0) && (n < 50))
{
p = cad[n - 1];
if (islower(p))
printf("\n%c es una letra minuscula", p);
else
printf("\n%c no es una letra minuscula", p);
}
else
printf("\nEl valor ingresado de n es incorrecto");
}

29
7. Caracteres y cadenas de caracteres/Programas/Programa 7.12/Programa 7.12/Programa 7.12.c Normal file
View File

@@ -0,0 +1,29 @@
#include <stdio.h>
#include <ctype.h>
/* Cuenta letras minúsculas y mayúsculas.
El programa, al recibir como dato una frase, determina el número de letras
➥minúsculas y mayúsculas que existen en la frase. */
void main(void)
{
char cad[50];
int i = 0, mi = 0, ma = 0;
printf("\nIngrese la cadena de caracteres (maximo 50 caracteres): ");
gets(cad);
while (cad[i] != '\0')
{
if (islower(cad[i]))
mi++;
else
if (isupper(cad[i]))
ma++;
i++;
}
printf("\n\nNumero de letras minusculas: %d", mi);
printf("\nNumero de letras mayusculas: %d", ma);
}

29
7. Caracteres y cadenas de caracteres/Programas/Programa 7.13/Programa 7.13/Programa 7.13.c Normal file
View File

@@ -0,0 +1,29 @@
#include <stdio.h>
/* Calcula longitud.
El programa calcula la longitud de la cadena sin utilizar la funci<63>n strlen. */
int cuenta(char*); /* Prototipo de funci<63>n. */
void main(void)
{
int i;
char cad[50];
printf("\nIngrese la cadena de caracteres: ");
gets(cad);
i = cuenta(cad);
printf("\nLongitud de la cadena: %d", i);
}
int cuenta(char* cadena)
/* La funci<63>n calcula la longitud de la cadena. */
{
int c = 0;
while (!cadena[c] == '\0')
c++;
return (c);
}

33
7. Caracteres y cadenas de caracteres/Programas/Programa 7.14/Programa 7.14/Programa 7.14.c Normal file
View File

@@ -0,0 +1,33 @@
#include <stdio.h>
/* Calcula longitud en forma recursiva.
El programa calcula de manera recursiva la longitud de la cadena sin utilizar
➥la función strlen. */
int cuenta(char*); /* Prototipo de función. */
void main(void)
{
int i;
char cad[50];
printf("\nIngrese la cadena de caracteres: ");
gets(cad);
i = cuenta(cad);
printf("\nLongitud de la cadena: %d", i);
}
int cuenta(char* cadena)
/* Esta función calcula la longitud de la cadena en forma recursiva. Es
➥importante tener conocimientos tanto de pilas como de recursividad para
➥comprender la solución propuesta, aunque ésta sea muy simple. Observa que
➥mientras no lleguemos al último caracter de la cadena, incrementamos la
➥cuenta en uno y llamamos a la función con el siguiente caracter. */
{
if (cadena[0] == '\0')
return 0;
else
return (1 + cuenta(&cadena[1]));
}

37
7. Caracteres y cadenas de caracteres/Programas/Programa 7.15/Programa 7.15/Programa 7.15.c Normal file
View File

@@ -0,0 +1,37 @@
# include <stdio.h>
# include <ctype.h>
/* Decodifica.
El programa decodifica una cadena de caracteres compuesta por números y
➥letras. */
void interpreta(char*); /* Prototipo de función. */
void main(void)
{
char cad[50];
printf("\nIngrese la cadena de caracteres: ");
gets(cad);
interpreta(cad);
}
void interpreta(char* cad)
/* Esta función se utiliza para decodificar la cadena de caracteres. */
{
int i = 0, j, k;
while (cad[i] != '\0')
{
if (isalpha(cad[i])) /* Se utiliza isalpha para observar si el caracter
➥es una letra. */
{
k = cad[i - 1] - 48;
/* En la variable entera k se almacena el ascii del número —convertido
➥en caracter— que nos interesa, menos 48 que corresponde al ascii
➥del dígito 0. */
for (j = 0; j < k; j++)
putchar(cad[i]);
}
i++;
}

34
7. Caracteres y cadenas de caracteres/Programas/Programa 7.16/Programa 7.16/Programa 7.16.c Normal file
View File

@@ -0,0 +1,34 @@
#include <stdio.h>
#include <string.h>
/* Cuenta cadenas.
El programa, al recibir dos cadenas de caracteres, calcula e imprime cuántas
➥veces se encuentra la segunda cadena en la primera. */
void main(void)
{
char cad1[50], cad2[50], *cad0 = "";
int i = 0;
printf("\nIngrese la primera cadena de caracteres: ");
gets(cad1);
printf("\nIngrese la cadena a buscar: ");
gets(cad2);
strcpy(cad0, cad1); /* Se copia la cadena original a cad0. */
cad0 = strstr(cad0, cad2);
/* En cad0 se asigna el apuntador a la primera ocurrencia de la cadena cad2.
➥Si no existe se almacena NULL.*/
while (cad0 != NULL)
{
i++;
cad0 = strstr(cad0 + 1, cad2);
/* Se modifica nuevamente la cadena, moviendo el apuntador una
➥posición. */
}
printf("\nEl número de veces que aparece la segunda cadena es: %d", i);
}

46
7. Caracteres y cadenas de caracteres/Programas/Programa 7.17/Programa 7.17/Programa 7.17.c Normal file
View File

@@ -0,0 +1,46 @@
#include <stdio.h>
#include <string.h>
/* Cadena invertida.
El programa obtiene la cadena invertida. */
char* inverso(char*); /* Prototipo de función. */
void main(void)
{
char fra[50], aux[50];
printf("\nIngrese la linea de texto: ");
gets(fra);
strcpy(aux, inverso(fra)); /* Se copia a aux el resultado de la función inverso. */
printf("\nEscribe la linea de texto en forma inversa: ");
puts(aux);
}
char* inverso(char* cadena)
/* La función calcula el inverso de una cadena y regresa el resultado al
➥programa principal. */
{
int i = 0, j, lon;
char cad;
lon = strlen(cadena);
j = lon - 1;
while (i < ((lon - 1) / 2))
/* Observa que el reemplazo de los caracteres se debe realizar solamente
➥hasta la mitad de la cadena. */
{
cad = cadena[i];
cadena[i] = cadena[j];
cadena[j] = cad;
i++;
j--;
}
return (cadena);
}

32
7. Caracteres y cadenas de caracteres/Programas/Programa 7.18/Programa 7.18/Programa 7.18.c Normal file
View File

@@ -0,0 +1,32 @@
#include <stdio.h>
/* Cadena invertida resuelta en forma recursiva. */
void inverso(char*); /* Prototipo de función. */
void main(void)
{
char fra[50];
printf("\nIngrese la linea de texto: ");
gets(fra);
printf("\nEscribe la linea de texto en forma inversa: ");
inverso(fra);
}
void inverso(char* cadena)
/* La función inverso obtiene precisamente el inverso de la cadena. La solución
➥presentada es simple, pero para comprenderla es necesario tener conocimientos
➥tanto de pilas como de recursividad. Observa que mientras no se encuentre el
➥caracter de terminación de la cadena, se llama a la función recursiva con
➥el apuntador al siguiente caracter de la cadena. Por otra parte, queda
➥pendiente de ejecutar —almacenado en una pila— el caracter al cual apunta
➥*cadena. */
{
if (cadena[0] != '\0')
{
inverso(&cadena[1]);
putchar(cadena[0]);
}
}

44
7. Caracteres y cadenas de caracteres/Programas/Programa 7.19/Programa 7.19/Programa 7.19.c Normal file
View File

@@ -0,0 +1,44 @@
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* Cuenta palabras.
El programa calcula el número de palabras que hay en la cadena de caracteres. */
int cuentap(char*); /* Prototipo de función. */
void main(void)
{
int i;
char fra[50];
printf("\nIngrese la linea de texto: ");
gets(fra);
strcat(fra, " "); /* Se agrega un espacio en blanco al final de la
➥cadena. */
i = cuentap(fra);
printf("\nLa linea de texto tiene %d palabras", i);
}
int cuentap(char* cad)
{
/* La función cuenta el número de palabras que hay en la cadena de
➥caracteres. */
char* cad0 = "";
int i = 0;
cad0 = strstr(cad, " "); /* Se localiza el primer espacio en blanco en la
➥cadena. */
while (strcmp(cad, " "))
{
strcpy(cad, cad0);
i++;
cad0 = strstr(cad + 1, " ");
/* Se busca un espacio en blanco a partir de la siguiente posición. */
}
return (i);
}

58
7. Caracteres y cadenas de caracteres/Programas/Programa 7.2/Programa 7.2/Programa 7.2.c Normal file
View File

@@ -0,0 +1,58 @@
# include <stdio.h>
# include <ctype.h>
/* Funciones para el manejo de caracteres de la biblioteca ctype.h. */
void main(void)
{
char p1;
printf("\nIngrese un caracter para analizar si este es un digito: ");
p1 = getchar();
if (isdigit(p1))/* La función isdigit regresa 1 si p1 es un dígito y 0 en caso contrario. */
printf("%c es un digito \n", p1);
else
printf("%c no es un digito \n", p1);
fflush(stdin);
printf("\nIngrese un caracter para examinar si éste es una letra: ");
p1 = getchar();
if (isalpha(p1))/* La función isalpha regresa 1 si p1 es una letra y 0 en caso contrario. */
printf("%c es una letra \n", p1);
else
printf("%c no es una letra \n", p1);
fflush(stdin);
printf("\nIngrese un caracter para examinar si éste es una letra minuscula: ");
p1 = getchar();
if (isalpha(p1))
if (islower(p1))/* La función islower regresa 1 si p1 es una letra minúscula y 0 en caso contrario.
La función isupper, por otra parte, regresa 1 si p1 es una letra mayúscula y 0 en caso contrario. */
printf("%c es una letra minuscula \n", p1);
else
printf("%c no es una letra minuscula \n", p1);
else
printf("%c no es una letra \n", p1);
fflush(stdin);
printf("\nIngrese una letra para convertirla de mayuscula a minuscula : ");
p1 = getchar();
if (isalpha(p1))
if (isupper(p1))
printf("%c fue convertida de mayuscula a minuscula \n", tolower(p1));
/* La función tolower convierte de mayúscula a minúscula. Si la
➥letra es minúscula no la modifica. La función toupper, por otra parte,
➥convierte de minúscula a mayúscula. Si la letra es mayúscula no la
➥modifica. */
else
printf("%c es una letra minuscula \n", p1);
else
printf("%c no es una letra \n", p1);
}

50
7. Caracteres y cadenas de caracteres/Programas/Programa 7.20/Programa 7.20/Programa 7.20.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <string.h>
int longitud(char cad); /* Prototipo de función. */
void main(void)
{
int i, n, l = -1, p, t;
char cad[50], FRA[20][50];
printf("\nIngrese el numero de filas del arreglo: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("Ingrese la linea %d de texto. Maximo 50 caracteres: ", i + 1);
fflush(stdin);
gets(FRA[i]); /* Se lee la cadena de caracteres dentro del ciclo. */
}
printf("\n");
for (i = 0; i < n; i++)
{
strcpy(cad, FRA[i]);
t = longitud(cad);
if (t > l)
{
l = t;
p = i;
}
}
printf("\nLa cadena con mayor longitud es: ");
puts(FRA[p])
;
printf("\nLongitud: %d", l);
}
int longitud(char* cadena)
/* Esta función calcula la longitud de la cadena. Es idéntica a la función
➥cuenta del programa 7.13. */
{
int cue = 0;
while (!cadena[cue] == '\0')
cue++;
return (cue);
}

46
7. Caracteres y cadenas de caracteres/Programas/Programa 7.21/Programa 7.21/Programa 7.21.c Normal file
View File

@@ -0,0 +1,46 @@
#include <stdio.h>
#include <string.h>
void intercambia(char FRA[][30], int); /* Prototipo de funci<63>n. */
void main(void)
{
int i, n;
char FRA[20][30];
printf("\nIngrese el numero de filas del arreglo: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("Ingrese la linea de texto numero %d: ", i + 1);
fflush(stdin);
gets(FRA[i]);
}
printf("\n\n");
intercambia(FRA, n);
for (i = 0; i < n; i++)
{
printf("Impresion de la linea de texto %d: ", i + 1);
puts(FRA[i]);
}
}
void intercambia(char FRA[][30], int n)
/* Esta funci<63>n intercambia las filas del arreglo. */
{
int i, j;
j = n - 1;
char cad[30];
for (i = 0; i < (n / 2); i++)
{
strcpy(cad, FRA[i]);
strcpy(FRA[i], FRA[j]);
strcpy(FRA[j], cad);
j--;
}
}

84
7. Caracteres y cadenas de caracteres/Programas/Programa 7.3/Programa 7.3/Programa 7.3.c Normal file
View File

@@ -0,0 +1,84 @@
#include <stdio.h>
/* Funciones para el manejo de cadenas de caracteres de la biblioteca stdio.h. */
void main(void)
{
char* cad0 = "Buenos dias"; /* En este caso se asignan 11 caracteres más el
➥caracter de terminación ‘\0’ a la posición de memoria a la que apunta la
➥variable cad0 —apuntador del tipo cadena de caracteres. */
char cad1[20] = "Hola"; /* Se asignan cuatro caracteres más el caracter
➥de terminación a la variable tipo char cad1. Observa que cad1 tiene espacio
➥para 20 caracteres.*/
char cad2[] = "Mexico"; /* En este caso se asignan seis caracteres (más
➥el caracter de terminación) a la variable cad2. Observa que cad2 no tiene espacio
➥reservado como cad1; por lo tanto, acepta cualquier número de caracteres. */
char cad3[] = { 'B', 'i', 'e', 'n', 'v', 'e', 'n', 'i', 'd', 'o', '\0' };
/* Observa otra forma de asignación de valores a la variable cad3. */
char cad4[20], cad5[20], cad6[20];
printf("\nLa cadena cad0 es: ");
puts(cad0);
/* La función puts es la más apropiada para escribir cadenas de caracteres.
➥Observa que esta función baja automáticamente una línea después de imprimir la cadena. */
printf("\nLa cadena cad1 es: ");
printf("% s", cad1);
/* La función printf, con el formato de variable %s, también se puede utilizar
➥para escribir cadenas de caracteres. Baja automáticamente una línea después de escribir la cadena.*/
printf("\nLa cadena cad2 es: ");
puts(cad2);
printf("\nLa cadena cad3 es: ");
puts(cad3);
printf("\nIngrese una linea de texto —se lee con gets—: \n");
gets(cad4);/* La función gets es la más apropiada para leer cadenas de caracteres. */
printf("\nLa cadena cad4 es : ");
puts(cad4);
fflush(stdin);
printf("\nIngrese una linea de texto —se lee con scanf—: \n");
scanf("%s", cad5);
/* La función scanf, con el formato de variable %s, también se puede utilizar
➥para leer una cadena de caracteres, aunque con algunas restricciones. Si la
➥cadena está formada por varias palabras sólo lee la primera. Por ejemplo, si
➥queremos ingresar la cadena “Buenos días”, sólo lee la palabra “Buenos”, por
➥ello esta función únicamente es útil si conocemos con anticipación que la
➥cadena que vamos a leer está formada por una sola palabra. */
printf("\nLa cadena cad5 es: ");
printf("%s", cad5);
fflush(stdin);
char p;
int i = 0;
/* La declaración de variables siempre se debe realizar en la parte inicial del
➥programa. En este caso se colocan en esta sección (char p e int i = 0) para
➥que puedas observar la relación directa con las líneas de programación que se
➥muestran a continuación. */
printf("\nIngrese una linea de texto —se lee cada caracter con getchar—: \n");
/* Se utiliza la función getchar para leer caracteres de la línea de texto y
➥asignarlos a la variable de tipo cadena de caracteres cad6. Observa que se leen
➥caracteres mientras no se encuentre al caracter que indica fin de línea ‘\n’. */
while ((p = getchar()) != '\n')
cad6[i++] = p;
cad6[i] = '\0';
/* Al final de la cadena se incorpora el caracter de terminación NULL para
➥indicar el fin de la misma. */
printf("\nLa cadena cad6 es: ");
puts(cad6);
}

47
7. Caracteres y cadenas de caracteres/Programas/Programa 7.4/Programa 7.4/Programa 7.4.c Normal file
View File

@@ -0,0 +1,47 @@
#include <stdio.h>
/* Declaración de cadenas de caracteres y asignación de valores. */
void main(void)
{
char* cad0;
cad0 = "Argentina"; /* La declaración y la asignación son correctas. */
puts(cad0);
cad0 = "Brasil";
/* Correcto. Se modifica el contenido de la posición en memoria a la que apunta
➥la variable cad0 —apuntador de tipo cadena de caracteres. */
puts(cad0);
char* cad1;
gets(*cad1); gets(cad1);
/* Incorrecto. Ambas lecturas generan un error en la ejecución del programa.
➥Para que un apuntador de tipo cadena de caracteres se pueda utilizar con la
➥función de lectura gets, es necesario inicializarlo como se hace en la siguiente
➥instrucción. */
char* cad1 = "";
gets(cad1);
/* Correcto. Primero se le asigna un valor a la posición de memoria a la que
➥apunta cad1. Luego podemos modificar el contenido de esta posición de memoria
➥utilizando la función gets. */
char cad1[];
/* Incorrecto. Se genera un error en la compilación del programa, porque no
➥se reserva el espacio correspondiente. */
char cad2[20] = "México"; /* Correcto. */
puts(cad2);
gets(cad2);
/* El valor de una cadena (declarada como cadena[longitud]) se puede modificar
➥por medio de lecturas o utilizando funciones de la biblioteca string.h
(ejemplo 7.6). */
puts(cad2);
cad2[10] = "Guatemala";
/* Incorrecto. Observa cuidadosamente el caso anterior y analiza la diferencia
➥que existe con éste. Aquí se produce un error en la compilación del programa,
➥al tratar de asignar la cadena de caracteres ”Guatemala” al caracter 11 de la
➥cadena. */
}

60
7. Caracteres y cadenas de caracteres/Programas/Programa 7.5/Programa 7.5/Programa 7.5.c Normal file
View File

@@ -0,0 +1,60 @@
#include <stdio.h>
#include <stdlib.h>
/* Funciones para el manejo de caracteres de la biblioteca stdlib.h. */
void main(void)
{
int i;
double d;
long l;
char cad0[20] = {'\0'}, *cad1;
printf("\nIngrese una cadena de caracteres: ");
gets(cad0);
i = atoi(cad0);
/* La función atoi convierte una cadena de caracteres que contiene números
➥a un valor de tipo entero. Si la cadena comienza con otro caracter o no
➥contiene números, regresa 0 o el valor queda indefinido. */
printf("\n %s \t %d", cad0, i + 3);
/* Se imprime el valor de i+3 para demostrar que i ya fue convertido a un
➥entero.*/
printf("\nIngrese una cadena de caracteres: ");
gets(cad0);
d = atof(cad0);
/* La función atof convierte una cadena de caracteres que contiene números
➥reales a un valor de tipo double. Si la cadena comienza con otro caracter
➥o no contiene números, regresa 0 o el valor queda indefinido. */
printf("\n %s \t %.2lf ", cad0, d + 1.50);
d = strtod(cad0, &cad1);
/* La función strtod convierte una cadena de caracteres que contiene números
➥reales a un valor de tipo double. El resto de la cadena se almacena en el
➥segundo argumento de la función, &cad1, un apuntador de tipo cadena de
➥caracteres. Si la cadena no contiene números o comienza con otro caracter,
➥regresa 0 o el valor queda indefinido. */
printf("\n %s \t %.2lf", cad0, d + 1.50);
puts(cad1);
l = atol(cad0);
/* La función atol convierte una cadena de caracteres que contiene números a
➥un valor de tipo long. Si la cadena no contiene números o comienza con
➥otro caracter, regresa 0 o el valor queda indefinido. */
printf("\n %s \t %ld", cad0, l + 10);
l = strtol(cad0, &cad1, 0);
/* La función strtol convierte una cadena de caracteres que contiene números a
➥un valor de tipo long. El resto de la cadena se almacena en el otro argumento
➥de la función, &cad1. El tercer argumento se utiliza para indicar que la
➥cadena puede estar en formato octal, decimal o hexadecimal. Si la cadena no
➥contiene números o comienza con otro caracter, regresa 0 o el valor queda
➥indefinido. */
printf("\n %s \t %ld", cad0, l + 10);
puts(cad1);

66
7. Caracteres y cadenas de caracteres/Programas/Programa 7.6/Programa 7.6/Programa 7.6.c Normal file
View File

@@ -0,0 +1,66 @@
#include <stdio.h>
#include <string.h>
/* Funciones de la biblioteca string.h para el manejo de cadenas de
caracteres. */
void main(void)
{
char* cad0 = "Hola México";
char cad1[20], cad2[20], cad3[20] = ", buenos dias!!!";
strcpy(cad1, cad0);
/* La función strcpy permite copiar una cadena de caracteres completa. En este
➥caso se copia la cadena cad0 a cad1. Si el espacio reservado para cad1 es
➥menor que el de cad0, se genera un error en la ejecución del programa. */
printf("\nPrueba de la funcion strcpy. Se copia la cadena cad0 a cad1: %s\n", cad1);
strcpy(cad1, cad3);
printf("\nPrueba de la funcion strcpy. Se copia la cadena cad3 a cad1: %s\n", cad1);
strcpy(cad1, "XX");
printf("\nPrueba de la funcion strcpy. Se copia la cadena XX a cad1: %s\n", cad1);
strncpy(cad2, cad0, 4);
cad2[4] = '\0';
/* La función strncpy permite copiar un número determinado de caracteres a
➥otra cadena de caracteres. En este caso se copian 4 caracteres de la cadena
➥cad0 —segundo argumento— a cad2 —primer argumento. Siempre se debe
➥incorporar al final de la cadena el caracter de terminación. Si el espacio
➥reservado para cad2 es menor que lo que se pretende copiar, se genera
➥un error en la ejecución del programa. */
printf("\nPrueba de la funcion strncpy.Se copian 4 caracteres de cad0 a cad2: %s\n", cad2);
strncpy(cad2, cad3, 3);
cad2[3] = '\0';
printf("\nPrueba de la funcion strncpy. Se copian 3 caracteres de cad3 acad2: %s\n", cad2);
strcat(cad0, cad3);
/* La función strcat permite incorporar una cadena de caracteres a otra
➥cadena dada. En este caso se agrega la cadena cad3 a cad0. Si el espacio
➥reservado para cad0 es menor a lo que se debe almacenar se genera un error
➥de ejecución. */
printf("\nPrueba de la funcion strcat. Se incorpora la cadena cad3 a cad0: %s\n", cad0);
strcat(cad1, "YY");
printf("\nPrueba de la funcion strcat.Se incorpora la cadena YY a cad1: %s\n", cad1);
strcat(cad2, " ");
strncat(cad2, cad0, 4);
printf("\nPrueba de la funcion strncat. Se incorporan 4 caracteres de cad0 a cad2: %s\n", cad2);
/* La función strncat permite incorporar un número determinado de caracteres
➥a una cadena. En este caso se agregan cuatro caracteres de la cadena cad0
➥a cad2. Si el espacio de cad2 es menor a lo que se debe almacenar ocurre
➥un error de ejecución. */
cad0 = strstr(cad0, "Mexico");
printf("\nPrueba de la funcion strstr. Se trata de localizar la cadena Mexico dentro de cad0: %s\n", cad0);
/* La función strstr se utiliza para localizar una cadena de caracteres dentro
➥de otra cadena. Si la encuentra, regresa un apuntador al inicio de la
➥primera ocurrencia de la cadena localizada. De otra forma, regresa NULL. */
cad0 = strstr(cad0, "Guatemala");
printf("\nPrueba de la funcion strstr. Se trata de localizar la cadena Guatemala dentro de cad0: %s\n", cad0);
}

55
7. Caracteres y cadenas de caracteres/Programas/Programa 7.7/Programa 7.7/Programa 7.7.c Normal file
View File

@@ -0,0 +1,55 @@
#include <stdio.h>
#include <string.h>
/* Otras funciones de la biblioteca string.h para el manejo de cadenas. */
void main(void)
{
int i;
char cad0[20] = "Hola Mexico";
char cad1[20] = "Hola Guatemala";
char cad2[20] = "Hola Venezuela";
char cad3[20] = "Hola México";
char* c, c3;
i = strcmp(cad0, cad1);
/* La función strcmp permite comparar dos cadenas de caracteres. Si la
➥primera cadena —en este caso cad0— es mayor a la segunda —cad1—,
➥regresa un valor positivo; si es menor, un valor negativo y de otra forma,
➥0. */
printf("\nResultado de la comparacion —cad0 y cad1—: %d", i);
i = strcmp(cad0, cad2);
printf("\nResultado de la comparacion —cad0 y cad2—: %d", i);
i = strcmp(cad0, cad3);
printf("\nResultado de la comparacion —cad0 y cad3—: %d", i);
i = strlen(cad0);
/* La función strlen obtiene la longitud —el número de caracteres— de
➥una cadena. */
printf("\nLongitud cadena cad0: %d", i);
i = strlen(cad1);
printf("\nLongitud cadena cad1: %d", i);
c = strchr(cad1, 'G'); /* c es un apuntador de tipo caracter.
*/
/* La función strchr busca la posición en la que se encuentra un
➥determinado caracter en la cadena de caracteres. Si lo encuentra regresa
➥un apuntador a la primera ocurrencia del caracter en la cadena, de otra
➥forma regresa NULL. */
if (c != NULL)
{
c3 = *c; /* c3 toma el contenido de la celda de memoria a la
➥que apunta c.*/
printf("\nEl valor de c3 es: %c", c3);
}
c = strchr(cad2, 'V');
if (c != NULL)
{
c3 = *c;
printf("\nEl valor de c3 es: %c", c3);
}

50
7. Caracteres y cadenas de caracteres/Programas/Programa 7.8/Programa 7.8/Programa 7.8.c Normal file
View File

@@ -0,0 +1,50 @@
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* Minúsculas y mayúsculas.
El programa, al recibir como dato un arreglo unidimensional de tipo
➥cadena de caracteres, determina el número de minúsculas y mayúsculas
➥que hay en cada cadena. */
void minymay(char cad); /* Prototipo de función. */
void main(void)
{
int i, n;
char FRA[20][50];
/* Observa cómo se declara el arreglo unidimensional de cadena de
➥caracteres. */
printf("\nIngrese el numero de filas del arreglo: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
/* Para cada fila se lee la cadena correspondiente. */
printf("Ingrese la linea %d de texto: ", i + 1);
fflush(stdin);
gets(FRA[i]);
}
printf("\n\n");
for (i = 0; i < n; i++)
minymay(FRA[i]);
}
void minymay(char* cadena)
/* Esta función se utiliza para calcular el número de minúsculas
➥y mayúsculas que hay en cada cadena. */
{
int i = 0, mi = 0, ma = 0;
while (cadena[i] != '\0')
{
if (islower(cadena[i]))
mi++;
else
if (isupper(cadena[i]))
ma++;
i++;
}
printf("\n\nNumero de letras minusculas: %d", mi);
printf("\nNumero de letras mayusculas: %d", ma);
}

35
7. Caracteres y cadenas de caracteres/Programas/Programa 7.9/Programa 7.9/Programa 7.9.c Normal file
View File

@@ -0,0 +1,35 @@
#include <stdio.h>
/* Cuenta caracteres.
El programa, al recibir como datos una cadena de caracteres y un caracter,
➥cuenta cuántas veces se encuentra el caracter en la cadena. */
int cuenta(char*, char); /* Prototipo de función. */
void main(void)
{
char car, cad[50];
int res;
printf("\nIngrese la cadena de caracteres: ");
gets(cad);
fflush(stdin);
printf("\nIngrese el caracter : ");
car = getchar();
res = cuenta(cad, car);
printf("\n\n % c se encuentra %d veces en la cadena %s", car, res, cad);
}
int cuenta(char* cad, char car)
/* Esta función se utiliza para obtener el número de veces que se encuentra
➥el caracter en la cadena. */
{
int i = 0, r = 0;
while (cad[i] != '\0')
{
if (cad[i] == car)
r++;
i++;
}
return (r);
}