Cohete

En esta ocasión he realizado un programa que realiza una pequeña animación. Se trata de recrear el despegue de un cohete que se va ralentizando poco a poco y que al final explota. Es bastante sencillo, a pesar del número de líneas que contiene, ya que la mayoría de estas son para mostrar la parte visual. A continuación se puede ver la sencillez de la lógica necesaria para llevar a cabo este programa.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int i=0, j=0, k=0;

    for (i=0; i<15; i++) {
        for (j=i; j<=15; j++) {
            printf("\n");
        }
        if (i==14) {
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("        *       \n");
            printf("    *           \n");
            printf("      *  *      \n");
            printf("      -   *  -  \n");
            printf("      *   -  ** \n");
            printf("       *  *     \n");
            printf("    * - * -     \n");
            printf("      * *       \n");
            Sleep(300);
            system("cls");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("       * *      \n");
            printf("       -  * -   \n");
            printf("      *  -  **  \n");
            printf("        *  *    \n");
            printf("    *  -  * -   \n");
            printf("      *  *      \n");
            Sleep(300);
            system("cls");
            printf("               \n");
            printf("                \n");
            printf("               \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("               \n");
            printf("       *       \n");
            printf("        *  *    \n");
            printf("     * -  *     \n");
            printf("      *  *      \n");
            Sleep(300);
            system("cls");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("       *       \n");
            printf("    *    -  *  \n");
            printf("     *  *      \n");
            Sleep(300);
            system("cls");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("         *     \n");
            printf("               \n");
            printf("               \n");
            printf("    *      *   \n");
            printf("        *      \n");
            Sleep(300);
            system("cls");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("                \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("             * \n");
            printf("               \n");
            printf("               \n");
            printf("               \n");
            printf("      *        \n");
            Sleep(300);
            system("cls");

        }
        else {
            printf("       .       \n");
            printf("      / \\     \n");
            printf("      | |      \n");
            printf("     /| |\\    \n");
            printf("      ---      \n");
            if (i%3)
                printf("      ***       \n");
            else
                printf("       *        \n");
            if (i%3)
                printf("       *       \n");
            else
                printf("      * *      \n");
            if (i%3)
                printf("      * *      \n");
            else
                printf("       *       \n");

            Sleep(400 + i*4*i);
        }
        system("cls");
    }
    return 0;
}

Indicador proceso carga

Supongo que habéis visto en multitud de ocasiones las pantallas de inicialización dónde se indica gráficamente cómo avanza el proceso de carga de un determinado programa. He realizado un pequeño programa en C que simula este proceso.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int i=0, j=0;


    for (i=1; i<=10; i++) {
        printf("(%d%c)",i*10,'%');
        if (i%2) printf("%c  ",'/');
        else printf("%c  ",'\\');
        for (j=1;j<=i; j++) printf("*");

        Sleep(500);
        system("cls");
    }
    return 0;
}

Números primos hasta 1000

Esta es una nueva versión del localizador de números primos. En este caso, se muestran todos los primos entre 1 y 1000 de un modo diferente. En este caso realizo un contador descendente desde 1000 hasta 1 y cuando encuentra un número primo se para un instante para mostrar el número en cuestión.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

//Declaración de la función
int es_primo(int num);

int main()
{
    int i=0, j=0;

    for (i=1000; i>0; i--) {
        if (es_primo(i)) {
            printf("%d es primo",i);
            Sleep(800);
        }
        else {
            printf("%d",i);
        }
        system("cls");
    }
    return 0;
}

//Función que indica si un número que se pasa por parámetro
//es primo (1) o no (0).
int es_primo(int num) {
    int k=0;

    for (k=2; k<num-1; k++) {
        if (num%k==0) return 0;  //es divisible, no es primo
    }
    return 1;  //es primo
}

Piedra, papel, tijera, lagarto, Spock

