Lista Enlazada Simple Borrado

/*Realiza un programa para enlazar una lista simple, añade 1 menu que nos
permita borrar cualquier elemento de la lista sin perder infromacion.*/
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
//Definimos el nodo
struct registro{
   char nombre[40];
   struct registro *sig;    
};
//Acuñamos un nuevo tipo de dato: nodo
//Así, más adelante, en la función malloc
//podremos utilizar sizeof(nodo)
typedef struct registro nodo;
int mostrar_menu(){
    int opcion;
    system("cls");
    printf("\n********* MENU *********");
    printf("\n0. Salir del programa.");
    printf("\n1. Leer lista enlazada.");
    printf("\n2. Mostrar lista.");
    printf("\n3. Borrar un elemento.");
    printf("\n4. Insertar  un elemento.");
    printf("\nElige una de las opciones: ");
    scanf("%d",&opcion);
    return(opcion);
}
void leer_lista(nodo *inicio){
    nodo *registro;
    int cont=1;
    char seguir='s';
    registro=inicio;
    do{
       printf("\nNombre nodo %d: ",cont++);
       scanf(" %[^\n]",registro->nombre);
       printf("\nDeseas leer mas nombres (s/n)?: ");
       scanf(" %c",&seguir);
       if(seguir=='s'){
          registro->sig=(nodo *) malloc(1*sizeof(nodo));
          registro=registro->sig;
       }
       else{
          printf("\nFINAL DE LA LISTA");
          registro->sig=0;    
      }
    }while(seguir=='s');
    return;
}
void mostrar_lista(nodo *inicio){
   nodo *registro;
   int cont=1;
   registro=inicio;
   printf("\n************ LISTA ************");
   do{
    printf("\n Direccion: %X\tNombre %d: %s\tApunta a: %X",registro,cont++,registro->nombre,registro->sig);  
    registro=registro->sig;
   }while(registro!=0);
   printf("\n\nPara continuar presione cualquier tecla.");
   fflush(stdin);
   getchar();
   return;
}
nodo *borrar_nodo(nodo *inicio,char aux_nombre[]){
   nodo *registro;
   char seguir='s';
   registro=inicio;
   //En caso de que el nodo que quiero borrar
   //sea el primero
   if(strcmp(registro->nombre,aux_nombre)==0)
     inicio=registro->sig;
   else  
   //EN caso de que el nodo que quiero borrar
   //esté entre el primero y el último
   do{
        if(strcmp((registro->sig)->nombre,aux_nombre)==0){
            registro->sig=(registro->sig)->sig;
            seguir='n';
        }
        else
            registro=registro->sig;
    }while(seguir=='s' && registro!=0);
   //En caso de que el nodo que quiera borrar
   // sea el último de la fila
   return(inicio);
}
nodo *insertar_nodo(nodo *inicio,char aux_nombre[],char aux_nombre_anterior[]){
   nodo *registro,*nuevo;
   char seguir='s';
   registro=inicio;
   nuevo=(nodo *) malloc(1*sizeof(nodo));
   strcpy(nuevo->nombre,aux_nombre);
   //Supongo que insertamos en una posicion intermedia
   do{
      if(strcmp((registro->sig)->nombre,aux_nombre_anterior)==0){
            //Conectamos con el siguiente
            nuevo->sig=registro->sig;
            registro->sig=nuevo;
            seguir='n';
      }
      else
          registro=registro->sig;
   }while(seguir=='s' && registro!=0);
   return(inicio);
}
main(){
    //Reservamos memoria para el puntero
    //al primer nodo
    nodo *inicio;
    char aux_nombre[40],aux_nombre_anterior[40];
    inicio=(nodo *) malloc(1*sizeof(nodo));
    int opcion;
    do{
        opcion=mostrar_menu();
        switch(opcion){
            case 0:
                    printf("\nPrograma finalizado");
                    break;
            case 1: //Leer lista
                    leer_lista(inicio);
                    break;
            case 2: //Mostrar lista
                    mostrar_lista(inicio);
                    break;
            case 3://Eliminar nodo
                    printf("\nEscriba el nombre que desea borrar de la lista: ");
                    scanf(" %[^\n]",aux_nombre);
                    inicio=borrar_nodo(inicio,aux_nombre);
                    break;
            case 4:
                    system("cls");
                    printf("\nNombre: ");
                    scanf(" %[^\n]",aux_nombre);
                    printf("\nDelante de quien desea insertar ese nombre: ");
                    scanf(" %[^\n]",aux_nombre_anterior);
                    inicio=insertar_nodo(inicio,aux_nombre,aux_nombre_anterior);
                    break;
            default:
                 printf("\nOpcion incorrecta.");
                 getchar();    
        }
    }while(opcion!=0);
    getchar();
    getchar();
}

