bool MotorDeInferencia::aplicar(Regla* r, Asociacion* as){
    cout << "MotorDeInferencia::aplicar()"<<endl;


    bool aplicada =bh->aplicar(r, as);  //<---------


    cout << "as.t" << as->t << endl;
    cout <<"Retornando al primer consecuente de la regla: " << r->getId()<<endl;;
    cout << "Valor: " << as->valor << endl;
    return aplicada;

}

bool BaseDeHechos::aplicar(Regla* r, Asociacion* as){
    cout << "BaseDeHechos::aplicar()"<<endl;
    vector<Asociacion> consecuentes=r->getConsecuente();
    if(consecuentes.size()==2 &&(isContenido(consecuentes[0])
                             || isContenido(consecuentes[1])))
        return false;
    if(consecuentes.size()==2 && isNegacion(consecuentes[0])){
        *as=consecuentes[1];
        return true;
    }        
    as=&consecuentes[0];

/* cout << "consecuentes.size:"<<consecuentes.size()<<endl;
    cout << "as->t" << as->t << endl;
    cout << "as->valor: " << as->valor << endl;*/
 
    return true;    
    
}

public static void main(String[] args) throws IOException {
		//Validacion con Afd.
		Afd automata = new Afd("adn.jff");
		System.out.println("Introduzca una o varias cadenas separadas"
				+ " por coma para su validación: \n");
		Scanner consola = new Scanner(System.in);
		String linea = consola.nextLine();
		String[] listaCadenas = linea.split(",");
		System.out.println("********Validación con Afd.********\n");
		for (String cadena : listaCadenas) {
			System.out.println("La cadena (" + cadena + ") ¿Es válida? "
					+ ValidacionADN.esValida(automata, cadena));
			if (ValidacionADN.esValida(automata, cadena) == false) {
				System.out.println("estado: " + automata.getEstadoActual()
						+ ", símbolo: " + automata.getSimboloActual());

			}
		}
		//Validación con Matcher.
		System.out.println("********Validacion con Matcher********");


		Pattern patEnzimas= Pattern.compile("[[GGCC]*|[GGTACC]*|[TTCGAA]*|[TGATCA]*]+"); // ESTA ES LA LÍNEA QUE TENGO MAL


		for (String cadena: listaCadenas){
			Matcher matEnzimas= patEnzimas.matcher(cadena);
			System.out.println("¿Es válida la cadena ("+cadena+")?"+matEnzimas.matches());
		}
						
	}

Array ArrayCreaAleatorio(int linf, int lsup)
{
      ArrayAp a=malloc(sizeof(ArrayRep));
      a->n=lsup-linf+1; 
      a->v=malloc(sizeof(int)*a->n);
      for (int i=0; i<a->n;i++)
          a->v[i]=linf+i;
      for (int j=0;j<=a->n-2;j++)
      {
          int k=EnteroAleatorio(j+1,a->n-1);
          int aux=a->v[j];
          a->v[j]=a->v[k];
          a->v[k]=aux;
      }
      return a; 
}

// Crea y devuelve un array cuyos elementos han sido 
// leídos desde un fichero de texto con descriptor de fichero f.
// Req: El formato del fichero de lectura es el siguiente:
//  n v_1 v_2 ... v_n
//  con n>0. 
// Por ejemplo, el array {4,6,3,5} estaría en el fichero como:
//  4 4 6 3 5
Array ArrayCreaFichero(FILE * f)
{
      ArrayAp a;
      fscanf(f,"%d",&a->n);
      a->v=malloc(sizeof(int)*a->n);
      for(int i=0;i<a->n;i++)
         fscanf(f,"%d",&a->v[i]);
      return a;
}

// Crea y devuelve un array de tamaño n con sus elementos
// inicializados a cero e indexados desde 1 hasta n.
// Req: n>0
Array ArrayCrea(int n)
{
      ArrayAp a=malloc(sizeof(ArrayRep));
      a->n=n;
      a->v=malloc(sizeof(int)*n);
      for (int i=0;i<a->n;i++)
          a->v[i]=0;
      return a;      
}

typedef struct {int *v; int n;}ArrayRep;
typedef ArrayRep *ArrayAp;