En una entrada anterior de este blog se muestra el código que permite realizar el conocido juego "Piedra, papel, tijera". Sin embargo, existen otras versiones más complejas o "freakies" de este juego. Una de ellas apareció hace algún tiempo en la serie de TV "The big bang theory". Esta versión del juego contempla dos posibilidades más aparte de las habituales: lagarto y Spock (el conocido personaje de Star Trek). A pesar de que en este caso existen más posibilidades para comprobar, podéis comprobar que empleo únicamente tres instrucciones if en el código para realizar todas las comprobaciones.

http://sweet-killer-angels.blogspot.com/2010/05/jugamos.html

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    //0 - Piedra, 1 - Papel, 2 - Tijera, 3 - Lagarto, 4 - Spock
    int tablaResultados[5][5] = {{-1,1,0,0,1},{0,-1,1,1,0},{1,0,-1,0,1},{1,0,1,-1,0},{0,1,0,1,-1}};
    int jugada_usuario=0, jugada_ordenador=0;
    int k=0,l=0;

    //Inicializamos la semilla del generador pseudoaleatorio
    srand(time(NULL));
    while (1) {
        printf("\tPiedra, papel, tijera\n\n");
        printf("\t 1.- Piedra\n");
        printf("\t 2.- Papel\n");
        printf("\t 3.- Tijera\n");
        printf("\t 4.- Lagarto\n");
        printf("\t 5.- Spock\n");
        printf("\t 6.- Salir\n\n");
        printf("\t Haga su jugada: ");

        //Obtenemos la jugada del usuario
        scanf("%d",&jugada_usuario);
        //Obtenemos la jugada del ordenador
        jugada_ordenador = (rand()%5) + 1;

        if (jugada_usuario==6) return 0; //Salimos del programa

        switch (jugada_usuario) {
            case 1:
                printf("\n\tUsted ha elegido Piedra\n");
                break;
            case 2:
                printf("\n\tUsted ha elegido Papel\n");
                break;
            case 3:
                printf("\n\tUsted ha elegido Tijera\n");
                break;
            case 4:
                printf("\n\tUsted ha elegido Lagarto\n");
                break;
            case 5:
                printf("\n\tUsted ha elegido Spock\n");
                break;
        }
        switch (jugada_ordenador) {
            case 1:
                printf("\n\tEl ordenador ha elegido Piedra\n");
                break;
            case 2:
                printf("\n\tEl ordenador ha elegido Papel\n");
                break;
            case 3:
                printf("\n\tEl ordenador ha elegido Tijera\n");
                break;
            case 4:
                printf("\n\tEl ordenador ha elegido Lagarto\n");
                break;
            case 5:
                printf("\n\tEl ordenador ha elegido Spock\n");
                break;
        }

        //Obtenemos el ganador de la tabla de resultados posibles
        if (tablaResultados[jugada_usuario-1][jugada_ordenador-1] == 0)
            printf("\n\n\tHa ganado el usuario\n");
        if (tablaResultados[jugada_usuario-1][jugada_ordenador-1] == 1)
            printf("\n\n\tHa ganado el ordenador\n");
        if (tablaResultados[jugada_usuario-1][jugada_ordenador-1] == -1)
            printf("\n\n\tEMPATE\n");

        Sleep(3000);
        system("cls");
    }

    return 0;
}

Listas enlazadas

Estos últimos días he estado tratando de recordar el funcionamiento de los punteros en C. Al principio me costó un poco, y cometí muchos de los errores que solía cometer cuando los descubrí hace años durante mis primeras incursiones en la programación (en C, en particular). De todos modos, creo que ya he vuelto a entender la esencia de los mismos y para comprobar mis progresos he realizado unas pruebas creando una lista enlazada y realizando ciertas operaciones básicas sobre ella (añadir elementos, eliminar, buscar y listar los elementos). El código correspondiente se puede ver a continuación.

#include <stdio.h>
#include <stdlib.h>

//Definición de los elementos de la lista
 struct list {
    int valor;
    struct list *sig;
};
typedef struct list item;