Lista Enlazada Doble

/*Completa el código de la función
mostrar_lista_inversa() para que reciba un
puntero al último elemento de la lista y
la muestre por pantalla desde el último al
primer elemento, es decir, en orden inverso

*/
#include<stdio.h>

/*typedef struct{
char nombre[30];
   int edad;
   registro *siguiente;      
}registro; *///ESTO ES IMPOSIBLE


struct elemento_lista{
   char nombre[30];
   int edad;
   struct elemento_lista *siguiente;
   struct elemento_lista *anterior;      
};
//Defino un nuevo tipo de dato al que llamare
//nodo
typedef struct elemento_lista nodo;
void mostrar_lista_inversa(nodo *final){

}
void mostrar_lista(nodo *principio){
     nodo *registro;
     registro=principio;
     int cont=1;
     char seguir='s';
     printf("\n****CONTENIDO DE LA LISTA DE MIS AMIGOS****");
     do{
       printf("\nAMIGO %d",cont++);
       printf("\nNombre: %s",registro->nombre);
       printf("\nEdad: %d",registro->edad);
       if(registro->siguiente!=0)
          registro=registro->siguiente;                      
       else{
          printf("\nFIN DE LA LISTA");
          seguir='n';
       }
     }while(seguir=='s');
    
     return;          
}
nodo *enlazar_lista(nodo *principio){
      int cont=1;
      char seguir='s';
      nodo *registro, *aux_anterior,*final;
      registro=principio;
      aux_anterior=0;
     do{
       printf("\n***Amigo %d***",cont++);
       printf("\nNombre: ");
       scanf(" %[^\n]",registro->nombre);
       printf("\nEdad: ");
       scanf("%d",&registro->edad);
       printf("\nDeseas tener un nuevo amigo (s/n): ");
       scanf(" %c",&seguir);
       if(seguir=='s')
           registro->siguiente=(nodo *)malloc(1*sizeof(nodo));
       else{
           final=registro;
           registro->siguiente=0;
           printf("\nLista enlazada finalizada");
       }
       registro->anterior=aux_anterior;
       aux_anterior=registro;
       registro=registro->siguiente;
     }while(seguir=='s');        
     return(final);        
}
main(){
     nodo *registro,*principio,*final;
     registro=(nodo *) malloc(1*sizeof(nodo));
     principio=registro;
     final=enlazar_lista(principio);
     mostrar_lista(principio);
     mostrar_lista_inversa(final);
     getchar();
     getchar();
}

Cartel Giratorio

Cada Intro que pulses, el mensaje cambiara:


/*Escribe el codigo de un programa para mostrar por pantalla 4 mensaje
publicitario mediante una lista enlazada simple circular
(conecta el ultimo con el primero)*/
#include<stdio.h>
#include<stdlib.h>
struct registro{
    char mensaje[150];
    struct registro *sig;
};
typedef struct registro nodo;
int mostrar_menu(){
    int opcion;
    printf("\n********** MENU **********");
    printf("\n0.Salir del Programa.");
    printf("\n1.Crear lista enlazada.");
    printf("\n2.Reproducir lista enlazada.");
    printf("\nElige una opcion: ");
    scanf("%d",&opcion);
    return(opcion);
}
void crear_lista(nodo *inicio){
    nodo *registro;
    registro=inicio;
    int cont=1;
    char seguir='s';
  
    printf("\nIntroduce los mensajes: ");
    do{
        printf("\n Mnesaje %d: ",cont++);
        scanf(" %[^\n]",registro->mensaje);
        printf("\nDeseas introducir otro mensaje(s/n)?: ");
        scanf(" %c",&seguir);
        if(seguir=='s'){
          registro->sig=(nodo *) malloc(1*sizeof(nodo));
          registro=registro->sig;
        }
        else{
          printf("\nFin de los Mensajes.");
          registro->sig=inicio;
        }
    }while(seguir=='s');
    return;
}
void mostrar_lista(nodo *inicio){
    nodo *registro;
    registro=inicio;
    char seguir='s';
    do{
       printf("\n**********");
       printf("%s",registro->mensaje);
       registro=registro->sig;
       getchar();
       system("cls");
    }while(registro->sig!=0);
  
    return;
}
main(){
    int opcion;
    nodo *inicio;
    char seguir='s';
    inicio=(nodo *) malloc(1*sizeof(nodo));
  
    do{
       opcion=mostrar_menu();
       switch(opcion){
            case 0:
                printf("\nFin del Programa.");
                break;
            case 1:
                crear_lista(inicio);
                break;
            case 2:
                mostrar_lista(inicio);
                break;
            default:
                printf("\nError.");
        }
    }while(seguir=='s');  


       getchar();
       getchar();
}

Cartel Giratorio

Cada Intro que pulses, el mensaje cambiara:


