Exemple #1
0
int main() {
    int** minha_matriz = cria_matriz(3, 4);

    //    |   0    1     2    3
    // ___|______________________
    // 0  |  12   45    56    5
    // 1  |   0    0    -1   17
    // 2  |   3   10     0    1

    minha_matriz[0][0] = 12;
    minha_matriz[0][1] = 45;
    minha_matriz[0][2] = 56;
    minha_matriz[0][3] = 5;

    minha_matriz[1][2] = -1;
    minha_matriz[1][3] = 17;

    minha_matriz[2][0] = 3;
    minha_matriz[2][1] = 10;
    minha_matriz[2][3] = 1;

    int** matriz_dobro = soma_matrizes(minha_matriz, minha_matriz,
                                       3, 4);

    imprime_matriz(minha_matriz, 3, 4);
    printf("\n");
    imprime_matriz(matriz_dobro, 3, 4);

    printf("\n");
    return 1;
}
Exemple #2
0
/*multiplica duas matrizes e guarda o resultado em uma matriz resultante*/
void multiplica_matrizes(void)
{
  Matriz matriz_A = {NULL,1,1}, matriz_B = {NULL,1,1}, matriz_Mult = {NULL,1,1};
  ushort i,j,k;
  uchar flag = TRUE;
  while(flag)
    {
      ler_matriz(&matriz_A);/*le valores para linha e coluna e aloca memoria para a matriz*/
      ler_matriz(&matriz_B);/*le valores para linha e coluna e aloca memoria para a matriz*/
      if(matriz_A.col != matriz_B.row)/*verifica se a multiplicaccao e possivel*/
	{
	  printf("\nErro o numero de linhas de colunas de A tem que ser igual ao numero de linhas de B\n");
	  libera_matriz(matriz_A.address, &(matriz_A.row));/*libera a memoria alocada anteriormente*/
	  libera_matriz(matriz_B.address, &(matriz_B.row));/*libera a memoria alocada anteriormente*/
	}
      else
	flag = FALSE;
    }
  preenche_matriz(&matriz_A);/*preenche as entradas da matriz com valores via teclado*/
  preenche_matriz(&matriz_B);/*preenche as entradas da matriz com valores via teclado*/
  matriz_Mult.row = matriz_A.row;
  matriz_Mult.col = matriz_B.col;
  matriz_Mult.address = aloca_matriz(&(matriz_Mult.row),&(matriz_Mult.col));/*aloca memoria para a matriz_Mult*/
  inicializa_matriz(&matriz_Mult);
  for(i = 0; i < matriz_Mult.row; i++)
    for(j = 0; j < matriz_Mult.col; j++)
      for(k = 0; k < matriz_A.col; k++)/*k < matriz_B->row tambem esta correto*/
	*(*(matriz_Mult.address + i) + j) += (*(*(matriz_A.address + i) + k)) * (*(*(matriz_B.address + k) + j));
  imprime_matriz(&matriz_A);
  imprime_matriz(&matriz_B);
  imprime_matriz(&matriz_Mult);
  libera_matriz(matriz_A.address,&(matriz_A.row));
  libera_matriz(matriz_B.address,&(matriz_B.row));
  libera_matriz(matriz_Mult.address,&(matriz_Mult.row));
}
int main( void )
{
  matriz_t *m = matriz_criar( 3, 4 );
  printf("\nmatriz criada com sucesso!\n");
  m = matriz_incluir_valores("1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1", m);
  printf("valores incluidos com sucesso!\n");
  imprime_matriz(m);
  printf("matriz impressa com sucesso!\n"); 
  matriz_t *mt = matriz_obter_transposta(m);
  printf("transposta obtida com sucesso!\n");
  imprime_matriz(mt);
  printf("matriz impressa com sucesso!\n");
  matriz_destruir(m);
  printf("matriz destruida com sucesso!\n");
  exit( EXIT_SUCCESS );
}
Exemple #4
0
int main(int argc, char **argv) {
    
// Verificando quantidade de arquivos na chamada de execução no terminal.
    if (argc != 3) {
        printf("ERROR!\nQuantidade de arquivos diferente do esperado.\n");
    } else {
        Mat *matrizA = NULL;
        Mat *matrizB = NULL;
        Mat *matrizC = NULL;
        
        matrizA = busca_arquivo(matrizA, argv[1]);        
        matrizB = busca_arquivo(matrizB, argv[2]);
	
        matrizC = soma_matriz(matrizA, matrizB);
        
        desaloca_matriz(matrizA);
        desaloca_matriz(matrizB);

	imprime_matriz(matrizC);
        
        desaloca_matriz(matrizC);
    }

    return 0;
}
//----------------------------------------------
// Nome: jogar
// Desc: Realiza os principais comandos do jogo
//----------------------------------------------
int jogar()
{
	ALLEGRO_BITMAP *botao_ok = al_load_bitmap("images/ok button.jpg"); // Cria e carrega arquivo ok button.jpg

	ALLEGRO_BITMAP *botao_start = al_load_bitmap("images/start button.jpg"); // Cria e carrega arquivo start button.jpg

	int **matriz; // Para alocação dinâmica de matrizes deve-se criar um ponteiro para ponteiro

	int tamanho_matriz = (dificuldade * 10); // Variável criada apenas para melhoria do código

	al_clear_to_color(al_map_rgb(255, 255, 255)); // limpa a tela e a pinta toda de branco

	al_draw_bitmap(botao_ok, LARGURA_MAX / 1.12, ALTURA_MAX / 1.07, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair

	al_draw_bitmap(botao_start, LARGURA_MAX / 1.12, ALTURA_MAX / 1.31, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair

	matriz = aloca_matriz(tamanho_matriz); // Chama a função para Alocar a matriz
	
	imprime_matriz(matriz, dificuldade); // Chama a função para desenhar a matriz na tela

	escreve_jogar(matriz); // É esta a função que pede para o usuário entrar com os dados do jogo, assim como atualizar a matriz desenhada

	libera_matriz(matriz, tamanho_matriz); // Chama a função para liberar a memória ocupada pela matriz

	al_destroy_bitmap(botao_ok); // finaliza o BITMAP botao_ok para não ocupar espaço na memória

	al_destroy_bitmap(botao_start); // finaliza o BITMAP botao_ok para não ocupar espaço na memória

	return 0;
}
// impressao em tabela
// * mat = ponteiro para a primeira posicao da matriz
// n = numero de elementos totais na matriz
// m = tamanho de uma coluna
void imprime_matriz(int * mat, int n, int m){
    if (n == 0)
        return;
    imprime_matriz(mat, --n, m);
    if ((n % m) == 0)
        putchar('\n');
    printf("%d ", *(mat+n));
}
Exemple #7
0
int main(void) {
    menu();
    
    inicializa_matriz();
    imprime_matriz();
    
    printf("\n");    
    return 0;
}
int main(int argc, char * argv[]){
     int ** matriz;
     int n, m, i, j, k; 
    if (argc < 2)
    {
        printf("Usage: %s [N] [M] [num1] [num2] ... [num(N*M)]\n", \
                argv[0]);
        return(EXIT_SUCCESS);
    }
   
    n = atoi(argv[1]);
    m = atoi(argv[2]); 
    if (argc != (n*m + 3))
    {
        printf("Usage: %s [N] [M] [num1] [num2] ... [num(N*M)]\n", \
                argv[0]);
        return(EXIT_SUCCESS);
    }

    matriz = (int ** )malloc(sizeof(int *) * n + ((sizeof(int) * m)*n));
    int *data = (int*) (matriz + n);
    printf("Matriz lida: \n");
    for (i=0; i<n; i++){
        matriz[i] = data + i * n;
    }
    k = 0;
    for (i=0; i<m; i++){
        for (j=0; j<n; j++){
            matriz[i][j]= atoi(argv[k+3]);
            k++;
        }
    }
    putchar('\n');
    for (i=0; i<m; i++){
        for (j=0; j<n; j++){
            printf("%d ", matriz[i][j]);
        }
        putchar('\n');
    
    }

    imprime_matriz(&matriz[0][0], n*m, n);
    putchar('\n');
    printf("Soma da matriz: %d \n", soma_matriz(*matriz, n*m));
    putchar('\n');

    printf("Maior da matriz: %d \n", maior_matriz(*matriz, n*m));

    putchar('\n');

    printf("Menor da matriz: %d \n", menor_matriz(*matriz, n*m));

    putchar('\n');
    return 0;
}
/* Execucao */
int main(){
   Elemento **matriz; /* Matriz do jogo */
   int n_linhas, n_colunas, jogada_i, jogada_j, tmp;
   int elementos_revelados=0, total_minas=0, jogadas_validas=0;
   char resultado='i', /* Jogador não ganhou nem perdeu */
        aux;
   
   scanf("%d %d", &n_colunas, &n_linhas);
   
   matriz=aloca_matriz(n_linhas, n_colunas);

   capta(matriz, n_linhas, n_colunas, &total_minas); /* Capta a matriz passada na entrada e conta o total de minas */

   contar_bombas_vizinhas(matriz, n_linhas, n_colunas);

   aux=getchar();
   while(aux!=EOF){ /* Lemos as jogadas validas ate o fim do arquivo */
      ungetc(aux, stdin);

      scanf("%d %d", &jogada_i, &jogada_j);
      tmp = executar_jogada(matriz, n_linhas, n_colunas, jogada_i-1, jogada_j-1);
      if(tmp != -1){ /* Nao executa jogadas iguais */
         jogadas_validas++;
         elementos_revelados = elementos_revelados + tmp; /* Adiciona caracteres revelados na jogada */
         
         if(tmp==0){ /* Jogador perdeu */
            resultado='p';
            elementos_revelados+=1;
            break;
         }
         
         if(elementos_revelados+total_minas == n_linhas*n_colunas){ /* "n_linhas*n_colunas" = total de elementos */
            resultado='v'; /* Jogador ganhou */
            break;
         }
      }
      do{
         aux=getchar();
      } while (aux=='\n');
      
   }
   printf("Minas: %d\n", total_minas);
   printf("Jogadas: %d\n", jogadas_validas);
   printf("Revelados: %d\n", elementos_revelados);
   if(resultado=='v') printf("Resultado: =)\n");
   if(resultado=='p') printf("Resultado: =(\n");
   if(resultado=='i') printf("Resultado: ?\n");
   
   imprime_matriz(matriz, n_linhas, n_colunas, resultado);
   
   libera_matriz(matriz, n_linhas); /* Libera toda memoria alocada */
   
   return 0;
}
int EXECUTA_COMPILADOR(char texto[]){
	int tamanho, resultado, cont_mensagem=0, comando_valido=0;
	char mensagem[TAM][TAM], comando[TAM][TAM];
	executavel programa[TAM];

	//1. Análise Léxica	
    resultado = analise_lexica(texto, comando, mensagem[0]);
	//imprime_string(texto);

	if(resultado == -1){
		tamanho = retorna_tamanho_matriz(mensagem);
		imprime_matriz(mensagem, tamanho);
	}
	else{
		tamanho = retorna_tamanho_matriz(comando);
		imprime_matriz(comando, tamanho);
        //printf("%s\n",comando[0]);
        
		//2. Análise Sintática
        resultado = analise_sintatica(comando, mensagem, &cont_mensagem);
        if(resultado == 0){
            printf("\nComando válido! Parabéns meu!!!\n");
        	comando_valido = 1;
        }
        else{
            printf("\nErro de Compilação!\n");
            tamanho = retorna_tamanho_matriz(mensagem);
			imprime_matriz(mensagem, tamanho);
            comando_valido = 0;
        }
	}

	//3. Análise Semântica
	if(comando_valido)
		analise_semantica(comando, programa);

	return 0;
}
int main(void){
	int n;
	printf("Digite o tamanho da matriz: ");
	scanf("%d",&n);
	int **m = cria_matriz(n);
	le_matriz(m,n);
	imprime_matriz(m,n);
	exercicio_a(m,n,3);
	exercicio_b(m,n);
	exercicio_c(m,n,3);
	exercicio_c(m,n,1);
	exercicio_d(m,n);	
	return 0;
}
Exemple #12
0
int main() {
	int m[MAXLINHA][MAXCOLUNA], linhas, colunas, maiorValor;
	int c_m[MAXLINHA][MAXCOLUNA], c_linhas, c_colunas, c_maiorValor;
	char nome_arquivo[MAX_NAME], c_nome_arquivo[MAX_NAME], complemento[MAX_NAME], menu = '9';
	int a, b, c, d, t = 0, index_char;

	printf("Digite o nome do arquivo de entrada: ");
	scanf("%s", nome_arquivo);

	while (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 0) {
		printf("Digite o nome do arquivo de entrada: ");
		scanf("%s", nome_arquivo);
	}

	printf("Arquivo %s.pgm carregado com sucesso.\n", nome_arquivo);
	imprime_menu();


	while(menu != 's') {
		if (menu == 'c') {
			printf("Digite o nome do arquivo de entrada: ");
			scanf("%s", nome_arquivo);

			if (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 1) {
				t = 0;

				printf("Arquivo %s.pgm carregado com sucesso.\n\n", nome_arquivo);

			} else return 0;


		} else if (menu == 'a') {
			imprime_menu();
		

		} else if (menu == 't') {
			imprime_matriz(m, linhas, colunas);


		} else if (menu == 'n') {
			negativo(m, linhas, colunas);
			complemento[t++] = 'n';
			printf("Operacao realizada com sucesso.\n");

		} else if (menu == 'r') {
			rotacao(m, &linhas, &colunas);
			complemento[t++] = 'r';
			printf("Operacao realizada com sucesso.\n");

		} else if (menu == 'v') {
			rebatimentoVertical(m, linhas, colunas);
			complemento[t++] = 'v';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'h') {
			rebatimentoHorizontal(m, linhas, colunas);
			complemento[t++] = 'h';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'x') {
			printf("Informe x superior: ");
			scanf("%d", &a);

			printf("Informe y superior: ");
			scanf("%d", &b);

			printf("Informe x inferior: ");
			scanf("%d", &c);

			printf("Informe y inferior: ");
			scanf("%d", &d);

			if (a < 0 || b < 0 || c > (linhas - 1) || d > (colunas - 1) || a > c || b > d) {
				printf("Limites invalidos\n\n");

			} else {
				corte(m, &linhas, &colunas, a, b, c, d);
				complemento[t++] = 'x';
				printf("Operacao realizada com sucesso.\n");

			}



		} else if (menu == 'e') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroErosao(m, linhas, colunas, a);
			complemento[t++] = 'e';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'd') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroDilatacao(m, linhas, colunas, a);
			complemento[t++] = 'd';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'm') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroMediana(m, linhas, colunas, a);
			complemento[t++] = 'm';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'z') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			filtroMedia(m, linhas, colunas, a);
			complemento[t++] = 'z';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '1') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda1(m, linhas, colunas, a, b);
			complemento[t++] = '1';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '2') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda2(m, linhas, colunas, a, b);
			complemento[t++] = '2';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == '3') {
			printf("Digite o tamanho da janela: ");
			scanf("%d", &a);

			while(a < 3 || a > 50) {
				printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
				printf("Digite o tamanho da janela: ");
				scanf("%d", &a);
			}

			printf("Informe o valor de k: ");
			scanf("%d", &b);

			filtroBorda3(m, linhas, colunas, a, b);
			complemento[t++] = '3';
			printf("Operacao realizada com sucesso.\n");


		} else if (menu == 'g') {
			for(index_char = 0; nome_arquivo[index_char] != 0; index_char++) {
				c_nome_arquivo[index_char] = nome_arquivo[index_char];
			}

			if (t > 0)
				c_nome_arquivo[index_char++] = '-';

			for(a = 0; a < t; a++)
				c_nome_arquivo[index_char++] = complemento[a];

			while(c_nome_arquivo[index_char] != 0)
				c_nome_arquivo[index_char++] = 0;

			grava_pgm(c_nome_arquivo, m, linhas, colunas, maiorValor);
			printf("%s.pgm\nArquivo %s.pgm gravado com sucesso.\n", c_nome_arquivo, c_nome_arquivo);


		} else if (menu == 'C') {
			printf("Digite o nome do arquivo para comparacao: \n");
			scanf("%s", c_nome_arquivo);

			if (le_pgm(c_nome_arquivo, c_m, &c_linhas, &c_colunas, &c_maiorValor) == 1) {
				if (c_linhas != linhas || c_colunas != colunas) {
					printf("As matrizes tem dimensoes diferentes.\n");

				} else {
					/* Compara valor a valor e verifica se é igual ou diferente */
					c = 1;
					for(a = 0; a < linhas; a++) {
						for(b = 0; b < colunas; b++) {
							if (m[a][b] != c_m[a][b]) {
								c = 0;
								break;
							}
						}

						if (c == 0) break;
					}

					if (c == 0) printf("As matrizes tem dimensoes diferentes.\n");
					else printf("As matrizes sao iguais.\n");
				}

			} else {
				printf("Falha ao carregar arquivo %s.pgm de comparacao.\n", c_nome_arquivo);

			}

			
		} else if (menu != '9') {
			printf("Comando invalido\n");

		}

		printf("Digite um comando: ");
		scanf(" %c", &menu);
	}

	

	return 0;
}
Exemple #13
0
void adiciona_voo_aux(int test) {
	int validade_1_id = 0, validade_2_id = 0, existe_1_id = 0, existe_2_id = 0, ocupacao_1_id = 0, ocupacao_2_id, k = 0, v = 0;
	char i[4] = "\0", j[4] = "\0";
	validade_1_id = le_id(i);
	validade_2_id = le_id2(j);
	if(validade_1_id == 0 && validade_2_id == 0){
		existe_1_id = verifica_id(i);
		existe_2_id = verifica_id(j);
		if(existe_1_id == 0 && existe_2_id == 0){
			ocupacao_1_id = ocupacao_aeroporto(i);
			ocupacao_2_id = ocupacao_aeroporto(j);
			for(k = 0; k < contador_aeroportos; k++){
				for(v = 0; v < contador_aeroportos; v++){ 
					if((strcmp(airport[k].id, i) == 0) && (strcmp(airport[v].id, j) == 0) ){
						if(airport[k].state == 1 || airport[v].state == 1){
							if(test == 3){
								if((ocupacao_1_id + 2 <= airport[k].capacity) && (ocupacao_2_id + 2 <= airport[v].capacity)){
									matriz[k][v] += 1;
									matriz[v][k] += 1;
								}
								else{
									erro_auxiliar(test,i,j);
								}
								break;		
							}		
							if(test == 2){
								if((ocupacao_1_id + 1 <= airport[k].capacity) && (ocupacao_2_id + 1 <= airport[v].capacity)){
									matriz[k][v] += 1;
								}
								else{
									erro_auxiliar(test,i,j);
								}	
								break;
							}
							if(test == 1){
								if(matriz[k][v] > 0){ 
									matriz[k][v] -= 1;
								}
								else{
									erro_auxiliar(test,i,j);
								}	
								break;
							}	
							if(test == 0){
								if((matriz[k][v] > 0) && (matriz[v][k])){
									matriz[k][v] -= 1;
									matriz[v][k] -= 1;
								}
								else{
									erro_auxiliar(test,i,j);
								}
								break;
							}
							break; 
						}	
						else{
							erro_auxiliar(test,i,j);
						}	
					}/*este if nao falha, apenas está aqui para "salvar" os indices*/	
				}/*END OF FOR*/
			}/*END OF FOR*/
		}
	}else{
		erro_auxiliar(test,i,j);
	}/*
	    }else{
	    erro_auxiliar(test,i,j);
	    }	este else não faz parte das veriicaçoes obrigatorias*/
#if DEBUG
imprime_matriz();
#endif
}		
//----------------------------------------------
// Nome: escreve_jogar
// Desc: Esta função pede ao usuário as posições de tudo que é necessário para a execução do jogo
//----------------------------------------------
void escreve_jogar(int **matriz)
{
	// Esse vetor de (char *) foi criado para diminuir a quantidade de código (basicamente: if) da função. O vetor depende da dificuldade 
	char *texto_inicial[5] = {"A dificuldade 1 consiste em escolher:",
							  "A dificuldade 2 consiste em escolher:",
							  "A dificuldade 3 consiste em escolher:",
							  "A dificuldade 4 consiste em escolher:",
							  "A dificuldade 5 consiste em escolher:"};

	// Esse vetor de (char *) foi criado para diminuir a quantidade de código (basicamente: if) da função. O vetor depende da dificuldade 
	char *bonus = {"> O Bonus"};

	ALLEGRO_FONT *fonte_jogar = al_load_font("fonts/AGENCYB.TTF", 14, 0); // Carrega o arquivo de fonte

	bool parar_obstaculos = false;

	// A seguinte variável foi criada para facilitar a leitura do código do programa
	int tamanho_matriz = dificuldade * 10;

	//
	// As seguintes variáveis foram criadas para converter as coordenadas do mouse e armazenar as  nas células da matriz
	//
	int pos_x;

	int pos_y;

	int linha_inicial;

	int coluna_inicial;

	int linha_final;

	int coluna_final;

	int linha_alvo;

	int coluna_alvo;

	int linha_obstaculo;

	int coluna_obstaculo;

	int linha_bonus;

	int coluna_bonus;

	int custo_total;

	int custo_aux;

	int custo_aux2;
	//
	// Fim da declaração das variáveis
	//

	al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), LARGURA_MAX / 2, 310, ALLEGRO_ALIGN_CENTRE, texto_inicial[dificuldade - 1]); // Escreve o texto central

	//
	// As seguintes funções escrevem no espaço determinado o que tem que ser escolhido pelo usuário
	//
	al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 20, 340, NULL, "> A Posicao Inicial");

	al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 20, 375, NULL, "> A Posicao Final");

	al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 250, 340, NULL, "> Obstaculo (ENTER para cancelar)");

	al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 250, 375, NULL, bonus);
	//
	// Fim das funções  que escrevem as escolhas necessárias
	//

	al_flip_display(); // Atualiza a tela
	
	// Caso a opção de existir labirinto seja verdadeira
	if (labirinto == true)
	{
		matriz = carrega_labirinto(dificuldade); // Chama a função responsável por gerar, aleatoriamente, um labirinto perfeito 

		imprime_matriz(matriz, dificuldade); // Imprime o labirinto no espaço reservado

		al_flip_display(); // Atualiza tela
	}

	//
	// ----------------------------------------------------------------------------------------
	//  O seguinte do while é utilizado para que o usuário entre com a posição inicial do jogo
	// ----------------------------------------------------------------------------------------
	//

	// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição inicial válida
	do
	{
		pos_x = 0; // Zera a variável

		pos_y = 0; // Zera a variável

		al_draw_text(fonte_jogar, al_map_rgb(255, 0, 0), 20, 340, NULL, "> A Posicao Inicial"); // Pinta o texto para melhor visualização

		al_flip_display(); // Atualiza a tela

		inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

		if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
		{
			if (ev.mouse.button & 1)
			{
				// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
				pos_x = pos_x_mouse;

				pos_y = pos_y_mouse;

				if (pos_y <= 300)
				{
					coluna_inicial = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna

					// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
					if (dificuldade == 4)
						linha_inicial = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha

					else
						linha_inicial = (pos_y * tamanho_matriz ) / 300; // Converte a coordenada do mouse em linha

					// Determina a posição inicial e atualiza a matriz
					if (matriz[linha_inicial][coluna_inicial] != PAREDE)
					{
						matriz[linha_inicial][coluna_inicial] = POS_INICIAL;

						imprime_matriz(matriz, dificuldade);
					}
				}
			}
		}
	} while ( (pos_y >= 300) || (pos_y == 0) || (matriz[linha_inicial][coluna_inicial] == PAREDE) );

	//
	// --------------------------------------------------------------------------------------
	//  O seguinte do while é utilizado para que o usuário entre com a posição final do jogo
	// --------------------------------------------------------------------------------------
	//

	// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição final válida
	do
	{
		pos_x = 0; // Zera variável

		pos_y = 0; // Zera variável

		al_draw_text(fonte_jogar, al_map_rgb(0, 0, 255), 20, 375, NULL, "> A Posicao Final"); // Pinta o texto para melhor visualização

		al_flip_display(); // Atualiza tela

		inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

		if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
		{
			if (ev.mouse.button & 1)
			{
				// quando o usuário clicar com o borão esquerdo do mouse as coordenadas serão armazenadas em variáveis
				pos_x = pos_x_mouse;

				pos_y = pos_y_mouse;

				if (pos_y <= 300)
				{
					coluna_final = (pos_x * tamanho_matriz ) / 600; // Converte a coordenada do mouse em coluna

					// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
					if (dificuldade == 4)
						linha_final = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha

					else
						linha_final = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha

					// Determina a posição final e atualiza a matriz
					if ( ( (linha_final != linha_inicial) || (coluna_final != coluna_inicial) ) && (matriz[linha_final][coluna_final] != PAREDE) )
					{
						matriz[linha_final][coluna_final] = POS_FINAL;

						imprime_matriz(matriz, dificuldade);
					}
				}
			}
		}
	} while ( (pos_y >= 300) || (pos_y == 0) || ( (linha_final == linha_inicial) && (coluna_final == coluna_inicial) ) || (matriz[linha_final][coluna_final] == PAREDE) );

		//
	// ----------------------------------------------------------------------------------------
	//  O seguinte do while é utilizado para que o usuário entre com a posição do alvo do jogo
	// ----------------------------------------------------------------------------------------
	//

	// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição válida
	do
	{
		pos_x = 0; // Zera variável

		pos_y = 0; // Zera variável

		//*******al_draw_text(fonte_jogar, al_map_rgb(0, 0, 255), 20, 375, NULL, "> A Posicao Final"); // Pinta o texto para melhor visualização

		al_flip_display(); // Atualiza tela

		inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

		if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
		{
			if (ev.mouse.button & 1)
			{
				// quando o usuário clicar com o borão esquerdo do mouse as coordenadas serão armazenadas em variáveis
				pos_x = pos_x_mouse;

				pos_y = pos_y_mouse;

				if (pos_y <= 300)
				{
					coluna_alvo = (pos_x * tamanho_matriz ) / 600; // Converte a coordenada do mouse em coluna

					// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
					if (dificuldade == 4)
						linha_alvo = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha

					else
						linha_alvo = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha

					// Determina a posição do alvo e atualiza a matriz
					if ( ( (linha_alvo != linha_inicial) || (coluna_alvo != coluna_inicial) ) || ( (linha_alvo != linha_final) || (coluna_alvo != coluna_final) ) && (matriz[linha_alvo][coluna_alvo] != PAREDE) )
					{
						matriz[linha_alvo][coluna_alvo] = ALVO;

						imprime_matriz(matriz, dificuldade);
					}
				}
			}
		}
	} while ( (pos_y >= 300) || (pos_y == 0) || ( (linha_alvo == linha_inicial) && (coluna_alvo == coluna_inicial) ) || ( (linha_alvo == linha_final) && (coluna_alvo == coluna_final) ) || (matriz[linha_alvo][coluna_alvo] == PAREDE) );

	//
	// ------------------------------------------------------------------------------------------
	//  O seguinte for é utilizado para que o usuário entre com a posição dos obstáculos do jogo
	// ------------------------------------------------------------------------------------------
	//

	// O seguinte bloco de comando será executado até que o usuário digite ENTER (para cancelar a entrada de obstáculos)
	do
	{
		pos_x = 0; // Zera variável

		pos_y = 0; // Zera variável

		al_draw_text(fonte_jogar, al_map_rgb(255, 165, 0), 250, 340, NULL, "> Obstaculo (ENTER para cancelar)"); // Pinta o texto para melhor visualização

		al_flip_display(); // Atualiza tela

		// O seguinte bloco de comando só será executado caso a opção obstaculo esteja habilitada
		if (obstaculo == true)
		{
			// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição válida para o obstáculo
			do
			{
				inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

				// O seguinte bloco de comando será executado caso o usuário entre com a tecla ENTER
				if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
				{
					switch(ev.keyboard.keycode)
					{
					case ALLEGRO_KEY_ENTER:
						parar_obstaculos = true;

						break;
					}

					// O seguinte break é necessário para que, ao apertar a tecla ENTER, o usuário não precise entrar com mais um obstáculo
					break;
				}

				if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
				{
					if (ev.mouse.button & 1)
					{
						// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
						pos_x = pos_x_mouse;

						pos_y = pos_y_mouse;
					}

					if (pos_y <= 300)
					{
						coluna_obstaculo = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna

						// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
						if (dificuldade == 4)
							linha_obstaculo = (pos_y * tamanho_matriz) / 280; // Converte a coordenada do mouse em linha

						else
							linha_obstaculo = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha

						// Determina a posição dos obstáculos e atualiza a matriz
						if ( ( ( (linha_obstaculo != linha_inicial) || (coluna_obstaculo != coluna_inicial) ) && ( (linha_obstaculo != linha_final) || (coluna_obstaculo != coluna_final) ) && ( (linha_obstaculo != linha_alvo) || (coluna_obstaculo != coluna_alvo) ) ) && (matriz[linha_obstaculo][coluna_obstaculo] != PAREDE) )
						{
							if (matriz[linha_obstaculo][coluna_obstaculo] != OBSTACULO)
								matriz[linha_obstaculo][coluna_obstaculo] = OBSTACULO;

							else if (matriz[linha_obstaculo][coluna_obstaculo] == OBSTACULO)
								matriz[linha_obstaculo][coluna_obstaculo] = CAMPO_VAZIO;

							imprime_matriz(matriz, dificuldade);
						}
					}
				}
			} while( (pos_y >= 300) || (pos_y == 0) || ( (linha_obstaculo == linha_inicial) && (coluna_obstaculo == coluna_inicial) ) || ( (linha_obstaculo == linha_final) && (coluna_obstaculo == coluna_final) ) || (matriz[linha_obstaculo][coluna_obstaculo] == PAREDE) );
		}
		
		// Sai do bloco de comandos caso a opção obstaculo esteja desabilitada
		else
			break;

	} while (parar_obstaculos == false);

	//
	// -------------------------------------------------------------------------------------
	//  O seguinte for é utilizado para que o usuário entre com a posição dos bônus do jogo
	// -------------------------------------------------------------------------------------
	//

	
	// O seguinte bloco de comando será executado até que o usuário entre com o número correto de bônus
	do
	{
		pos_x = 0; // Zera variável

		pos_y = 0; // Zera variável

		al_draw_text(fonte_jogar, al_map_rgb(0, 186, 255), 250, 375, NULL, bonus); // Pinta o texto para melhor visualização

		al_flip_display(); // Atualiza tela

		inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

		if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
		{
			if (ev.mouse.button & 1)
			{
				// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
				pos_x = pos_x_mouse;

				pos_y = pos_y_mouse;
			}

			if (pos_y <= 300)
			{
				coluna_bonus = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna

				// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
				if (dificuldade == 4)
					linha_bonus = (pos_y * tamanho_matriz) / 280; // Converte a coordenada do mouse em linha

				else
					linha_bonus = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha

				// Determina a posição dos bônus e atualiza a matriz
				if ( ( ( ( (linha_bonus != linha_inicial) || (coluna_bonus != coluna_inicial) ) && ( (linha_bonus != linha_final) || (coluna_bonus != coluna_final) ) && ( (linha_bonus != linha_alvo) || (coluna_bonus != coluna_alvo) ) ) && (matriz[linha_bonus][coluna_bonus] != PAREDE) ) )
				{
					matriz[linha_bonus][coluna_bonus] = BONUS;

					imprime_matriz(matriz, dificuldade);
				}
			}
		}
	} while( (pos_y >= 300) || (pos_y == 0) || ( (linha_bonus == linha_inicial) && (coluna_bonus == coluna_inicial) ) || ( (linha_bonus == linha_final) && (coluna_bonus == coluna_final) ) || ( (linha_bonus == linha_alvo) && (coluna_bonus == coluna_alvo) ) || ( (matriz[linha_bonus][coluna_bonus] == PAREDE) ) );

	// O próximo bloco de comandos será realizado até que a variável fechar seja igual a true
	do
	{
		al_flip_display(); // Atualiza a tela

		inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código

		if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Quando o usuário apertar algum botão do mouse
		{
			if((ev.mouse.button & 1) && (pos_x_mouse >= 536) && (pos_x_mouse <= 595) && (pos_y_mouse >= 374) && (pos_y_mouse <= 393))
				break; // Volta para o menu principal Caso seja selecionado o botão "VOLTAR"
			
			else if((ev.mouse.button & 1) && (pos_x_mouse >= 536) && (pos_x_mouse <= 595) && (pos_y_mouse >= 306) && (pos_y_mouse <= 325))
			{
				custo_total = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_final, coluna_final, false); // Caso seja selecionado o botão "INICIAR"
				custo_aux = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_bonus, coluna_bonus, false) + procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_final, coluna_final, false) - (BONUS * 10 * dificuldade);
				custo_aux2 = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_bonus, coluna_bonus, false) + procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_final, coluna_final, false) - (BONUS * 10 * dificuldade);
			}
		
			if ( (custo_total <= custo_aux) && (custo_total <= custo_aux2) )
			{
				procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_inicial, coluna_inicial, true);
				procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_alvo, coluna_alvo, true);
			}

			else if ( (custo_aux <= custo_total) && (custo_aux <= custo_aux2) )
			{
				procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_inicial, coluna_inicial, true);
				procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_alvo, coluna_alvo, true);
				procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_bonus, coluna_bonus, true);
			}

			else
			{
				procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_inicial, coluna_inicial, true);
				procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_bonus, coluna_bonus, true);
				procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_alvo, coluna_alvo, true);
			}
		}
	} while(!fechar);

	al_destroy_font(fonte_jogar); // Finaliza a fonte
}
int main()
  {
    char acao;
    num_matriz k, k1, k2, k3;
    int m, n, i, j;
    float x;
    matriz a[num_nomes];

    while (true)
      { 
        scanf("%c", &acao);
        printf("ação: %c", acao);
        switch (acao)
          { 
            case 'r': 
              le_nome(&k); prox_linha();
              printf(" %c\n", min_nome+k);
              le_matriz(&a[k]);
              break;
            case 'z': 
              le_nome(&k); scanf("%d %d", &m, &n); prox_linha();
              printf(" %c %d %d\n", min_nome+k, m, n);
              inicializa(&a[k], m, n);
              break;
            case 'v': 
              le_nome(&k); scanf("%d %d", &i, &j); prox_linha();
              printf(" %c %d %d\n", min_nome+k, i, j);
              printf("  %c[%d,%d] = %8.2f\n", min_nome+k, i, j, valor(&(a[k]), i, j));
              break;
            case 'a':
              le_nome(&k); scanf("%d %d %f", &i, &j, &x); prox_linha();
              printf(" %c %2d %2d %8.2f\n", min_nome+k, i, j, x);
              atribui(&a[k], i, j, x);
              break;
            case 's':
              le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
              printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
              soma(&a[k1], &a[k2], &a[k3]);
              break;
            case 'm':
              le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
              printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
              multiplica(&a[k1], &a[k2], &a[k3]);
              break;
            case 't':
              le_nome(&k1); le_nome(&k2); prox_linha();
              printf(" %c %c\n", min_nome+k1, min_nome+k2);
              transpoe(&a[k1], &a[k2]);
              break;
            case 'w':
              le_nome(&k); prox_linha();
              printf(" %c\n", min_nome+k);
              imprime_matriz(&a[k]);
              break;
            case 'x':
              printf("\n");
	      bapply(bprint);
              printf("fim da execução.\n");
              exit(0);
              break;
            case '#':
              { int c;
                do 
                  { c = getchar(); putchar(c); } 
                while ((c != '\n') && (c != EOF));
              }
              break;
  	   case 'l':
	     le_nome(&k); prox_linha();
             printf(" %c\n", min_nome+k);
             libera(&a[k]);
             break;
            default:
              { erro("ação inválida"); }
          } /* switch */
      } /* while */

   bapply(bprint);

   return 0;
  } /* main */