//Prototipos de funciones
int long_lista(item *lista);
item *add_lista(item *lista, int valor);
item *del_lista(item *lista, int valor);
int search_lista(item *lista, int valor);
void print_lista(struct list *lista);

int main()
{
    item *lista, *item1, *item2, *item3;
    int tamano=0;
    int i=0;

    lista=NULL;
    for (i=0; i<10; i++) {
        //Añadimos elementos a la lista
        lista = add_lista(lista,i);
    }
    printf("La longitud de la lista es: %d\n",long_lista(lista));
    printf("Antes de borrar: \n");
    //Mostramos el contenido de la lista
    print_lista(lista);
    //Borramos un elemento de la lista
    lista = del_lista(lista,9);
    printf("Despues de borrar: \n");
    //Mostramos los elementos de la lista
    print_lista(lista);

    //Búsqueda de elementos en la lista
    if (search_lista(lista,4)) printf("La lista contiene un 4\n");
    else printf("La lista no contiene un 4\n");
    if (search_lista(lista,9)) printf("La lista contiene un 9\n");
    else printf("La lista no contiene un 9\n");
    return 0;
}

/*
    Esta función devuelve el número de elementos que contiene la lista que
    recibe como parámetro
*/
int long_lista(item *lista) {
    int lon=0;

    if (lista==NULL) return 0;
    else {
        while (lista!=NULL) {
            lista=lista->sig;
            lon++;
        }
        return lon;
    }
}

/*
    Esta función devuelve un puntero al inicio de la lista después de añadirle un
    nuevo elemento cuyo valor se le pasa como parámetro a la función.
*/
item *add_lista(item *lista, int valor) {
    item *lista_aux;

    lista_aux = (item *)malloc(sizeof(item));

    if (lista==NULL) {
        lista_aux->valor=valor;
        lista_aux->sig=NULL;
        lista=lista_aux;
    }
    else {
        lista_aux->valor=valor;
        lista_aux->sig=lista;
        lista=lista_aux;
    }

    return lista;
}

/*
    Esta función devuelve un puntero a la cabeza de la lista resultante de eliminar
    el elemento cuyo valor asociado coincide con el que se pasa por parámetro.
*/
item *del_lista(item *lista, int valor) {
    item *index;
    item *temp;

    index = lista;
    if (index != NULL) {
        if (index->valor==valor) {
            index=index->sig;
            lista=index;
            return lista;   //hemos borrado el primer elemento de la lista
        }
        else {
            temp=lista;
            index=lista->sig;
            while (index!=NULL) {
                if (index->valor==valor) {
                    temp->sig=index->sig;
                    return lista;  //eliminamos de la lista el primer elemento encontrado
                }
                else {
                    index=index->sig;
                    temp=temp->sig;
                }
            }
        }
    } else
        return lista;  //no se ha borrado nada de la lista porque estaba vacía
}

/*
    Esta función devuelve un 0 si no encuentra ningún elemento en la lista cuyo valor
    asociado coincida con el pasado por parámetro, y un 1 si encuentra al menos un
    elemento cuyo valor si coincida.
*/
int search_lista(item *lista, int valor) {
    item *index;
    int encontrado=0;

    index=lista;
    while (index!=NULL) {
        if (index->valor==valor) {
            return 1;
        }
        else {
            index=index->sig;
        }
    }
    return 0;
}

/*
    Esta función se ocupa de mostrar por pantalla el valor de todos los elementos
    pertenecientes a la lista que se pasa por parámetro.
*/
void print_lista(item *lista) {
    item *index;

    index=lista;
    while (index!=NULL) {
        printf("Valor: %d\n", index->valor);
        index=index->sig;
    }
}

Piedra, papel, tijera

