Ordenación (método MergeSort)

Profundizando un poco más en el tema de los algoritmos de ordenación y después de ver unos videos disponibles en la página web del MIT  he programado el algoritmo MergeSort utilizando listas enlazadas con punteros. Este algoritmo se comporta mucho mejor que el de selección cuando el número de elementos a ordenar crece. La idea que aplica este algoritmo es la de "divide y vencerás" y lo hace de modo recursivo.

struct tipo_dato {
    int num;
    struct tipo_dato *sig;
};



struct tipo_dato *mergeSort(struct tipo_dato *lista) {
    struct tipo_dato *lista1=NULL, *lista2=NULL, *listaOrd1=NULL, *listaOrd2=NULL, *listaOrd=NULL;


    if (longitud_lista(lista) <= 1) {
        return lista;
    }
    else {
        //Este es el puntero a la primera mitad de la lista.
        lista1 = lista;
        //Obtenemos la segunda parte de la lista (la segunda mitad).
        lista2 = obtener_lista2(lista);
        //Ordenamos recursivamente cada mitad del algoritmo
        listaOrd1 = mergeSort(lista1);
        listaOrd2 = mergeSort(lista2);

        //Mezclamos las dos mitades ordenadas previamente
        listaOrd = mezclar(listaOrd1, listaOrd2);

        return listaOrd;
    }
}

Para ver el código de un ejemplo de uso del algoritmo y los resultados de la ejecución podéis visitar este enlace en Codepad:
http://codepad.org/B3EOCoi8

Ordenación (método de selección)

Hemos estado hablando sobre los algoritmos de ordenación en clase y tuvimos que implementar el algoritmo de ordenación por selección para poder mostrar unos listados de datos ordenados en una aplicación que estamos realizando. A continuación muestro el código correspondiente a la función que realiza la tarea de la ordenación y la definición de la estructura de datos que representa los nodos de la lista enlazada.

struct tipo_lista_libro {
    char titulo[20];
    char autor[25];
    float precio;
    struct tipo_lista_libro *sig;
};

struct tipo_lista_libro *ordenar_lista_libros_seleccion(struct tipo_lista_libro *lista) {
    struct tipo_lista_libro *lista_aux = NULL, *lista_aux2 = NULL;
    struct tipo_lista_libro libro;

    lista_aux = lista;
    if (lista != NULL) {
        while (lista_aux->sig != NULL) {
            lista_aux2 = lista_aux->sig;
            while (lista_aux2 != NULL) {
                if (strcmp(lista_aux->titulo, lista_aux2->titulo)>0) {
                    //Copiamos el contenido de lista_aux a una variable temporal
                    strcpy(libro.titulo, lista_aux->titulo);
                    strcpy(libro.autor, lista_aux->autor);
                    libro.precio = lista_aux->precio;
                    //Copiamos el contenido de lista_aux2 a lista_aux
                    strcpy(lista_aux->titulo, lista_aux2->titulo);
                    strcpy(lista_aux->autor, lista_aux2->autor);
                    lista_aux->precio = lista_aux2->precio;
                    //Copiamos en lista_aux2 el contenido de la variable auxiliar
                    strcpy(lista_aux2->titulo, libro.titulo);
                    strcpy(lista_aux2->autor, libro.autor);
                    lista_aux2->precio = libro.precio;
                }
                lista_aux2 = lista_aux2->sig;
            }
            lista_aux = lista_aux->sig;
        }
    }
    return lista;
}

Para ver el resultado de una prueba de la ejecución de este programa visita el siguiente enlace:
http://codepad.org/qkNxYv08 en Codepad. Allí podéis ver el código completo y los resultados de la ejecución.

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);
 }
}

Pseudocódigo (II)

En esta ocasión voy a mostrar el pseudocódigo y el correspondiente código en lenguaje C de un problema un poco más complejo que los anteriores. Además, reflejaré el pseudocódigo sin modificaciones y, a continuación, el el código probado y depurado. De este modo se pueden observar las modificaciones y errores detectados una vez que el código fue compilado, ejecutado y probado. En este caso las modificaciones no fueron muchas, pero tuve que realizar algunas para que el programa funcionase del modo deseado.

