Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
01raul

Analise do codigo

Recommended Posts

Ola pessoal^_^ durante a minha disciplina de inteligencia artificial o professor pediu que estudasse o código e Apresentássemos para ele individualmente, porém apesar de comentar a parte que entendi ainda tem muita coisa que não faço a menor ideia do que esta acontecendo como por exemplo a logica da roleta e sorteio se alguém puder me dar uma mão vou ficar muito agradecido!!!  :tw_cold_sweat:


//declaracao de bibliotecas
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>
#include <time.h>

//Definição do número de 
#define populacao 30 //POPULAÇÃO
#define Ncidade 10   //CIDADES

//Definição da matriz e o espelhamento
	int distancia [Ncidade][Ncidade]= {{0,15,30,5,12,19,45,22,56,70 	},
             		                  {15,0,34,98,134,97,87,101,76,9    },
                      		          {30,34,0,234,554,67,61,78,123,209 },
                            		  {5,98,234,0,14,56,79,120,99,34    },			// valores
                             		  {12,134,554,14,0,76,87,91,222,543 },
	                         		  {19,97,67,56,76,0,46,765,344,10   },
	                              	  {45,87,61,79,87,46,0,542,78,890   },
	                           		  {22,101,78,120,91,765,542,0,120,65},
	                            	  {56,76,123,99,222,344,78,120,0,90 },
	                           	 	  {70,9,209,34,543,10,890,65,90,0  }};
	                           	 	  	                           	 	  
// DECLARANDO AS VARIAVEIS 
int pop[populacao][Ncidade], km[populacao], filho[Ncidade], geração[populacao][Ncidade], a, 
			   b, k, z, achou=0, perfeito, total=0, tipoSelecao, quantidadeGeracao, gera=2; 
float aptidaopopulacao[populacao], taxaMutacao;	                           	 	  
	
//DEFINIÇÃO DA ESTRUTURA
	struct s{
	  int individuo[Ncidade], aptidao1;  // DECLARANDO VARIAVEIS DA ESTRUTURA
   }selecionado;


//===================== ELIMINA GENES REPETIDOS ======================= //

void VERIFICA_GENES(int individuo, int posicao_atual){            
        for(register int k=0; k<posicao_atual; k++)
            if(pop[individuo][k] == pop[individuo][posicao_atual]){
                pop[individuo][posicao_atual]++;
                pop[individuo][posicao_atual] = pop[individuo][posicao_atual]%Ncidade;
                VERIFICA_GENES(individuo, posicao_atual);
            }                        
}

//===================== elimina indivíduos repetidos =================== //

int INDIVIDUO_EXISTE(int pos){  //FUNÇÃO QUE VERIFICA SE O INDIVIDUO EXISTE                       
     int j; // DECLARANDO VARIAVEIS
     for(register int i=0; i<pos; i++){
        for(j=0; j<Ncidade; j++){
           if(pop[i][j] != pop[pos][j]){
              break;
           }
        }
        if(j==10)return 1;
     }
    return 0;
}

//===================== calcula a quantidade de quilometros ============== //

void APTDAO(){ 

int aux=0;      // DECLARANDO VARIAVEIS        
    for(register int a=0; a<populacao; a++){
	    for(register int b=0; b<Ncidade-1; b++){
	    	aux += distancia[pop[a][b]][pop[a][b+1]];
	    	km[a]=aux;         
	    }
	   aux=0;
	}
}

// ===================== Primeira Geração ============================== //

void PRIMEIRA_GERACAO(){

	for(register int a=0; a<populacao; a++){
		for(register int b=0; b<Ncidade; b++){
			pop[a][b]=rand ()%Ncidade;
			VERIFICA_GENES(a,b);
	    }
		
        if(INDIVIDUO_EXISTE(a))a-=1;		
}
	APTDAO();
	printf(" \n\n\t\tPRIMEIRA geração \n");
	for(register int a=0; a<populacao; a++){
    	printf("CAMINHO %i: ", a+1);
    for(register int b=0; b<Ncidade; b++){
        printf("%i ",pop[a][b]);
    }
    printf("KM PERCORRIDOS %i\n", km[a]);    
	} 

if(achou)
	printf("\n\nO INDIVIDUO %d É PERFEITO\n\n",perfeito+1);
}

// ============== Calculo de Aptidão do Individuo ============ //

void CALCULO_APT_INDVIDUO(){ 	  //Calculo da aptidão inversamente proporcional
     float media, total_ind=0;   // DECLARANDO VARIAVEIS
     total=0;
     for(register int x=0; x<populacao; x++){
             total+=km[x];
             if(!km[x])continue;
             total_ind+=(1/(float)km[x]);             
     }     
     for(register int x=0; x<populacao; x++){
             aptidaopopulacao[x]=(float)(total/(km[x]*total_ind));
     }
}


// ============== Seleção metodo Roleta e sorteio ============ //

void ROLETA(){
	int sorte, achou =0, i=0;   // DECLARANDO VARIAVEIS
	float soma=0;
	CALCULO_APT_INDVIDUO();
	do{sorte = rand()%total; }while(!sorte);
     
     while(!achou){
         soma += aptidaopopulacao[i];
         
         if(soma >= sorte){

         	for(register int k=0; k<Ncidade; k++)  //SORTEIO DAS POSIÇÕES
         		selecionado.individuo[k] = pop[i][k]; //SELECIONANDO AS POSIÇÕES
                 selecionado.aptidao1 = aptidaopopulacao[i]; //REALOCANDO AS POSICÕES
                 achou=1;
         }
         i++;
     }
}