Continuando con los juegos, a continuación se puede ver el código de un pequeño programa en C que permite jugar al famoso juego "Piedra, papel, tijera". Aunque pueda parecer que nos pasamos el día jugando, he llegado a la conclusión de que programando estos juegos se puede aprender bastante. Además, la programación si es divertida puede ser como un juego, en el que tú defines las normas.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int jugada_ordenador=0, jugada_usuario=0;
    int fin=0;

    srand(time(NULL));
    while (1) {
        printf("\tPiedra, papel, tijera\n\n");
        printf("\t 1.- Piedra\n");
        printf("\t 2.- Papel\n");
        printf("\t 3.- Tijera\n");
        printf("\t 4.- Salir\n\n");
        printf("\t Haga su jugada: ");

        scanf("%d",&jugada_usuario);
        jugada_ordenador = (rand()%3) + 1;

        if (jugada_usuario==4) return 0; //Salimos del programa

        switch (jugada_usuario) {
            case 1:
                printf("\n\tUsted ha elegido Piedra\n");
                break;
            case 2:
                printf("\n\tUsted ha elegido Papel\n");
                break;
            case 3:
                printf("\n\tUsted ha elegido Tijera\n");
                break;
        }

        switch (jugada_ordenador) {
            case 1:
                printf("\n\tEl ordenador ha elegido Piedra\n");
                break;
            case 2:
                printf("\n\tEl ordenador ha elegido Papel\n");
                break;
            case 3:
                printf("\n\tEl ordenador ha elegido Tijera\n");
                break;
        }
        //Comprobamos los casos en los que gana el ordenador
        if (jugada_ordenador==1 && jugada_usuario==3) printf("\n\n\tGana el ordenador\n");
        if (jugada_ordenador==2 && jugada_usuario==1) printf("\n\n\tGana el ordenador\n");
        if (jugada_ordenador==3 && jugada_usuario==2) printf("\n\n\tGana el ordenador\n");
        //Comprobamos los casos en los que gana el usuario
        if (jugada_usuario==1 && jugada_ordenador==3) printf("\n\n\tGana el usuario\n");
        if (jugada_usuario==2 && jugada_ordenador==1) printf("\n\n\tGana el usuario\n");
        if (jugada_usuario==3 && jugada_ordenador==2) printf("\n\n\tGana el usuario\n");
        //Comprobamos los empates
        if (jugada_ordenador==jugada_usuario) printf("\n\n\tHabeis empatado\n");

        //Esperamos un rato mostrando el resultado, limpiamos la pantalla y volvemos
        //a mostrar el menú.
        Sleep(3000);
        system("cls");
    }

    return 0;
}

El que quiera una versión un poco más complicada de este juego puede intentar programar el juego "Piedra, papel, tijera, lagarto, Spock" creado en la serie de TV "The big bang theory". Podéis encontrar los detalles en internet.

Lluvia de letras

He estado investigando un poco acerca de la librería no estándar conio.h y de algunas funciones que pueden resultar útiles en ciertos casos. Además, en el pequeño programa que muestro a continuación también utilizo funciones para generación de números pseudoaleatorios. Este programa solicita al usuario que introduzca una frase y en cuanto se pulsa las letras de la frase comienzan a caer por la pantalla hasta que desaparecen por el fondo.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio2.h>

int main()
{
    char frase[80];
    int i=0, j=0, x=0;

    printf("Introduce una frase: \n");
    fgets(frase,80,stdin);

    srand(time(NULL));
    if (strlen(frase)>0) {
        for (j=0; j<30; j++) {
            system("cls");
            for (i=0; i<strlen(frase); i++) {
                x=(rand()%4) + j;
                gotoxy(i+1,x);
                if (x < 24) {
                    printf("%c",frase[i]);
                }
            }
            Sleep(250);
        }
    }
    return 0;
}

A continuación, se pueden ver los resultados de la ejecución del programa en distintos instantes de la misma.

Control de acceso en C

