equivalenza formule logiche... enumerazione?

[jaguar21]

Ciao a tutti vi pongo il mio quesito:

ho 2 formule logiche deve verificare che siano equivalenti, le ho salvate e validate in un ARRAY per ognuna e ora dovrei provare per la loro equivalenza per ogni valore delle loro proposizioni , quindi si ha l equivalenza se e solo se per ogni valore delle proposizioni il risultato delle formule è lo stesso....a questo punto non saprei come fare per provare tutte e combinazioni...potreste aiutarmi??? non so se possano servire le enumerazioni per impostare vero o falso per ogni proposizione aiuto il 13 devo consegnare questo progetto

/*

* main.c

*

*  Created on: 12/dic/2013

*      Author: GianMarco

*/



/* Il programma acquisisce acquisisce da tastiera due formule di logica proposizionale

e stabilisce se esse sono equivalenti. */



/* Inclusione delle librerie standard*/

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>







/* Dichiarazione delle funzioni */

char *acquisisci_formula (int *); 



int valida_formula (char *, int *n);







int risolvi(char *,char *, int *);





/* Funzione principale */

int main (void)

{

    /* Dichiarazione delle variabili locali alla funzione */

    char  *fbf;        

    char *fsec;     /* Lavoro: Puntatore ad un array

                                di caratteri */



    int             n,          /* Lavoro: Dimensione dell'array */

                    risultato,  /* Output: Valore di verita' trovato */

                    sx = 1;     /* Lavoro: Indice del primo elemento

                                esaminabile dell'array */



    /* Stampa a video del titolo del programma */

    printf("\n\n\t- Programma per confronate l'equivalenza tra 2 formule logiche");

    printf("\n\t- Autore:  - \n\n");



    /* Acquisizione della formula */

    fbf = acquisisci_formula(&n);

    fsec= acquisisci_formula(&n);

    



    /* Acquisizione dell'assegnamento di verita' */

    



    /* Valutazione della soddisfacibilita' */

    risultato = risolvi(fbf, fsec,

                        &sx);

                        

    



    /* Stampa del risultato finale */

    if(risultato == 1)

        printf("\n L'assegnamento di verita' inserito SODDISFA");

    else

        printf("\n L'assegnamento di verita' inserito NON SODDISFA");

    printf(" la formula. \n\n");



    return(0);

}



/* La funzione acquisisce la formula e ne effettua la validazione */

/* Prende in ingresso una variabile che indica la lunghezza effettiva

della formula e restituisce l'indirizzo del primo elemento, la

lunghezza della formula viene aggiornata */

char *acquisisci_formula(int *n)

{

    /* Dichiarazione delle variabili locali alla funzione */

    int             i = 0,        /* Lavoro: contatore */

                    err = 0,       /* Lavoro: esito delle validazioni */

                    connettivi = 0,       /*Lavoro: n°  connettivi logici*/

                  conn_max=3,    /*Lavoro: n° massimo occorenze proposizionali*/

                  proposizioni=0; 

                  

         



    char  *fbf;    /* Lavoro: Puntatore che ospitera' un

                             array del nuovo tipo strutturato */



    char            caratt,  /* Input: Carattere da acquisire */

                    car_err; /* Lavoro: Variabile utile a

                             svuotare il buffer */

                             



    /* Acquisizione della formula con validazione */

    /* Se la formula inserita e' scorretta o troppo lunga

    l'acquisizione viene ripetuta*/

    do

    {

      *n=7;



        /* Allocazione di un array della dimensione indicata */

        fbf = (char *) calloc(*n + 1, sizeof(char));



        /* Acquisizione della formula */

        printf("\nDigitare una formula ben formata della logica");

        printf(" proposizionale.\nDigitare:\n \"1\" per la negazione");

        printf("\n \"2\" per la congiunzione\n \"3\" per la ");

        printf("disgiunzione\n \"4\" per l'implicazione\n");

        printf(" \"5\" per la doppia implicazione\n Utilizzare");

        printf(" lettere minuscole per rappresentare le ");

        printf("proposizioni\n E' vietato l uso delle parentesi verrà applicata la precedenza dei connettivi logici: ");



      

       /* Vengono acquisiti caratteri fino al massimo consentito */

        for (i = 0, connettivi=0, proposizioni=0;

             (((caratt = getchar()) != '\n') && (i < *n));

             i++)

            {

         if (caratt == '1' || caratt == '2' || caratt == '3' || caratt == '4' || caratt == '5')

            connettivi++;

         

         

         if (!isdigit(caratt))

            proposizioni++;

         



            fbf[i]= caratt;

          }

          printf("propozioni= %d",proposizioni);

          printf("connettivi= %d",connettivi);

          printf("formula= %s", fbf);

         

          



        /* Se si e' superato il limite, viene segnalato all'utente e

        liberato spazio in memoria per ripetere l'allocazione */

        if(connettivi > conn_max)

        {

            



            /* Vengono eliminati i caratteri non acquisiti */

            do

                scanf("%c",

                      &car_err);

            while(car_err != '\n');



            free(fbf);

            printf("\n\nErrore: sono stati usati più di 3 connettivi logici.\n\n");

        }

        else

        {

            /* Validazione della formula e rimozione di spazi */

            err = valida_formula(fbf,

                                 &i);



            /* Se la formula risulta errata viene segnalato all'utente

            e liberato spazio per ripetere l'allocazione*/

            if(err != 0)

            {

                printf("\n\nErrore: formula non corretta.\n\n");

                free(fbf);

                

            }

        }

    }

    while((connettivi > conn_max) || (err != 0) || i > *n);



    return(fbf);

}