void TORNEIO(){
     int candidato, melhor; // DECLARANDO VARIAVEIS
     selecionado.aptidao1 = 1000;     
     for(register int a=0; a<k; a++){         
         candidato=rand()%populacao;
         if(km[candidato]<selecionado.aptidao1){             
             selecionado.aptidao1 = km[candidato];
             melhor=candidato;
             for(register int k=0; k<Ncidade; k++)
    				     selecionado.individuo[k] = pop[candidato][k];                     
         }       
     }  
}

// =============== Multação ================================ //

void MUTACAO_POR_ORDEM(){
     int aux, posicao_al; // DECLARANDO VARIAVEIS
     for(register int k=0; k<Ncidade; k++){
       if(!(rand()%(int)(100/taxaMutacao))){
          do{posicao_al = rand()%Ncidade;}while(posicao_al == k);
          aux = filho[k];
          filho[k] = filho[posicao_al];
          filho[posicao_al] = aux;
       }
	}    
}

// =============== REPRODUÇÃO ============================= //

void REPRODUCAO_POR_ORDEM(){
	int i, indice, p1[Ncidade], p2[Ncidade], corte; // DECLARANDO VARIAVEIS
	
	switch(tipoSelecao){
		case 1:
			ROLETA();
			for(register int k=0; k<Ncidade; k++)
             p1[k] = selecionado.individuo[k];
			
			ROLETA();
			for(register int k=0; k<Ncidade; k++)
             p2[k] = selecionado.individuo[k];
			break;	
	
		case 2:
			TORNEIO();
			for(register int k=0; k<Ncidade; k++)
             p1[k] = selecionado.individuo[k];
		
			TORNEIO();
			for(register int k=0; k<Ncidade; k++)
             p2[k] = selecionado.individuo[k];
			break;	
	}
	    corte = rand()%7;
	     for(i=0; i<=corte; i++){
    	    filho[i] = p1[i];
			}
	
	indice=i;

     for(register int b=0; b<Ncidade; b++){
        for(register int k=indice; k<Ncidade; k++){
           if(p2[b] == p1[k]){
              filho[i] = p1[k];                        
              i++;
              break;
           }
        }
     }
}

// ================= NOVA_GERAÇÃO ======================== //

void NOVA_GERACAO(){    
 
    for(register int a=0; a<populacao; a++){ 
      REPRODUCAO_POR_ORDEM();
      MUTACAO_POR_ORDEM(); 
 
      for(register int k=0; k<Ncidade; k++)
         geração[a][k] = filho[k];     
    }
}

// =============== ATUALIZAÇÃO ============================= //

void ATUALIZACAO(){

	 NOVA_GERACAO();
    for(register int a=0; a<populacao; a++){
      for(register int b=0; b<Ncidade; b++){
          pop[a][b] = geração[a][b];
       }    
    }
     APTDAO();
    printf("\n\t\tGERAÇÃO %d\n", gera++);
    for(register int a=0; a<populacao; a++){
       printf("INDIVIDUO %i: ", a+1);
       for(register int b=0; b<Ncidade; b++){
         printf("%i ", pop[a][b]);
       }
       printf(" KM PERCORRIDOS: %i\n", km[a]);    
	
	}
}


// =============== Menu Principal ========================== //
int main(){ 
int opcao; a=0;

setlocale(LC_ALL, "portuguese");
srand(time(0));
system("color f9");

printf("\t\tCAIXEIRO VIAJANTE\n");

do {	
		printf("\n\nSELEÇÃO\n1.ROLETA \n2.TORNEIO\nDEFINA TIPO DE SELEÇÃO: ");
		fflush(stdin);
		scanf("%i", &tipoSelecao);
 		
 		if(tipoSelecao == 2){
 		   printf("\nINFORME O TAMANHO DO TORNEIO: ");
           fflush(stdin);
           scanf("%d", &k);
 			
 			}
	}while(tipoSelecao!=1 && tipoSelecao!=2);
	do{
		printf("\nINFORME A QUANTIDADE DE GERAÇÕES (MAIOR QUE 1): ");
        fflush(stdin);
        scanf("%i", &quantidadeGeracao);
        
		}while(quantidadeGeracao < 2);
    do{ 
        printf("\nINFORME A TAXA DE MUTAÇÃO (EM %%): "); 
        fflush(stdin);
        scanf("%f", &taxaMutacao);
        
	}while(taxaMutacao <= 0 || taxaMutacao>100);
	
	PRIMEIRA_GERACAO();
	
	getch();
	
	for(register int x=0; x<(quantidadeGeracao - 1); x++){
        ATUALIZACAO();
        
        if(achou){
    	  printf("\n\nO INDIVIDUO --> ");
      	for(register int j=0; j<Ncidade; j++){
        	printf("%i ", pop[perfeito][j]);
      }
        
		printf("<-- É PERFEITO\n\n");
      break; 
      }
   		getch();
} 
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário






Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×