Hoy hemos estado trabajando con las funciones de caracteres y cadenas en C. Para poner en práctica algunas de las cosas aprendidas los últimos días he realizado un programa que simule un control de acceso a una aplicación o a un sistema. A continuación, podéis ver el código correspondiente.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int i=0, tiempo=0, j=0;
    char cadena[20];
    int acertada=0;

    strcpy(cadena,"clave");
    while ((i<5) & !acertada) {
        Sleep(i*1000);
        system("cls");
        printf("Introduzca su clave: ");
        scanf("%s",cadena);

        if (strcmp(cadena,"clave")==0){
            acertada=1;
            system("cls");
            printf("\n\n\n\n\n");
            printf("    ****************************\n");
            printf("    *   BIENVENIDO AL SISTEMA  *\n");
            printf("    ****************************\n\n\n\n");
            printf("        Cargando  ");
            for (j=0; j<10; j++) {
                printf(".");
                Sleep(700);
            }
            Sleep(10000);
            //system("cls");
        }
        else {
            printf("Su clave es incorrecta. Intentelo de nuevo. Le quedan %d intentos\n", 5-(i+1));
            i++;
        }

    }
    return 0;
}

Por último, os muestro un par de imágenes de distintos momentos de la ejecución de la aplicación.

Tres en raya

He estado trabajando ayer y hoy en un juego de tres en raya. Ayer estuve desarrollando el algoritmo en pseudocódigo y, después de repasarlo y depurarlo un poco, hoy me he puesto a programar. Incluso así tuve algunos problemas a la hora de traducir el pseudocódigo a lenguaje C. Estos problemas fueron debidos al tiempo que llevo sin trabajar con este lenguaje y a las peculiaridades de los punteros (pueden ser un poco puñeteros). A continuación muestro el código del juego y después voy a jugar unas partidas.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char tablero[3][3] = {{'1','2','3'}, {'4','5','6'}, {'7','8','9'}};
    int vencedor = 0, casilla=0, fila=0, col=0;

    //Bucle principal de ejecución del programa
    while (hay_casillas_sin_marcar(tablero) && vencedor==0) {
        mostrar_tablero(tablero);
        printf("\nIntroduzca la casilla a marcar (1-9): ");
        scanf("%d",&casilla);

        //Traducimos el número de casilla a la fila y columna correspondiente
        if (casilla==1) { fila=0; col=0;}
        if (casilla==2) { fila=0; col=1;}
        if (casilla==3) { fila=0; col=2;}
        if (casilla==4) { fila=1; col=0;}
        if (casilla==5) { fila=1; col=1;}
        if (casilla==6) { fila=1; col=2;}
        if (casilla==7) { fila=2; col=0;}
        if (casilla==8) { fila=2; col=1;}
        if (casilla==9) { fila=2; col=2;}

        if (!casilla_marcada(fila,col,tablero)) {

            marcar_casilla(fila,col,0,tablero);
            if (tres_en_raya(tablero)) {
                vencedor=1;  //gana el usuario
            }
            else {
                marcar_casilla_ordenador(tablero);
                if (tres_en_raya(tablero))
                    vencedor=2;  //gana el ordenador
            }
        }
    }

    if (vencedor==0) printf("No hay ganador\n");
    if (vencedor==1) printf("El ganador es el usuario\n");
    if (vencedor==2) printf("El ganador es el ordenador\n");

    return 0;
}

//Función HAY_CASILLAS_SIN_MARCAR()
int hay_casillas_sin_marcar(char (*tablero)[3][3]) {
    int i=0, j=0;   //indice de fila y columna

    for (i=0; i<3; i++) {
        for (j=0; j<3; j++) {
            if (((*tablero)[i][j]!='X') && ((*tablero)[i][j]!='O'))
                return 1;   //devolvemos verdadero
        }
    }
    return 0;  //devolvemos falso
}

//Función MOSTRAR_TABLERO()
void mostrar_tablero(char (*tablero)[3][3]) {
    int i=0, j=0;

    for (i=0; i<3; i++) {
        for (j=0; j<3; j++) {
            printf("%c  ", (*tablero)[i][j]);
        }
        printf("\n");   //pasamos a la siguiente fila
    }
}