/* Elimina gli spazi,effettua il controllo sull'esattezza della formula

e inizializza i campi che ospitano gli assegnamenti di verita' */

/* Prende in ingresso l'array della formula e la sua lunghezza,

restituisce un flag che indica la presenza o meno di errori,

la lunghezza della formula viene eventualmente aggiornata */

int valida_formula (char *fbf, 

                    int *n)

{

    /* Dichiarazione delle variabili locali alla funzione */

        int i,      /* Lavoro: variabile contatore */

        spazi = 0,  /* Lavoro: variabile contatore degli spazi */

        err = 0;    /* Lavoro: contatore/flag per segnalare errori */

        

    /* Rimozione degli spazi */

    for(i = 0; (i < *n); i++)

    {

        /* Se il carattere corrente e' uno spazio viene aggiornato

        il contatore*/

        if(fbf[i] == ' '){

            spazi++;

            printf("spazi= %d", spazi);

        /* Se il carattere corrente non e' uno spazio viene fatto

        scorrere all'indietro di tante posizioni quanti sono gli

        spazi individuati */

        }else

            fbf[i - spazi] = fbf[i];

    }



    /* Viene aggiornata la lunghezza dell'array */

    *n -= spazi;



    /* Validazione della formula */

    /* La formula non deve contenere parentesi */

    for (i=0; i < *n; i++)

    {

      if (fbf[i] == '(' || fbf[i] == ')')

      {

      err++;

      printf("\n\nErrore: reparto parentesi 1 = %d\n\n", err);

      }   

      

   }

   

    

    /* Se si riscontrano gia' errori, non si prosegue */

    if(err == 0)

    {

        for(i = 0;

            (i < *n);

            i++)

        {



            /* Validazione connettivi logici */

            if(isdigit(fbf[i]))

            {

                /* Controllo caratteri ammessi */

                if((fbf[i] > '5') ||

                   (fbf[i] == '0'))

                    err++;

                else if(fbf[i] > '1')

                {

                    /* In questo progetto un connettivo binario puo' essere seguito

                    solo da  variabili */

                    if((!(islower(fbf[i + 1]))) && (!fbf[i + 1] == '1'))

                       err++;



                    if((!(islower(fbf[i - 1]))))

                       err++;

                }

            }

            /* Validazione proposizioni */

            else if(islower(fbf[i]))

            {

                /* Una proposizione può essere preceduta solo da

                connettivi e seguita da un connettivo

                binario */

                if (!((fbf[i + 1] >= '2') &&

                       (fbf[i + 1] <= '5')) && (!(fbf[i + 1] == '\0')))

                {

                    err++;

                    printf("\n\nErrore: reparto proposizioni dopo minuscole = %d%d\n\n", err,i);

            }

            

                if (!(i==0)  && (!(fbf[i - 1] >= '1')))

                {

                err++;

            printf("\n\nErrore: reparto proposizioni prima minuscole = %d%d\n\n", err,i);

            }   

            

                

                

            }

        }

    }

   printf("\n\nTOTALE ERRORI= %d\n\n", err);

    return(err);

}

}