Indicar a partir del número de días a partir del 01-01-2011, ¿Cuántos años, meses, semanas y días constituyen el número de días.
Funciones: BISIESTO(ano), DIASMES(mes)

INICIO
DíasInicio=0,anos, meses=0, semanas=0, anoActual=2011, diasRestantes=0
MOSTRAR “Introduzca el número de días: “
LEER días
diasRestantes=dias
MIENTRAS (diasRestantes>0) HACER
  SI (diasRestantes>366)
    SI ESBISIESTO(anoActual)
      diasRestantes=diasRestantes-366
    SINO
      diasRestantes=diasRestantes-365
      anos=anos+1
      anoActual=anoActual+1
    FIN SI
  SINO
    SI (diasRestantes>365)
      diasRestantes=diasRestantes-365
      anos=anos+1
      anoActual=anoActual+1
    SINO
      Índice=0
      MIENTRAS (diasRestantes>NDIAS(i))
        SI ESBISIESTO(anoActual) Y (índice=2)
          diasRestantes=diasRestantes-NDIAS(índice)-1
          meses=meses+1
          índice = índice + 1
        SINO
          Días= días + NDIAS(índice)
          diasRestantes = diasRestantes – NDIAS(índice)
          meses=meses + 1
          índice = índice +1
        FIN SI
      FIN MIENTRAS
      SI (diasRestantes>=7)
        Semanas=diasRestantes/7
        Días=RESTO(diasRestantes/7)
        diasRestantes=0 //Condición de finalización
      FIN SI
    FIN SI
  FIN SI
FIN MIENTRAS
MOSTRAR “El número de años es: “ anos
MOSTRAR “El número de meses es: “ meses
MOSTRAR “El número de semanas es: “ semanas
MOSTRAR “El número de días es: “ dias
FIN

#include <stdio.h>
int main() {
  int diasInicio=0,dias=0, meses=0,anos=0, semanas=0, anoActual=2011, diasRestantes=0;
  int indice=0;

  printf("Introduzca el número de días: ");
  scanf("%d",&diasInicio);

  diasRestantes=diasInicio;
  while (diasRestantes>0) {
    if (diasRestantes>=366) {
      if (esBisiesto(anoActual)) {
        diasRestantes=diasRestantes-366;
      }else {
        diasRestantes=diasRestantes-365;
      }
      anos=anos+1;
      anoActual=anoActual+1;
    }
    else {
      if ((diasRestantes==365)&&(!esBisiesto(anoActual))) {        
          diasRestantes=diasRestantes-365;
          anos=anos+1;
          anoActual=anoActual+1;
      }
      else {
        indice=1;
        while (diasRestantes>=diasMes(indice)) {
          if (esBisiesto(anoActual)&&(indice==2)) {
            diasRestantes=diasRestantes-diasMes(indice)-1;
            meses=meses+1;
            indice++;
          }
          else {
            dias=dias+diasMes(indice);
            diasRestantes=diasRestantes-diasMes(indice);
            meses=meses+1;
            indice++;
          }
        }
       
        if (diasRestantes>=7) {
          semanas=diasRestantes/7;
          dias=diasRestantes%7;
          diasRestantes=0;
        }
        else {
          dias=diasRestantes;
          diasRestantes=0;
        }
      }
    }
  }
 
  printf ("El número de años= %d\n", anos);
  printf ("El número de meses es= %d\n", meses);
  printf ("El número de semanas es= %d\n", semanas);
  printf ("El número de días es= %d\n", dias);

  return(0);
}

int esBisiesto(int ano) {
  if ((ano%4==0) && ((ano%400==0) || (ano%100!=0)))
    return 1;
  else
    return 0;
}