//Función CASILLA_MARCADA(ENTERO fila, ENTERO columnma)
int casilla_marcada(int fila, int columna, char (*tablero)[3][3]) {

    if ((*tablero)[fila][columna] == 'X' || (*tablero)[fila][columna] == 'O') {
        return 1;
    }
    else {
        return 0;
    }
}

//Función MARCAR_CASILLA(ENTERO casilla, ENTERO jugador)
void marcar_casilla(int fila, int columna, int jugador, char (*tablero)[3][3]) {

    //jugador: 0->usuario, 1->ordenador
    if (jugador==0) { //jugador=usuario
        (*tablero)[fila][columna]='X';
    }
    if (jugador==1) {  //jugador=ordenador
        (*tablero)[fila][columna]='O';
        printf("jugador==1 (ordenador) casilla: (%d,%d)\n",fila,columna);
    }
}

//Función ENTERO TRES_EN_RAYA()
int tres_en_raya(char (*tablero)[3][3]) {
    int i=0, j=0;

    //Comprobamos todas las filas
    for (i=0; i<3; i++) {
        if (((*tablero)[i][0]==(*tablero)[i][1]) && ((*tablero)[i][1]==(*tablero)[i][2])) {
            return 1;
        }
    }
    //Comprobamos las columnas
    for (j=0; j<3; j++) {
        if (((*tablero)[0][j]==(*tablero)[1][j]) && ((*tablero)[1][j]==(*tablero)[2][j])) {
            return 1;
        }
    }
    //Comprobamos diagonales
    if ((*tablero)[0][0]==(*tablero)[1][1] && (*tablero)[1][1]==(*tablero)[2][2]) {
        return 1;
    }
    if ((*tablero)[0][2]==(*tablero)[1][1] && (*tablero)[1][1]==(*tablero)[2][0]) {
        return 1;
    }
    return 0;  //si no se cumple ninguna de las condiciones anteriores no hay tres en raya
}