/*Escribe el codigo de un programa para mostrar por pantalla 4 mensaje
publicitario mediante una lista enlazada simple circular
(conecta el ultimo con el primero)*/
#include<stdio.h>
#include<stdlib.h>
struct registro{
    char mensaje[150];
    struct registro *sig;
};
typedef struct registro nodo;
int mostrar_menu(){
    int opcion;
    printf("\n********** MENU **********");
    printf("\n0.Salir del Programa.");
    printf("\n1.Crear lista enlazada.");
    printf("\n2.Reproducir lista enlazada.");
    printf("\nElige una opcion: ");
    scanf("%d",&opcion);
    return(opcion);
}
void crear_lista(nodo *inicio){
    nodo *registro;
    registro=inicio;
    int cont=1;
    char seguir='s';
  
    printf("\nIntroduce los mensajes: ");
    do{
        printf("\n Mnesaje %d: ",cont++);
        scanf(" %[^\n]",registro->mensaje);
        printf("\nDeseas introducir otro mensaje(s/n)?: ");
        scanf(" %c",&seguir);
        if(seguir=='s'){
          registro->sig=(nodo *) malloc(1*sizeof(nodo));
          registro=registro->sig;
        }
        else{
          printf("\nFin de los Mensajes.");
          registro->sig=inicio;
        }
    }while(seguir=='s');
    return;
}
void mostrar_lista(nodo *inicio){
    nodo *registro;
    registro=inicio;
    char seguir='s';
    do{
       printf("\n**********");
       printf("%s",registro->mensaje);
       registro=registro->sig;
       getchar();
       system("cls");
    }while(registro->sig!=0);
  
    return;
}
main(){
    int opcion;
    nodo *inicio;
    char seguir='s';
    inicio=(nodo *) malloc(1*sizeof(nodo));
  
    do{
       opcion=mostrar_menu();
       switch(opcion){
            case 0:
                printf("\nFin del Programa.");
                break;
            case 1:
                crear_lista(inicio);
                break;
            case 2:
                mostrar_lista(inicio);
                break;
            default:
                printf("\nError.");
        }
    }while(seguir=='s');  


       getchar();
       getchar();
}

Lista enlazada simple

#include<stdio.h>
/*typedef struct{
char nombre[30];
   int edad;
   registro *siguiente;      
}registro; ESTO ES IMPOSIBLE*/
struct elemento_lista{
   char nombre[30];
   int edad;
   struct elemento_lista *siguiente;      
};
//Defino un nuevo tipo de dato al que llamare
//nodo
typedef struct elemento_lista nodo;
void mostrar_lista(nodo *principio){
     nodo *registro;
     registro=principio;
     int cont=1;
     char seguir='s';
     printf("\n****CONTENIDO DE LA LISTA DE MIS AMIGOS****");
     do{
       printf("\n********************");
       printf("\nAMIGO %d",cont++);
       printf("\nNombre: %s",registro->nombre);
       printf("\nEdad: %d",registro->edad);
       if(registro->siguiente!=0)
          registro=registro->siguiente;                      
       else{
          printf("\n\nFIN DE LA LISTA");
          seguir='n';
       }
     }while(seguir=='s');
     return;          
}
main(){
     nodo *registro,*principio;
     int cont=1;
     char seguir='s';
    
     registro=(nodo *) malloc(1*sizeof(nodo));
     principio=registro;
    
     do{
       printf("\n***Amigo %d***",cont++);
       printf("\nNombre: ");
       scanf(" %[^\n]",registro->nombre);
       printf("\nEdad: ");
       scanf("%d",&registro->edad);
       printf("\nDeseas tener un nuevo amigo (s/n): ");
       scanf(" %c",&seguir);
       if(seguir=='s'){
           registro->siguiente=(nodo *)malloc(1*sizeof(nodo));
           registro=registro->siguiente;
       }
       else{
           printf("\nLista enlazada finalizada");
           registro->siguiente=0;
       }
     }while(seguir=='s');
     //enlazar_lista(principio);
     mostrar_lista(principio);
     getchar();
     getchar();
}

Ejercicio de Ficheros Resuelto