int diasMes(int mes) {
  short diasMeses[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
 
  return (diasMeses[mes-1]);
}

Pseudocódigo

Como paso previo a adentrarnos en la progamación en C, hemos estado desarrollando algoritmos para resolver ciertos problemas comunes mediante pseudocódigo. El objetivo fundamental es familiarizarse con las estructuras lógicas más utilizadas en programación (independientemente del lenguaje). Sin embargo, para quién no está habituado a programar puede resultar un poco abstracto resolver los problemas de este modo. Por eso he decidido mostrar algunos ejemplos de pseudocódigo acompañados por el correspondiente código en C. He tratado de utilizar las estructurar más comunes (if, while, for, switch).

INICIO
A=0, B=0
Leer A, B
SI A=B
Mostrar “Los números introducidos son iguales”
SINO
Mostrar “Los números introducidos no son iguales”
FIN

#include
int main() {
int a=0,b=0;

printf("Introduce el primer número: ");
scanf("%d",&a);
printf("Introduce el segundo número: ");
scanf("%d",&b);

if (a==b) printf("Los números introducidos son iguales\n");
else printf("Los números introducidos no son iguales\n");

return(0);
}

Pedir por teclado el número de mes y responder por pantalla el nombre del mes y el número de días que tiene(realizar para los 4 primeros meses)
INICIO
NUM_MES=0
MOSTRAR “Introduzca un número de mes(1-4):”
LEER NUM_MES
HACER EN CASO
EN CASO NUM=1:
MOSTRAR “El mes es enero y tiene 31 días”
EN CASO NUM=2:
MOSTRAR “El mes es febrero y tiene 28 días”
EN CASO NUM=3:
MOSTRAR “El mes es marzo y tiene 31 días”
EN CASO NUM=4:
MOSTRAR “El mes es abril y tiene 30 días”
SEA OTRO VALOR:
MOSTRAR “El número introducido no está en el rango indicado”
FIN

#include
int main() {
int num_mes=0;

printf("Introduzca un número de mes (1-4):");
scanf("%d",&num_mes);

switch(num_mes) {
  case 1:
    printf("El mes es enero y tiene 31 días\n");
    break;
  case 2:
    printf("El mes es febrero y tiene 28 días\n");
    break;
  case 3:
    printf("El mes es marzo y tiene 31 días\n");
    break;
  case 4:
    printf("El mes es abril y tiene 30 días\n");
    break;
  default:
    break;
  }
  return (0);
}

INICIO
NUM_MAX=0, NUM=0
MOSTRAR “Introduzca el número máximo:”
LEER NUM_MAX
MIENTRAS (NUM<=NUM_MAX) HACER MOSTRAR NUM NUM = NUM +1 FIN MIENTRAS FIN

#include <stdio.h>
int main() {
  int num_max=0, num=0;

  printf("Introduzca el número máximo: ");
  scanf("%d",&num_max);
  while (num<=num_max) {
    printf("%d ", num);
    num = num +1;
  }
  printf("\n");
  return(0);
}

Factorial de un número

INICIO
NUM_MAX=0, NUM=1, PROD=1
MOSTRAR “Introduzca el número: “
LEER NUM
MIENTRAS (NUM <= NUM_MAX) HACER
  PROD = PROD * NUM
  NUM = NUM + 1
FIN MIENTRAS
MOSTRAR “El factorial de NUM_MAX es: “ PROD
FIN

#include <stdio.h>
int main() {
  int num_max=0, num=1, prod=1;

  printf("Introduzca un número: ");
  scanf("%d",&num_max);

  while (num<=num_max) {
    prod = prod * num;
    num = num + 1;
  }
  printf ("El factorial de %d es: %d\n",num_max,prod);

  return(0);
}

INICIO
numMax=0
MOSTRAR “Introduzca el número hasta el que quiere contar: “
LEER numMax
PARA valor=0 HASTA numMax
MOSTRAR “El valor es: “ valor
FIN PARA

#include <stdio.h>
int main() {
  int numMax=0, valor=0;

  printf("Introduzca el número hasta el que quiere contar: ");
  scanf("%d",&numMax);

  for (valor=0; valor<=numMax; valor++) {
    printf("El valor es: %d\n", valor);
  }

  return(0);
}

Leer un número (entero y positivo, no hace falta comprobarlo) y determinar si es divisible por 5, 4, 3, 2, y 1 al mismo tiempo.

INICIO
Num=0
MOSTRAR “Introduzca un número: “
LEER Num
SI RESTO(Num/5)=0 Y RESTO(Num/4) =0 Y RESTO(Num/3)=0 Y RESTO(Num/2)=0
MOSTRAR “El número es divisible por 5,4,3,2 y 1”
SINO
MOSTRAR “El número no es divisible por 5,4,3,2 y 1”
FIN

(Solución alternativa)
INICIO
Num=0, Divisible=cierto
MOSTRAR “Introduzca un número: “
LEER Num
SI RESTO(Num/5) <> 0 Divisible=falso
SI RESTO(Num/4) <> 0 Divisible=falso
SI RESTO(Num/3) <> 0 Divisible=falso
SI RESTO(Num/2) <> 0 Divisible=falso
SI Divisible=cierto MOSTRAR “El número es divisible por 5,4,3,2 y 1”
SINO MOSTRAR “El número no es divisible por 5,4,3,2 y 1”
FIN

Indicar si un año es bisiesto.

INICIO
Ano=0;
MOSTRAR “Introducir el año: “
LEER Ano
SI RESTO(Ano/4)=0 Y ((RESTO(Ano/400) =0 Ó RESTO(Ano/100)<>0)) MOSTRAR “El año es bisiesto”
SINO MOSTRAR “El año no es bisiesto”
FIN

/* Código en C para comprobar si un año es bisiesto o no */
#include <stdio.h>
int main() {
  int ano=0;

  printf("Introducir el año: ");
  scanf("%d",&ano);

  if ((ano%4==0) && ((ano%400==0) || (ano%100!=0)))
    printf("El año es bisiesto\n");
  else
    printf("El año no es bisiesto\n");

  return(0);
}

Una compañía precisa de una administrativa.
A las candidatas se les realizan unas preguntas:
-¿Está soltera (1) o casado (2), otro (0)?
-¿Cantidad de hijos que tiene? Si no tiene indicar 0
-¿Posee algún título técnico S/N?
-¿Cuántos años tiene?
Serán preseleccionadas las que cumplan los siguientes requisitos:
+Mujeres solteras que estén en posesión de un título técnico, sin hijos y menores de 25 años.
+Mujeres casadas con edad superior a 40 años y con hijos
Tras introducir los datos indicar a la aspirante si está preseleccionada o no.

INICIO
estadoCivil=0,numHijos=0,titulo=”N”,anos=0
MOSTRAR “¿Está soltera(1), casada(2), otro(0)?”
LEER estadoCivil
MOSTRAR “¿Cantidad de hijos?”
LEER numHijos
MOSTRAR “¿Posee algún título técnico(S/N)?”
LEER titulo
MOSTRAR “¿Cuántos años tiene?”
LEER anos
SI ((estadoCivil=1) Y (numHijos=0) Y (titulo=”S”) Y (anos<25)) O ((estadoCivil=2) Y (edad>40) Y (numHijos>0)) MOSTRAR “Ha sido seleccionada”
SINO MOSTRAR “No ha sido seleccionada”
FIN

#include <stdio.h>
#include <string.h>
int main() {
  int estadoCivil=0, numHijos=0, anos=0;
  char titulo=' ', kk;

  printf("¿Está soltera(1), casada(2), otro(0)?");
  scanf("%d",&estadoCivil);
  printf("¿Cantidad de hijos?");
  scanf("%d",&numHijos);
  printf("¿Posee algún título técnico(S/N)?");
  scanf("%c",&kk);
  scanf("%c",&titulo);
  printf("¿Cuántos años tiene?");
  scanf("%d",&anos);

  if (((estadoCivil==1)&&(numHijos==0)&&(titulo=='S')) ||
     ((estadoCivil==2)&&(anos>40)&&(numHijos>0)))
     printf("Ha sido seleccionada\n");
  else
     printf("No ha sido seleccionada\n");

  return(0);
}

Solicitar por teclado un número entero entre 1 y 2000, y sacarlo por pantalla en números romanos.

INICIO
Num=0, Miles=0, Cientos=0, Decenas=0, Unidades=0, Aux=0
MOSTRAR  “Introduzca un número en el rango 1 a 2000”
LEER Num
MILES = Num/1000
Aux = RESTO(Num/1000)
CIENTOS = Aux/100
Aux = RESTO (Aux/100)
DECENAS = Aux/10
Aux = RESTO (Aux/10)
UNIDADES = Aux

//Mostrar los miles
PARA VALOR=1 HASTA MILES
        MOSTRAR “M”
FIN PARA

//Mostrar las centenas
HACER EN CASO
        EN CASO CIENTOS=1 MOSTRAR “C”
        EN CASO CIENTOS=2 MOSTRAR “CC”
        EN CASO CIENTOS=3 MOSTRAR “CCC”
        EN CASO CIENTOS=4MOSTRAR “CD”
        EN CASO CIENTOS=5 MOSTRAR “D"
        EN CASO CIENTOS=6 MOSTRAR “DC”
        EN CASO CIENTOS=7 MOSTRAR “DCC”
        EN CASO CIENTOS=8 MOSTRAR “DCCC”
        EN CASO CIENTOS=9MOSTRAR “CM”
FIN EN CASO
//Mostrar las decenas

HACER EN CASO
        EN CASO DECENAS =1 MOSTRAR “X”
        EN CASO DECENAS =2 MOSTRAR “XX”
        EN CASO DECENAS =3 MOSTRAR “XXX”
        EN CASO DECENAS =4MOSTRAR “XL”
        EN CASO DECENAS =5 MOSTRAR “L”
        EN CASO DECENAS =6 MOSTRAR “LX”
        EN CASO DECENAS =7 MOSTRAR “LXX”
        EN CASO DECENAS =8 MOSTRAR “LXXX”
        EN CASO DECENAS =9MOSTRAR “XC”
FIN EN CASO

//Mostrar las unidades
HACER EN CASO
        EN CASO UNIDADES =1 MOSTRAR “I”
        EN CASO UNIDADES =2 MOSTRAR “II”
        EN CASO UNIDADES =3 MOSTRAR “III"
        EN CASO UNIDADES =4MOSTRAR “IV”
        EN CASO UNIDADES =5 MOSTRAR “V”
        EN CASO UNIDADES =6 MOSTRAR “VI”
        EN CASO UNIDADES =7 MOSTRAR “VII”
        EN CASO UNIDADES =8 MOSTRAR “VIII”
        EN CASO UNIDADES =9MOSTRAR “IX”
FIN EN CASO
FIN

#include <stdio.h>
int main() {
  int num=0, miles=0, cientos=0, decenas=0, unidades=0, aux=0, i=0;

  printf ("Introduzca un número en el rango 1 a 3999: ");

  scanf("%d", &num);

  miles = num/1000;
  aux = num%1000;
  cientos=aux/100;
  aux=aux%100;
  decenas=aux/10;
  aux=aux%10;
  unidades=aux;

  printf ("El equivalente en números romanos es:  ");

  //Mostrar los miles
  for (i=1; i<=miles; i++) printf("%s","M");

  //Mostrar las centenas
  switch (cientos) {
    case 1:
      printf("%s","C");
      break;
    case 21:
      printf("%s","CC");
      break;
    case 3:
      printf("%s","CCC");
      break;
    case 4:
      printf("%s","CD");
      break;
    case 5:
      printf("%s","D");
      break;
    case 6:
      printf("%s","DC");
      break;
    case 7:
      printf("%s","DCC");
      break;
    case 8:
      printf("%s","DCCC");
      break;
    case 9:
      printf("%s","CM");
      break;
  }

  //Mostrar las decenas
  switch (decenas) {
    case 1:
      printf("%s","X");
      break;
    case 2:
      printf("%s","XX");
      break;
    case 3:
      printf("%s","XXX");
      break;
    case 4:
      printf("%s","XL");
      break;
    case 5:
      printf("%s","L");
      break;
    case 6:
      printf("%s","LX");
      break;
    case 7:
      printf("%s","LXX");
      break;
    case 8:
      printf("%s","LXXX");
      break;
    case 9:
      printf("%s","XC");
      break;
  }

  //Mostrar las unidades
  switch (unidades) {
    case 1:
      printf("%s","I");
      break;
    case 2:
      printf("%s","II");
      break;
    case 3:
      printf("%s","III");
      break;
    case 4:
      printf("%s","IV");
      break;
    case 5:
      printf("%s","V");
      break;
    case 6:
      printf("%s","VI");
      break;
    case 7:
      printf("%s","VII");
      break;
    case 8:
      printf("%s","VIII");
      break;
    case 9:
      printf("%s","IX");
      break;

  }
printf ("\n");
}