//Función MARCAR_CASILLA_ORDENADOR()
void marcar_casilla_ordenador(char (*tablero)[3][3]) {
    int i=0, j=0, marcada=0;

    // //////       /////////    ////////////   /////////////  //////
    //Comprobamos si el ordenador tiene opción de hacer tres en raya
    //   /////////  /////////  ////////   //////  //////   //////////
    //Para cada fila
    for (i=0; i<3; i++) {
        if (((*tablero)[i][0]=='O') && ((*tablero)[i][1]=='O') && (isdigit((*tablero)[i][2]))) {
            marcar_casilla(i,2,1,tablero);
            return;
        }
         if (((*tablero)[i][1]=='O') &&((*tablero)[i][2]=='O') && (isdigit((*tablero)[i][0]))) {
            marcar_casilla(i,0,1,tablero);
            return;
        }
        if (((*tablero)[i][0]=='O') &&((*tablero)[i][2]=='O') && (isdigit((*tablero)[i][1]))) {
            marcar_casilla(i,1,1,tablero);
            return;
        }
   }
   //Para cada columna
     for (j=0; j<3; j++) {
        if (((*tablero)[0][j]=='O') &&((*tablero)[1][j]=='O') && (isdigit((*tablero)[2][j]))) {
            marcar_casilla(2,j,1,tablero);
            return;
        }
        if (((*tablero)[1][j]=='O') &&((*tablero)[2][j]=='O') && (isdigit((*tablero)[0][j]))) {
            marcar_casilla(0,j,1,tablero);
            return;
        }
        if (((*tablero)[0][j]=='O') &&((*tablero)[2][j]=='O') && (isdigit((*tablero)[1][j]))) {
            marcar_casilla(1,j,1,tablero);
            return;
        }
    }
    //Diagonales
        if (((*tablero)[0][0]=='O') && ((*tablero)[1][1]=='O') && (isdigit((*tablero)[2][2]))) {
        marcar_casilla(2,2,1,tablero);
        return;
    }
    if (((*tablero)[1][1]=='O') && ((*tablero)[2][2]=='O') && (isdigit((*tablero)[0][0]))) {
        marcar_casilla(0,0,1,tablero);
        return;
    }
    if (((*tablero)[0][0]=='O') && ((*tablero)[2][2]=='O') && (isdigit((*tablero)[1][1]))) {
        marcar_casilla(1,1,1,tablero);
        return;
    }
    //
    if (((*tablero)[0][2]=='O') && ((*tablero)[1][1]=='O') && (isdigit((*tablero)[2][0]))) {
        marcar_casilla(2,0,1,tablero);
        return;
    }
    if (((*tablero)[1][1]=='O') && ((*tablero)[2][0]=='O') && (isdigit((*tablero)[0][2]))) {
        marcar_casilla(0,2,1,tablero);
        return;
    }
    if (((*tablero)[0][2]=='O') && ((*tablero)[2][0]=='O') && (isdigit((*tablero)[1][1]))) {
        marcar_casilla(1,1,1,tablero);
        return;
    }


    // //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //  //
    //Comprobamos filas para ver si hay 2 casillas marcadas por el usuario
    // //  //  //  //  //  //  //  //  // //  //  //  //  //  //  //  //
    for (i=0; i<3; i++) {
        if (((*tablero)[i][0]=='X') &&((*tablero)[i][1]=='X') && (isdigit((*tablero)[i][2]))) {
            marcar_casilla(i,2,1,tablero);
            return;
        }
        if (((*tablero)[i][1]=='X') &&((*tablero)[i][2]=='X') && (isdigit((*tablero)[i][0]))) {
            marcar_casilla(i,0,1,tablero);
            return;
        }
        if (((*tablero)[i][0]=='X') &&((*tablero)[i][2]=='X') && (isdigit((*tablero)[i][1]))) {
            marcar_casilla(i,1,1,tablero);
            return;
        }
    }
    //Comprobamos columnas para ver si alguna tiene 2 casillas marcadas por el usuario
    for (j=0; j<3; j++) {
        if (((*tablero)[0][j]=='X') &&((*tablero)[1][j]=='X') && (isdigit((*tablero)[2][j]))) {
            marcar_casilla(2,j,1,tablero);
            return;
        }
        if (((*tablero)[1][j]=='X') &&((*tablero)[2][j]=='X') && (isdigit((*tablero)[0][j]))) {
            marcar_casilla(0,j,1,tablero);
            return;
        }
        if (((*tablero)[0][j]=='X') &&((*tablero)[2][j]=='X') && (isdigit((*tablero)[1][j]))) {
            marcar_casilla(1,j,1,tablero);
            return;
        }
    }
    //Comprobamos diagonales para ver si alguna tiene 2 casillas marcadas por el usuario
    if (((*tablero)[0][0]=='X') && ((*tablero)[1][1]=='X') && (isdigit((*tablero)[2][2]))) {
        marcar_casilla(2,2,1,tablero);
        return;
    }
    if (((*tablero)[1][1]=='X') && ((*tablero)[2][2]=='X') && (isdigit((*tablero)[0][0]))) {
        marcar_casilla(0,0,1,tablero);
        return;
    }
    if (((*tablero)[0][0]=='X') && ((*tablero)[2][2]=='X') && (isdigit((*tablero)[1][1]))) {
        marcar_casilla(1,1,1,tablero);
        return;
    }
    //
    if (((*tablero)[0][2]=='X') && ((*tablero)[1][1]=='X') && (isdigit((*tablero)[2][0]))) {
        marcar_casilla(2,0,1,tablero);
        return;
    }
    if (((*tablero)[1][1]=='X') && ((*tablero)[2][0]=='X') && (isdigit((*tablero)[0][2]))) {
        marcar_casilla(0,2,1,tablero);
        return;
    }
    if (((*tablero)[0][2]=='X') && ((*tablero)[2][0]=='X') && (isdigit((*tablero)[1][1]))) {
        marcar_casilla(1,1,1,tablero);
        return;
    }

    //Si la casilla central está vacía la marcamos
    if ((*tablero)[1][1]=='5') {
        marcar_casilla(1,1,1,tablero);
    } else {
        i=0;  //fila
        j=0;  //columna

        //Buscamos una casilla sin marcar y la marcamos
        while (!marcada) {
            if (isdigit((*tablero)[i][j])) {
                (*tablero)[i][j]='O';
                marcada=1;
            }
                j++;
                if(j%3 == 0) {
                    i++;
                    j=j%3;
                }
        }
    }

    return;
}