/*Queremos idear un programa que permita:
1. Generar un fichero de texto para guardar una lista de platos de un
restaurante, el numero de calorias y el precio y guardarlo en un txt
2. Recuperar los platos del fichero txt y ordenarlos por su precio de mayor a
menor guardando la lista ordenada en un fichero con formato propio que incluya
el nombre del plato y el precio mas iva*/
#include<stdio.h>
#include<stdlib.h>
typedef struct{
    char nombre[80];
    int calorias;
    float precio;      
}plato;
int mostrar_menu(){
    int opcion;
    system("cls");
    printf("\n******MENU*****");
    printf("\n0. Salir del programa.");
    printf("\n1. Introducir los platos en un fichero .txt.");
    printf("\n2. Mostrar el contenido del fichero.");
    printf("\n3. Volcar los datos del fichero .txt en un fichero .mdd ordenados.");
    printf("\n4. Mostramos el .mdd.");          
    printf("\nElige una opcion: ");
    scanf("%d",&opcion);
    return(opcion);        
}
void leer_platos(){
    FILE *fichero;
    plato plato_leido;
    char ruta[80];
    char seguir='s';
    int cont=1;
    printf("\nIntroduce la ruta: ");
    scanf(" %[^\n]",ruta);
    fichero=fopen(ruta,"w");
    do{
       printf("\nPLATO %d",cont);
       printf("\nNombre del plato: ");
       scanf(" %[^\n]",plato_leido.nombre);
       printf("\nCalorias: ");
       scanf("%d",&plato_leido.calorias);
       printf("\nPrecio: ");
       scanf("%f",&plato_leido.precio);
       fprintf(fichero,"%s\t%d\t%.2f\n",plato_leido.nombre,plato_leido.calorias,plato_leido.precio);                
       printf("\nDesearias introducir un nuevo plato (s/n): ");
       scanf(" %c",&seguir);
       cont++;                    
    }while(seguir=='s');      
    fclose(fichero);        
}
void mostrar_fichero(){
    FILE *fichero;
    plato plato_leido;
    char ruta[80];
    char seguir='s';
    int cont=1;
    printf("\nIntroduce la ruta: ");
    scanf(" %[^\n]",ruta);
    fichero=fopen(ruta,"r");
    printf("\nCONTENIDO DEL FICHERO: %s",ruta);
    printf("\nPLATO\tCalorias\tPrecio\n");
    do{
       fscanf(fichero,"%[^\t]\t%d\t%f\n",plato_leido.nombre,&plato_leido.calorias,&plato_leido.precio);                    
       printf("%s\t%d\t%.2f\n",plato_leido.nombre,plato_leido.calorias,plato_leido.precio);
    }while(feof(fichero)==0);  
    printf("\nPara continuar presiona cualquier tecla: ");
    fflush(stdin);
    getchar();  
   return;              
}
int leer_datos(FILE *fichero_origen,plato *plato_leido[]){
      int cont=0;
      do{
       plato_leido[cont]=(plato *) malloc(1*sizeof(plato));
       fscanf(fichero_origen,"%[^\t]\t%d\t%f\n",plato_leido[cont]->nombre,&plato_leido[cont]->calorias,&plato_leido[cont]->precio);                    
       //Añadimos el IVA al precio del plato
       plato_leido[cont]->nombre=(plato_leido[cont]->precio*1.18);
       cont++;
    }while(feof(fichero_origen)==0);
    return(cont);          
}
void mostrar_platos_leidos(plato *plato_leido[],int nplatos){
     int cont;
     printf("\nPLATOS LEIDOS");
     for(cont=0;cont<nplatos;cont++){
         printf("\nNombre del plato=%s",plato_leido[cont]->nombre);
         printf("\nCalorias= %d",plato_leido[cont]->calorias);
         printf("\nPrecio= %.2f",plato_leido[cont]->precio);
         printf("\n*****************************");                          
     }                                    
     getchar();
     getchar();
     return;                                    
}
void ordeno_datos(plato *plato_leido[],int nplatos){
     int veces,cont;
     plato *aux;
     for(veces=1;veces<nplatos;veces++)
       for(cont=0;cont<nplatos-1;cont++)
         if(plato_leido[cont]->precio<plato_leido[cont+1]->precio){
           aux=plato_leido[cont];
           plato_leido[cont]=plato_leido[cont+1];
           plato_leido[cont+1]=aux;
         }
     return;
}
void grabo_datos(FILE *fichero_destino,plato *plato_leido[],int nplatos){
     char ruta[80];
     int cont;
     printf("\nIntroduce la ruta en la que quieres guardar el fichero .mdd: ");
     scanf(" %[^\n]",ruta);
     fichero_destino=fopen(ruta,"w");
     if(fichero_destino==0)
       printf("\nError en la ruta.");
     else{
       for(cont=0;cont<nplatos;cont++)  
         fwrite(plato_leido[cont],sizeof(plato),1,fichero_destino);
       fclose(fichero_destino);
     }
     return;                              
}
void pasar_txt_format_ordenado(){
     char ruta[80];
     plato *plato_leido[50];
     int nplatos;
     FILE *fichero_origen,*fichero_destino;
     printf("\nIntroduce la ruta: ");
     scanf(" %[^\n]",ruta);
     fichero_origen=fopen(ruta,"r");
     nplatos=leer_datos(fichero_origen,plato_leido);
     mostrar_platos_leidos(plato_leido,nplatos);
     ordeno_datos(plato_leido,nplatos);
     printf("\nDespues de ordenar los platos: \n");
     mostrar_platos_leidos(plato_leido,nplatos);
     grabo_datos(fichero_destino,plato_leido,nplatos);
     return;                      
}
void mostrar_mdd(){
     FILE *fichero_destino;
     char ruta[80];
     plato plato_leido;
    
     printf("\nIntroduce la ruta: ");
     scanf(" %[^\n]",ruta);
     fichero_destino=fopen(ruta,"r");
    
     printf("\nCONTENIDO DEL FICHERO: %s",ruta);
     printf("\nPLATO\tCalorias\tPrecio\n");
     do{
       fscanf(fichero_destino,"%[^\t]\t%d\t%f\n",plato_leido.nombre,&plato_leido.calorias,&plato_leido.precio);                    
       printf("%s\t%d\t%.2f\n",plato_leido.nombre,plato_leido.calorias,plato_leido.precio);
     }while(feof(fichero_destino)==0);
     return;
}
main(){
      int opcion;
      do{
       opcion=mostrar_menu();
       switch(opcion){
          case 0:
               printf("\nPrograma finalizado");
               break;
          case 1:
               system("cls");
               leer_platos();
               break;  
          case 2:
               system("cls");
               mostrar_fichero();
               break;
          case 3:
               system("cls");
               pasar_txt_format_ordenado();
               break;
          case 4:
               system("cls");
               mostrar_mdd();
               break;
          default:
               printf("\nEsa opcion no existe.Presione cualquier tecla para continuar: ");
               getchar();    
       }
      }while(opcion!=0);  
}

