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

Diseño de base de datos y consultas

Hemos estado trabajando un poco con Access para familiarizarnos con las bases de datos y el lenguaje de consultas SQL. A continuación voy a mostrar mi solución al problema planteado en este apartado del curso.

En primer lugar, se debe diseñar la estructura de tablas más adecuada a las necesidades de nuestro proyecto.

A continuación, se crean las consultas necesarias sobre la estructura de tablas creada previamente para obtener los datos requeridos por los usuarios.

BÚSQUEDAS:
1.- Cliente por nombre comercial, nombre fiscal, CIF/NIF, población, provincia, tipo de IVA, código postal y teléfono
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE NombreComercial LIKE “*”&[Nombre]&”*”
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE NombreFiscal LIKE “*”&[Nombre]&”*”
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE CIF_NIF = [:Nombre]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE Poblacion=[:Nombre]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE Provincia= [:Nombre]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE CIF_NIF=[:CIF_NIF]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE tipo_recargo_fk=[:TipoIVA]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE codigo_postal=[:CodigoPostal]
-SELECT NombreFiscal, NombreComercial FROM CLIENTE WHERE Id IN (SELECT id_cliente_fk FROM TELEFONOS_CLIENTE WHERE teléfono=[:Telefono])

2.- Proveedor por nombre comercial, nombre fiscal, CIF/NIF, población, provincia, código postal y teléfono
-SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE NombreComercial LIKE “*”&[Nombre]&”*”
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE NombreFiscal LIKE “*”&[Nombre]&”*”
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE CIF_NIF =[:Nombre]
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE Poblacion==[:Nombre]
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE Provincia= =[:Nombre]
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE CIF_NIF=[:CIF_NIF]
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE codigo_postal=[:CodigoPostal]
SELECT NombreFiscal, NombreComercial FROM PROVEEDOR WHERE Id IN (SELECT id_proveedor_fk FROM TELEFONOS_ PROVEEDOR WHERE teléfono=[:Telefono])

3.- Artículos por código y descripción
SELECT * FROM ARTICULO WHERE id=[:Código]
SELECT * FROM ARTICULO WHERE descripcion LIKE “*”&[descripción]&”*”

LISTADOS:
a)Clientes que han realizado compras de artículos de un proveedor.
SELECT DISTINCT C.nombre_comercial FROM ((CLIENTE C INNER JOIN FACTURA_VENTA FV ON C.Id=FV.id_cliente_fk) INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk) INNER JOIN ARTICULO A ON DFV.id_articulo_fk=A.Id WHERE A.id_proveedor_fk = [:IdProveedor]
b)Clientes a los que se les ha vendido un artículo.
SELECT DISTINCT C.nombre_comercial FROM (CLIENTE C INNER JOIN FACTURA_VENTA FV ON C.Id=FV.id_cliente_fk) INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk WHERE DFV.id_articulo_fk= [:IdArticulo]
c)Proveedores de una factura de venta.
SELECT DISTINCT P.nombre_comercial AS NombreProveedor FROM ((FACTURA_VENTA FV INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk) INNER JOIN ARTICULO A ON DFV.id_articulo_fk=A.Id) INNER JOIN PROVEEDOR P ON A.id_proveedor_fk=P.Id WHERE FV.Id = [:IdFacturaVenta]
d)Listado de facturas (total, por cliente, conteniendo un artículo).
-SELECT Id AS NumeroFactura, id_cliente_fk AS CodigoCliente, fecha FROM FACTURA_VENTA
-SELECT Id AS NumeroFactura, id_cliente_fk AS CodigoCliente, fecha FROM FACTURA_VENTA WHERE id_cliente_fk = [:IdCliente]
-SELECT FV.Id AS NumeroFactura, FV.id_cliente_fk AS CodigoCliente, FV.fecha AS Fecha FROM FACTURA_VENTA FV INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk WHERE DFV.id_articulo_fk = [:IdArticulo]
e)Listado de stock (todos, solo existencias).
- select articulo, sum(CantidadTotal) as Stock from(
select a.descripcion as articulo, sum(dfc.cantidad) as CantidadTotal from detalle_factura_compra dfc inner join articulo a on dfc.id_articulo_fk=a.id group by a.descripcion
union
select a.descripcion as articulo, -sum(dfv.cantidad) as CantidadTotal from detalle_factura_venta dfv inner join articulo a on dfv.id_articulo_fk=a.id group by a.descripcion)
group by articulo

