Ordenamiento de Argumentos de Línea de Comandos
1 #include <stdio.h>
2 #include<string.h>
3 void ordenar(int cantidad, char *elementos[]);
4 int main(int argc, char *argv[]) {
5 int indice;
6 ordenar(argc-1, argv+1);
7 for(indice = 1; indice < argc; ++indice)
8 printf("hola, %s\n", argv[indice]);
9
10 return 0;
11 }
12 void ordenar(int cantidad,char *elementos[]){
13 int i,j;
14 char *intercambio;
15 for(i=0;i<cantidad-i;i++){
16 for(j=0;j<cantidad-i-1;j++){
17 if(strcmp(elementos[j],elementos[j+1])>0){
18 intercambio=elementos[j];
19 elementos[j]=elementos[j+1];
20 elementos[j+1]=intercambio;
21 }
22 }
23 }
24
25
26 }
Ver CódigoBúsqueda de Mínimo y Máximo en Arreglo
1 #include<stdio.h>
2 #include<stdlib.h>
3 #define TAMANIO 5
4 void ingresar(int arreglo[],int cantidad);
5 void mostrar(int arreglo[],int cantidad);
6 void buscar_min_max(int arreglo[],int cantidad,int *pmin,int *pmax);
7 int main(){
8 int arreglo[TAMANIO];
9 int minimo,maximo;
10 printf("Ingrese %d datos:\n",TAMANIO);
11 ingresar(arreglo,TAMANIO);
12 printf("Los datos son:\n");
13 mostrar(arreglo,TAMANIO);
14 printf("Procesando datos...\n");
15 buscar_min_max(arreglo,TAMANIO,&minimo,&maximo);
16 printf("El resultado es:\n");
17 printf("min=%d,max=%d",minimo,maximo);
18 system("pause");
19 return 0;
20 }
21 void ingresar(int arreglo[],int cantidad){
22 int i;
23 for(i=0;i<cantidad;++i)
24 scanf("%d",&arreglo[i]);
25 }
26 void mostrar(int arreglo[],int cantidad){
27 int i=0;
28 for(i=0;i<cantidad;++i)
29 printf("%d",arreglo[i]);
30 printf("\n");
31 }
32 void buscar_min_max(int arreglo[],int cantidad,int *pmin,int *pmax){
33 int i;
34 *pmin=*pmax=arreglo[0];
35 for(i=0;i<cantidad;++i){
36 if(arreglo[i]<*pmin)
37 *pmin=arreglo[i];
38 else if(arreglo[i]>*pmax)
39 *pmax=arreglo[i];
40 }
41 }
Ver CódigoPregunta 1: La función busca el valor mínimo y máximo en el arreglo. Pregunta 2: Apunta a la dirección del primer elemento del arreglo. Encontrar el Valor Máximo
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 # define TAM 5
4 void ingresar(int arreglo[], int cantidad);
5 void mostrar(int arreglo[], int cantidad);
6 int* buscar_maximo(int arreglo[], int cantidad);
7 int main() {
8 int arreglo[TAM];
9 int* puntero_max;
10 printf("Ingrese %d datos:\n", TAM);
11 ingresar(arreglo, TAM);
12 printf("Los datos son: \n");
13 mostrar(arreglo, TAM);
14 printf("Procesando datos...\n");
15 puntero_max = buscar_maximo(arreglo, TAM);
16 printf("El resultado:\n");
17 printf("max = %d\n", *puntero_max);
18 return 0;
19 }
20 void ingresar(int arreglo[], int cantidad) {
21 int i;
22 for (i = 0; i < cantidad; ++i)
23 scanf("%d", &arreglo[i]);
24 }
25 void mostrar(int arreglo[], int cantidad) {
26 int i;
27 for (i = 0; i < cantidad; ++i)
28 printf("%d ", arreglo[i]);
29 printf("\n");
30 }
31 int* buscar_maximo(int arreglo[], int cantidad) {
32 int indice_max = 0;
33 int i;
34 for (i = 0; i < cantidad; ++i)
35 if (arreglo[i] > arreglo[indice_max])
36 indice_max = arreglo[i];
37 return &arreglo[indice_max];
38 }
Ver CódigoPregunta 1: La función encuentra la dirección del valor máximo. Retorna la dirección del valor máximo. Pregunta 2: Sí, es posible. Manipulación de Cadenas de Caracteres
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 # define LONGITUD 80
5 int main() {
6 char cadena1[LONGITUD] = "Aprender me hace feliz";
7 char cadena2[LONGITUD] = "Aprender me hace somnoliento";
8 char temporal[LONGITUD];
9 printf("sizeof(cadena1) vs. strlen(cadena1):\n");
10 printf("sizeof(cadena1)=%d\n", sizeof(cadena1));
11 printf("strlen(cadena1)=%d\n", strlen(cadena1));
12 printf("\nantes del intercambio: \n");
13 printf("cadena1: %s\n", cadena1);
14 printf("cadena2: %s\n", cadena2);
15 printf("\nintercambiando...\n");
16 strcpy(temporal, cadena1);
17 strcpy(cadena1, cadena2);
18 strcpy(cadena2, temporal);
19 printf("\ndespués del intercambio: \n");
20 printf("cadena1: %s\n", cadena1);
21 printf("cadena2: %s\n", cadena2);
22 return 0;
23 }
Ver CódigoPregunta 1: El tamaño de cadena1 es 80, sizeof calcula el tamaño del arreglo, strlen calcula la longitud de la cadena. Pregunta 2: No se puede asignar una cadena directamente a una dirección de arreglo. Pregunta 3: Sí, se intercambiaron los contenidos de las cadenas. Intercambio de Cadenas con Punteros
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 # define LONGITUD 80
5 int main() {
6 char *cadena1 = "Aprender me hace feliz";
7 char *cadena2 = "Aprender me hace somnoliento";
8 char *temporal;
9 printf("sizeof(cadena1) vs. strlen(cadena1):\n");
10 printf("sizeof(cadena1)=%d\n", sizeof(cadena1));
11 printf("strlen(cadena1)=%d\n", strlen(cadena1));
12 printf("\nantes del intercambio: \n");
13 printf("cadena1: %s\n", cadena1);
14 printf("cadena2: %s\n", cadena2);
15 printf("\nintercambiando...\n");
16 temporal = cadena1;
17 cadena1 = cadena2;
18 cadena2 = temporal;
19 printf("\ndespués del intercambio: \n");
20 printf("cadena1: %s\n", cadena1);
21 printf("cadena2: %s\n", cadena2);
22 return 0;
23 }
Ver CódigoPregunta 1: cadena1 almacena la direción inicial de "Aprender...". sizeof(cadena1) calcula los bytes ocupados por la dirección del puntero. strlen calcula la longitud de la cadena. Pregunta 2: Sí es posible. La diferencia es que en 2.2 se asigna la dirección de la cadena al puntero cadena1, lo cual es válido. Pregunta 3: Se intercambian las direcciones a las que apuntan cadena1 y cadena2. Las cadenas no se intercambiaron. Aceso a Arreglos Bidimensionales
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 int main() {
4 int matriz[2][4] = { {1, 9, 8, 4}, {2, 0, 4, 9} };
5 int i, j;
6 int *ptr_elemento;
7 int(*ptr_fila)[4];
8 printf("Salida 1: Acceso directo usando nombre de arreglo e índices\n");
9 for (i = 0; i < 2; ++i) {
10 for (j = 0; j < 4; ++j)
11 printf("%d", matriz[i][j]);
12 printf("\n");
13 }
14 printf("\nSalida 2: Acceso indirecto usando puntero a elementos\n");
15 for (ptr_elemento = &matriz[0][0], i = 0; ptr_elemento < &matriz[0][0] + 8; ++ptr_elemento,++i) {
16 printf("%d", *ptr_elemento);
17 if ((i + 1) % 4 == 0)
18 printf("\n");
19 }
20 printf("\nSalida 3: Acceso indirecto usando puntero a arreglos unidimensionales\n");
21 for (ptr_fila = matriz; ptr_fila < matriz + 2; ++ptr_fila) {
22 for (j = 0; j < 4; ++j)
23 printf("%d", *(*ptr_fila + j));
24 printf("\n");
25 }
26
27 return 0;
28 }
Ver CódigoReemplazo de Caracteres en una Cadena
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #define LONGITUD 80
4 void reemplazar(char* texto, char caracter_viejo, char caracter_nuevo);
5 int main() {
6 char texto[LONGITUD] = "programar es difícil o no, es una pregunta";
7 printf("Texto original:\n");
8 printf("%s\n", texto);
9 reemplazar(texto, 'i', '*');
10 printf("Texto procesado:\n");
11 printf("%s\n", texto);
12 return 0;
13 }
14 void reemplazar(char* texto, char caracter_viejo, char caracter_nuevo) {
15 while (*texto) {
16 if (*texto == caracter_viejo)
17 *texto = caracter_nuevo;
18 texto++;
19 }
20 }
Ver CódigoPregunta 1: La función remeplaza un carácter específico por uno nuevo en la cadena. Pregunta 2: Sí es posible. Truncamiento de Cadena
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #define LONGITUD 80
4 char* truncar_cadena(char* cadena, char caracter);
5 int main() {
6 char cadena[LONGITUD];
7 char caracter;
8 while (printf("Ingrese una cadena: "), gets(cadena) != NULL) {
9 printf("Ingrese un caracter:");
10 caracter = getchar();
11 printf("Truncando...\n");
12 truncar_cadena(cadena, caracter);
13 printf("Cadena truncada: %s\n\n", cadena);
14 getchar();
15 }
16 return 0;
17 }
18 char* truncar_cadena(char* cadena, char caracter) {
19 while (*cadena) {
20 if (*cadena == caracter) {
21 *cadena = '\0';
22 break;
23 }
24 else
25 cadena++;
26 }
27 return cadena;
28 }
Ver CódigoValidación de Identificadores
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #define NUMERO 5
5 int validar_id(char* identificador);
6 int main() {
7 char* ident[NUMERO] = { "31010120000721656X",
8 "3301061996X0203301",
9 "53010220051126571",
10 "510104199211197977",
11 "53010220051126133Y" };
12 int i;
13 for (i = 0; i < NUMERO; i++) {
14 if (validar_id(ident[i]))
15 printf("%s\tVerdadero\n",ident[i]);
16 else
17 printf("%s\tFalso\n",ident[i]);
18 }
19
20 return 0;
21 }
22 int validar_id(char* identificador) {
23 int i = 0;
24 char* p = identificador;
25 while (*identificador) {
26 if (*identificador >= '0' && *identificador <= '9')
27 i++, identificador++;
28 else
29 break;
30 }
31 if (i == 18)
32 return 1;
33 else if (i == 17 && (*(p+17) == 'x' || *(p + 17) == 'X'))
34 return 1;
35 else
36 return 0;
37
38 }
Ver CódigoCodificador y Decodificador de Texto
1 #define _CRT_SECURE_NO_WARNINGS
2 #include<stdio.h>
3 #include<string.h>
4 #define LONGITUD 80
5 void codificar(char *texto, int n);
6 void decodificar(char* texto, int n);
7 int main(){
8 char frase[LONGITUD];
9 int desplazamiento;
10 printf("Ingrese texto en inglés:");
11 gets(frase);
12 printf("Ingrese desplazamiento:");
13 scanf("%d", &desplazamiento);
14 printf("Texto codificado:");
15 codificar(frase, desplazamiento);
16 printf("%s\n", frase);
17 printf("Decodificando el texto codificado:");
18 decodificar(frase, desplazamiento);
19 printf("%s\n", frase);
20 return 0;
21 }
22 void codificar(char* texto, int n) {
23 char* p = texto;
24 while(*p){
25 if (*p >= 'a' && *p <= 'z') {
26 *p = 'a' + (*p - 'a' + n) % 26;
27 }
28 else if(*p>='A'&&*p<='Z')
29 *p = 'A' + (*p-'A' + n) % 26;
30 p++;
31 }
32 }
33 void decodificar(char* texto, int n) {
34 while (*texto) {
35 if (*texto >= 'a' && *texto <= 'z') {
36 *texto = 'a' + (*texto - 'a' - n+26) % 26;
37 }
38 else if (*texto >= 'A' && *texto <= 'Z') {
39 *texto = 'A' + (*texto - 'A' - n + 26) % 26;
40 }
41 texto++;
42 }
43 }