Leer un fichero

Escribir en un Fichero

Punteros

Otra vez sin captura, mucho codigo, que no cabe en 1 foto:



/*2.    Escriba un programa en el que se rellene una matriz 4 × 4 con las
iniciales de sus nombre y apellidos al azar. Utilice reserva dinámica de memoria
 y notación de punteros.*/
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

void rellena_matriz(char *matriz[]){
     int fil,col;
     //Se reserva la memoria
     for(col=0;col<4;col++)
        matriz[col]=(char *)malloc(4*sizeof(char));
     //Rellenamos la matriz
     for(fil=0;fil<4;fil++)
        for(col=0;col<4;col++){
           *(*(matriz+col)+fil)='*';
          
        }
     return;
}
void pinta_matriz(char *matriz[]){
     int fil,col;
     for(fil=0;fil<4;fil++){
        for(col=0;col<4;col++)
          printf(" %c",*(*(matriz+col)+fil));
        printf("\n");
     }
     return;    
}
void poner_iniciales(char *matriz[],char nombre[],char apellido1[],char apellido2[]){
     char iniciales[3];
     int cont,fil,col;
     iniciales[0]=nombre[0];
     iniciales[1]=apellido1[0];
     iniciales[2]=apellido2[0];
    
     for(cont=0;cont<3;cont++){
       fil=rand()%4;
       col=rand()%4;
       *(*(matriz+col)+fil)=iniciales[cont];
     }
     return;
}
main(){
       char *matriz[4],nombre[30],apellido1[30],apellido2[30];
       long tiempo;
       tiempo=time(0);
       srand(tiempo);
       rellena_matriz(matriz);
       pinta_matriz(matriz);
       printf("\nNombre: ");
       scanf(" %s",nombre);
       printf("\nApellido1: ");
       scanf(" %s",apellido1);
       printf("\nApellido2: ");
       scanf(" %s",apellido2);
       poner_iniciales(matriz,nombre,apellido1,apellido2);
       pinta_matriz(matriz);      
       getchar();
       getchar();
}

Y otro mas:





/*4.Para representar la ubicación de los alumnos en un aula se decide
declarar una matriz 4 × 4 de punteros a caracteres. Cada puntero de la matriz
apuntará al nombre de un alumno. Añada una función que reciba los nombres de dos
alumnos e intercambie sus posiciones.*/
#include<stdio.h>
#include<string.h>
#define N 3
typedef struct{
      int fila;
      int columna;   
}coordenadas;
void rellenar_clase(char *alumnos[][N]){
    int fil,col,longitud;
    char aux[40];
    for(fil=0;fil<N;fil++)
         for(col=0;col<N;col++){
            printf("\nAlumno (%d,%d): ",fil,col);
            scanf(" %[^\n]",aux);
            longitud=strlen(aux);
            alumnos[fil][col]=(char *) malloc(longitud*sizeof(char));
            strcpy(alumnos[fil][col],aux);
            printf("\nAcabo de leer: %s",alumnos[fil][col]);
        }
    return;
}
void mostrar_clase(char *alumnos[][N]){
    int fil,col;
    printf("\n****LA CLASE*********\n");
     for(fil=0;fil<N;fil++){
        for(col=0;col<N;col++)
          printf("\t%s",alumnos[fil][col]);
        printf("\n");
    }
    return;
}
void intercambiar_alumnos(char *alumnos[][N],char nombre1[],char nombre2[]){
    int fil,col;
    coordenadas posicion1,posicion2;
    char *aux_nombre;
    for(fil=0;fil<N;fil++)
         for(col=0;col<N;col++){
           if(strcmp(nombre1,alumnos[fil][col])==0){
              posicion1.fila=fil;
              posicion1.columna=col;
            }
           if(strcmp(nombre2,alumnos[fil][col])==0){
              posicion2.fila=fil;
              posicion2.columna=col;
            }
    }
    aux_nombre=alumnos[posicion1.fila][posicion1.columna];
    alumnos[posicion1.fila][posicion1.columna]=alumnos[posicion2.fila][posicion2.columna];
    alumnos[posicion2.fila][posicion2.columna]=aux_nombre;
}
main(){
       char *alumnos[N][N];
       char nombre1[40],nombre2[40];
       rellenar_clase(alumnos);
       mostrar_clase(alumnos);
       printf("\nIntroduce los nombres de los alumnos que quieres intercmabiar: ");
       printf("\nAlumno 1: ");
       scanf(" %[^\n]",nombre1);
       printf("\nAlumno 2: ");
       scanf(" %[^\n]",nombre2);
       intercambiar_alumnos(alumnos,nombre1,nombre2);
       mostrar_clase(alumnos);  
       getchar();
       getchar();
}

Metodo de Ordenacion de la Burbuja y Seleccion

Metodo Ordenacion de Seleccion:

Metodo Ordenacion de la Burbuja:

Matrices

Aqui vamos a presentar varios ejercicios de matrices:

 

/*Matriz que se rellena aleatoriamente con *'s*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
main(){
       char matriz[10][10];
       int filas,col,cont;
       long seed;
       seed=time(0);
       srand(seed);
       //Rellenamos la matriz
       for(filas=0;filas<10;filas++)
           for(col=0;col<10;col++)
               matriz[filas][col]='O';
       //Mostramos
       for(filas=0;filas<10;filas++){
           for(col=0;col<10;col++)
              printf("%c ",matriz[filas][col]);
           printf("\n");
       }
       //Generamos las posiciones al azar para 5 *'s
       for(cont=1;cont<=5;cont++){
           do{
              filas=rand()%10;
              col=rand()%10;
           }while(matriz[filas][col]=='*');
           matriz[filas][col]='*';
       }
       printf("\nLa matriz tras sembrarla de asteriscos.\n\n");
       //Mostramos
       for(filas=0;filas<10;filas++){
           for(col=0;col<10;col++)
              printf("%c ",matriz[filas][col]);
           printf("\n");
       }
       getchar();
       getchar();
}

2º - Operaciones con Cadenas

Este ejercicio como tiene mucho codigo, hare un copypaste:





/*Al meter un texto, el programa nos permite realizar unas estadisticas simples del texto*/

#include<stdio.h>