- select articulo, sum(CantidadTotal) as Stock from(
select a.descripcion as articulo, sum(dfc.cantidad) as CantidadTotal from detalle_factura_compra dfc inner join articulo a on dfc.id_articulo_fk=a.id group by a.descripcion
union
select a.descripcion as articulo, -sum(dfv.cantidad) as CantidadTotal from detalle_factura_venta dfv inner join articulo a on dfv.id_articulo_fk=a.id group by a.descripcion)
group by articulo having sum(CantidadTotal)>0
f)Listado de artículos (total y vendidos a un cliente entre fechas con precio de venta).
-SELECT descripcion, precio FROM ARTICULO
-SELECT A.descripción AS Articulo, DFV.precio_unidad AS PrecioVenta, DFV.cantidad AS Cantidad FROM (FACTURA_VENTA FV INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk) INNER JOIN ARTICULO A ON DFV.id_articulo_fk=A.Id WHERE FV.id_cliente_fk = [:IdCliente] AND FV.fecha BETWEEN [:FechaInicial] AND [:FechaFinal]
g)Formato 347 para clientes y proveedores (ventas o compras anuales por importe total superior a 3.005,06€).
- SELECT C.nombre_fiscal, SUM((1+DFV.IVA_aplicable)*DFV.cantidad*DFV.precio_unidad) AS Total from (DETALLE_FACTURA_VENTA DFV INNER JOIN FACTURA_VENTA FV ON DFV.id_factura_venta_fk=FV.id) INNER JOIN Cliente C ON FV.id_cliente_fk=C.Id GROUP BY C.nombre_fiscal HAVING SUM((1+DFV.IVA_aplicable)*DFV.cantidad*DFV.precio_unidad)>3005.6
- SELECT P.nombre_fiscal, SUM((1+DFC.IVA_aplicable)*DFC.cantidad*DFC.precio_unidad) AS Total from (DETALLE_FACTURA_COMPRA DFC INNER JOIN FACTURA_COMPRA FC ON DFC.id_factura_compra_fk=FC.id) INNER JOIN Proveedor P ON FC.id_proveedor_fk=P.Id GROUP BY P.nombre_fiscal HAVING SUM((1+DFC.IVA_aplicable)*DFC.cantidad*DFC.precio_unidad)>3005.6
h)Listado de ventas entre fechas.
SELECT A.descripcion AS Descripcion, DFV.cantidad AS Unidades, DFV.precio_unidad AS Precio, DFV.IVA_aplicable AS IVA FROM (FACTURA_VENTA FV INNER JOIN DETALLE_FACTURA_VENTA DFV ON FV.Id=DFV.id_factura_venta_fk) INNER JOIN ARTICULO A ON A.Id=DFV.id_articulo_fk WHERE FV.fecha BETWEEN [:fechaInicio] AND [:fechaFin]

i)Listado de compras entre fechas (artículos comprados entre fechas).
SELECT A.descripcion AS Descripcion, DFC.cantidad AS Unidades, DFC.precio_unidad AS Precio, DFC.IVA_aplicable AS IVA FROM (FACTURA_COMPRA FC INNER JOIN DETALLE_FACTURA_COMPRA DFC ON FC.Id=DFC.id_factura_compra_fk) INNER JOIN ARTICULO A ON A.Id=DFC.id_articulo_fk WHERE FC.fecha BETWEEN [:fechaInicio] AND [:fechaFin]
j)Listado de clientes con email.
SELECT * FROM CLIENTE WHERE email IS NOT NULL

Nota: Estas consultas han sido probadas sobre la estructura de base de datos mostrada al inicio, sobre MS Access 2007 y con unos pocos datos.