// Crea y devuelve un subarray del array a comprendido
// entre los índices i y j.
// Req: 1<=i<=j<=ArrayTam(a)
Array ArrayCreaSubarray(Array a, int i, int j)
{      
       ArrayAp ap=a;
       ArrayAp a2=ArrayCrea(j-i+1);
       for (int x=0; x<j-i+1;x++)   a2->v[x]=ap->v[i+x-1];
       return a2;
}

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


// Lee por teclado dos enteros linf y lsup, 
// tales que linf<=lsup.

void LimitesLee(int * linf, int * lsup)
{
     printf("Introduzca dos enteros para los límites inferior y superior: \n");
     scanf ("%d %d",linf,lsup);
     while (*linf>*lsup) 
     {
           printf("El limite inferior no puede ser mayor que el superior\n");
           printf("Por favor, vuelva a introducir los límites\n");
           scanf("%d %d",linf,lsup);
     }
}
// Imprime por pantalla los enteros linf y lsup con formato:
// Limites: [linf,lsup]
void LimitesImprime(int linf, int lsup)
{
     printf("Los límites inferior y superior son:[%d,%d]\n",linf,lsup);
}
// Genera y devuelve un entero aleatorio entre los límites 
// linf y lsup.
int EnteroAleatorio(int linf, int lsup)
{
    return linf+rand()%(lsup-linf+1);
}
// Imprime por pantalla un entero e con formato:
// Entero: e
void EnteroImprime(int e)
{
     printf("Entero: %d \n",e);
}



// Crea y devuelve un array de tamaño n = lsup-linf+1
// con los números enteros comprendidos entre los límites 
// linf y lsup, asignados al array de forma aleatoria entre los 
// índices 1 y n. El array contendrá finalmente una 
// permutación con los números enteros comprendidos entre
// dichos límites.
// Req: linf<=lsup
struct Array {int *v; int n;}

Array ArrayCreaAleatorio(int linf, int lsup)
{
      Array a;
      a.n=lsup-linf+1;
      a.v=malloc(sizeof(Array)*(a.n));
      for (int i=0; i<a.n;i++)
          a.v[i]=linf+i;
      for (int j=0;j<=a.n-2;j++)
      {
          int k=EnteroAleatorio(j+1,a.n-1);
          int aux=a.v[j];
          a.v[j]=a.v[k];
          a.v[k]=aux;
      }
      return a;       
}



int main()
{
    char nombre[10];
    int  edad;
    printf ("Hola mundo\n");
    printf ("Dime tu nombre: ");
    scanf  ("%s",nombre);
    printf ("Dime tu edad: ");
    scanf  ("%d",&edad);
    while(edad<0)
              {
              printf("Edad erronea, introduce edad: ");
              scanf("%d",&edad);
              }
    printf ("Hola %s tienes %d tacos\n",nombre,edad);
    
    int linf=0;
    int lsup=0;
    int ernd=0;
    int opcion=0;
    Array a=ArrayCreaAleatorio(linf,lsup);
    while (opcion!=7)
    {
          printf("1. Imprimir en pantalla los límites actuales.\n");
          printf("2. Imprimir en pantalla el entero aleatorio actual.\n");
          printf("3. Imprimir en pantalla el array actual.\n");
          printf("4. Leer desde teclado nuevos límites.\n");
          printf("5. Generar un nuevo entero aleatorio dentro de los límites actuales.\n");
          printf("6. Generar un nuevo array aleatorio dentro de los limites actuales.\n");
          printf("7. Salir.\n");
          printf("Introducir opción (1-5):\n");
          scanf("%d",&opcion);
          switch(opcion)
          {
              case 1:LimitesImprime(linf,lsup);break;
              case 2:EnteroImprime(ernd);break;
              case 3:break;
              case 4:LimitesLee(&linf,&lsup);
                     LimitesImprime(linf,lsup);break;
              case 5:ernd=EnteroAleatorio(linf,lsup);
                     EnteroImprime(ernd);break;
              case 6:break;
              case 7:break;
              default: printf("Error, la opción ha de estar comprendida entre 1-5\n");
          }
                      
                        
    }
        system("pause");
    return 0;
}