int cuenta_vocales(char texto[]){//Funcion para contar las vocales del texto introducido
     int cont=0;
     int aux=0;
     do{//Cuenta todas las vocales que se hayan introducido
        if(toupper(texto[cont])=='A' || toupper(texto[cont])=='E' || toupper(texto[cont])=='I' || toupper(texto[cont])=='O' || toupper(texto[cont])=='U')
          aux++;
     }while(texto[++cont]!='\0');
     return(aux);
}
int cuenta_consonantes(char texto[]){//Funcion para contar las consonantes del texto introducido
     int cont=0;
     int aux=0;
     do{//Cuenta todas las consonantes que se hayan introducido
        if(toupper(texto[cont])=='B' || toupper(texto[cont])=='C' || toupper(texto[cont])=='D' || toupper(texto[cont])=='F' || toupper(texto[cont])=='G' || toupper(texto[cont])=='H' || toupper(texto[cont])=='J' || toupper(texto[cont])=='K' || toupper(texto[cont])=='L' || toupper(texto[cont])=='M' || toupper(texto[cont])=='N' || toupper(texto[cont])=='P' || toupper(texto[cont])=='Q' || toupper(texto[cont])=='R' || toupper(texto[cont])=='S' || toupper(texto[cont])=='T' || toupper(texto[cont])=='V' || toupper(texto[cont])=='W' || toupper(texto[cont])=='X' || toupper(texto[cont])=='Y' || toupper(texto[cont])=='Z')
          aux++;
     }while(texto[++cont]!='\0');
     return(aux);
}
int cuenta_palabras(char texto[]){//Funcion para contar las palabras del texto introducido
    int cont=0;
    int aux=0;
    do{//Cuenta las palabras por cada espacio que encuentra
        if(texto[cont]==' ')
            aux++;
    }while(texto[++cont]!='\0');
    aux++;
    return(aux);
}
int cuenta_frases(char texto[]){//Funcion para contar las frases del texto introducido
    int cont=0;
    int aux=0;
    do{//Cuenta todos los puntos introducidos, que significa que acaba una frase
        if(texto[cont]=='.')
            aux++;
    }while(texto[++cont]!='\0');
    return(aux);
}
main(){//Declaramos las variables que vamos a utilizar en el programa
       int opcion,cont,cont2,longitud,nvocales,nconsonantes,palabra,nfrases,npalabras;
       char texto[80],respuesta='s',respuesta2='s';
       float resultado;
           //Intorudcimos el texto, limpiamos el buffer del teclado 
           printf("\nIntorduce un texto:");
           fflush(stdin);
           scanf("%[^\n]",texto);//Con esto, leemos todos los caracteres menos el salto de linea
          
           do{//Iniciamos un bucle para poder volver al menu de opciones
              //Mostramos las diferentes opciones del programa
               printf("\n*****MENU*****");
               printf("\nOpciones: ");
               printf("\n1.Caracteres introducidos");
               printf("\n2.Palabras introducidas");
               printf("\n3.Frases introducidas");
               printf("\n4.Vocales y consonantes introducidas");
               printf("\n\nElige una opcion: ");
               scanf("%d",&opcion);
               switch(opcion){
                  case 1://Opcion uno, Caracteres introducidos
                       cont=0;
                       printf("\nCalculamos cuantos caracteres has introducido.");
                       while(texto[++cont]!='\0');//Pasamos por el texto introducido y contamos todos los caracteres
                       longitud=cont;
                       printf("\nTiene %d caracteres.",longitud);
                       break;
                      
                  case 2://Opcion dos, Palabras introducidas
                       cont=0;
                       printf("\nCalculamos cuantas palabras se han introducido.");
                       npalabras=cuenta_palabras(texto);//Funcion definida mas arriba
                       printf("\nEl texto tiene %d palabras.",npalabras);
                       break;
                      
                  case 3://Opcion tres, Frases introducidas
                       cont2=0;
                       printf("\nCalculamos cuantas frases se han introducido.");
                       nfrases=cuenta_frases(texto);//Funcion definida mas arriba            
                       printf("\nTiene %d frases.",nfrases);
                       break;
                                       
                  case 4://Opcion cuatro, Vocales y consonantes introducidas
                       cont=0;
                       printf("\nCalculamos cuantas vocales y consonantes se han introducido.");
                       nvocales=cuenta_vocales(texto);//Funcion definida mas arriba
                       printf("\nTiene %d vocales.",nvocales);
                       nconsonantes=cuenta_consonantes(texto);//Funcion definida mas arriba
                       printf("\nTiene %d consonantes.",nconsonantes);
                       break;
                      
                  default://Si el usuario entra una opcion incorrecta
                          printf("\nOpcion incorrecta");
               }//Preguntamos si queremos elegir otra opcion
               printf("\n\nDeseas introducir una nueva opcion? (s/n): ");
               scanf(" %c",&respuesta);
               system("cls");//Limpiamos la pantalla            
           }while(respuesta=='s');
       printf("\n\nGracias por usar el programa.");
       getchar();
       getchar();  
}






A mi me funciona.

Operaciones con Cadenas

En este programa lo que vamos a realizar, es poder cambiar un string (frase), como queramos.

Aqui muestro el resultado:

Calculo de Edad

Este programa lo usaremos para escribir un algoritmo que lea tres enteros que representan la fecha de hoy (día, mes y año), seguidos de otros tres enteros que representan la fecha de nacimiento de una persona, y que escriba
la edad de la persona en años.

Factorial

Para calcular el factorial de un número:

Bucles

En esta parte, vamos a explicar los bucles, realizando una tabla de multiplicar

Bucle WHILE

Bucle DO WHILE

Bucle FOR

Y aqui mostramos uno con varios bulces

Otros ejempletee por aqui:

Condicional IF

Condicional Simple:

Condicionales Anidados:

Nosotros probaremos solo con 1 ejemplo.

Otro Ejemplo:

Los demas resultados podeis comprobarlos por vosotros mismos.

Leer y Mostrar por Pantalla

Operación Suma

Una suma, serviria tambien para resta, multiplicacion y division:

Resultado:

Como mostrar algo por pantalla

    Comenzaremos con un programita simple para mostrar por pantalla un mensaje de texto:

  
   El resultado al compilarlo seria este:

Tipos de Variable