Información ficheros texto

He estado haciendo unas pruebas con funciones de manejo de ficheros en C para quitar el óxido a mis conocimientos de C. Como resultado he hecho un programilla para mostrar cierta información relativa a un fichero de texto. Podemos obtener el número de caracteres, palabras y líneas en un fichero de texto. El nombre del fichero se pasa como parámetro en la línea de comando. Es decir, el modo de ejecutar el programa sería el siguiente:
                       programa nombre_fichero 

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[])
{
  FILE *fichero;
  char c;
  int contador_char=0, contador_lineas=0, contador_palabras=0, contador_char_palabra=0;

  if (argc==2) {
    fichero = fopen(argv[1],"r");
    if (!feof(fichero)) contador_lineas = 1;
    while ((c=fgetc(fichero)) != EOF) {
      if ((((int)c) != 32) && (c!='\n')) {
        contador_char++;
        contador_char_palabra++;
      }
      if (((c==' ') || (c=='\n')) && (contador_char>0)) {
        contador_palabras++;
        contador_char_palabra=0;
      }
      if (c=='\n') contador_lineas++;
    }
    if (contador_char_palabra>0) contador_palabras++;

    fclose(fichero);

    printf("El numero de caracteres en el fichero es: %d\n", contador_char);
    printf("El número de palabras en el fichero es: %d\n", contador_palabras);
    printf("El numero de lineas en el fichero es: %d\n",contador_lineas);
  }
  else {
    printf("Uso: file_counters nombrefichero");
  }
  return 0;
}

Calculadora en C

Estamos empezando el apartado de programación en C y para calentar motores he realizado el programa de la calculadora utilizando este lenguaje. A continuación, muestro el código de dicha aplicación.

#include <stdio.h>
#include <stdlib.h>

int main()
{
  int operacion=0, op1=0, op2=0, resultado=0;
  int error=0;
  char cadena[2];

  while (1) {
    error=0;
    printf("Calculadora:\n\n");
    printf(" 1.Sumar\n 2.Restar\n 3.Multiplicar\n 4.Dividir\n 0.Salir \n\n");
    scanf("%d",&operacion);

    if ((operacion>=0) && (operacion<=4)) { 
      if (operacion==0) break; 
      printf("Introduzca operando 1: "); 

      scanf("%d",&op1);
      printf("Introduzca operando 2: "); 
      scanf("%d",&op2); 
      
      switch (operacion) { 
        case 1: 
          resultado = sumar(op1,op2); 
          break; 
        case 2: 
          resultado = restar(op1,op2); 
          break; 
        case 3: 
          resultado = multiplicar(op1,op2); 
          break; 
        case 4: 
          resultado = dividir(op1,op2); 
          if (op2==0) { error=1; } 
          break; 
        default: 
          resultado=0; error=1; 
      } 
      if (error) { 
        printf("No se ha podido realizar la operacion. Compruebe que los operandos introducidos son correctos\n\n"); }
      else { 
        printf("El resultado es: %d\n\n", resultado); 
      } 


      printf("Pulse una tecla para continuar...");
      gets(cadena); 
      gets(cadena); 
      system("cls"); 
    } 
  } 
  return 0; 
} 


//Funciones creadas
int sumar(int sum1, int sum2) { 
  return(sum1+sum2); 
} 
int restar(int x, int y) {
  return(x-y);
}
int multiplicar(int x, int y){
  return(x*y);
}
int dividir(int x, int y) {
 if (y!=0) {
   return(x/y);
 }
}