16/11/2022 ; 6:12 PM
This commit is contained in:
@@ -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. */
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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]));
|
||||
}
|
||||
@@ -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++;
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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--;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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. */
|
||||
}
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
Reference in New Issue
Block a user