-Tipo int:

    En una variable de este tipo se almacenan números enteros (sin decimales). El rango de valores que admite es -32767 a 32767. Para poder utilizarla primero, hay que declararla dentro del main u otras funciones que haya si se necesita. Para ello simplemente habría que poner int nombredelavariable; de esta manera, la variable seria de tipo local, en cambio si lo pones entre las librerías y el resto del programa la variable seria de tipo global.

-Tipo long: 

    En una variable de este tipo se almacenan números enteros (sin decimales). El rango de valores que admite es -2.147.483.647 a 2.147.483.647. Para poder utilizarla primero, hay que declararla dentro del main u otras funciones que haya si se necesita. Para ello simplemente habría que poner long nombredelavariable; de esta manera, la variable seria de tipo local, en cambio si lo pones entre las librerías y el resto del programa la variable seria de tipo global.

-Tipo float: 

    En este tipo de variable podemos almacenar números decimales, no sólo enteros como en los anteriores. El rango de posibles valores es del 3,4E-38 al 3,4E38. Para poder utilizarla primero, hay que declararla dentro del main u otras funciones que haya si se necesita. Para ello simplemente habría que poner 

float nombredelavariable; de esta manera, la variable seria de tipo local, en cambio si lo pones entre las librerías y el resto del programa la variable seria de tipo global.

-Tipo char: 

    Las variables de tipo char sirven para almacenar caracteres. Los caracteres se almacenan en realidad como números del 0 al 255. Los 128 primeros (0 a 127) son el ASCII estándar. El resto es el ASCII extendido y depende del idioma y del ordenador. Para poder utilizarla primero, hay que declararla dentro del main u otras funciones que haya si se necesita. Para ello simplemente habría que poner 

char nombredelavariable; de esta manera, la variable seria de tipo local, en cambio si lo pones entre las librerías y el resto del programa la variable seria de tipo global.

Elementos básicos en nuestros programas

Los elementos fijos que tenemos que encontrar en un programa de C son los siguientes.

Librerias:

    Las librerias de C es una recopilación de ficheros cabecera y bibliotecas con rutinas, estandarizadas que implementan operaciones comunes, tales como las de entrada y salida o el manejo de cadenas. A diferencia de otros lenguajes no incluyen palabras clave para estas tareas, por lo que prácticamente todo programa implementado en C se basa en la biblioteca estándar para funcionar.

Tenemos todas estas librerias: Descarga del listado de librerias.

  

     Las librerias se expresarian asi (esta seria la libreria estandar):

#include<stdio.h>

    Además del menu principal que sería asi:

main(){

//Aqui dentro iria nuestro código (Con el //Aqui el comentario o el /*Aqui el comentario*/ se escribe un comentario )

}

    En bastantes programas tambien nos hara falta definir las variables que vayamos a utilizar, los mas utilizados son int, long, float, estos tres son utilizados para numeros, en orden: numeros pequeños, numeros mas grandes (referiendome a cantidad de digitos) y decimales.

    Aclaracion sobre las variables:

    A las variables no se les puede dar cualquier nombre. No se pueden poner más que letras de la 'a' a la 'z' (la ñ no vale), números y el símbolo '_'. No se pueden poner signos de admiración, ni de interrogación... El nombre de una variable puede contener números, pero su primer carácter no puede serlo. Tampoco valen como nombres de variable las palabras reservadas que usa el compilador.

    Las palabras reservadas del compilador son:

auto break case char const continue default do double else enum extern float for 
goto if int long register return short signed sizeof static struct typedef union unsigned void volatile while

    Por último es interesante señalar que el C distingue entre mayúsculas y minúsculas.

Primeros pasos

Antes de empezar tendremos que tener varias cosas en cuenta.:

Un compilador es un programa que convierte nuestro código fuente en un programa ejecutable, es decir, convierte nuestro código en binario para que el ordenador pueda ejecutarlo.

Actualmente el compilador que utilizamos yo y mis compañeros es el Dev-C++.

Link de Descarga: Dev-C++

 

Después de instalarlo yo toque las siguientes cosas:

-Menú Herramientas/Opciones del Editor/Principal/Resaltar llaves y paréntesis concordantes

-Menú Herramientas/Opciones del Editor/Visualización/Números de linea

    La primera opción nos sirve de ayuda para entender mejor que elemento esta dentro de otro, mejor lo veréis mas adelante.

   

    La segunda opción sirve para localizar el numero de linea en el que tenemos errores para poder visualizarlos antes.

    En la siguiente entrada, empezaremos a hacer nuestros primeros programas en C :).

El lenguaje C

     El lenguaje C, es un lenguaje de alto nivel, de los más conocidos que hay hoy en día. No se si se usara mucho actualmente para crear alguna aplicación pero si que sirve para empezar a aprender a programar.

     No confundas C++, con C, ya que C++ es una "evolución" del C, así que en breves iremos actualizando esto y nos pondremos manos a la obra.