Example #1
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));
}
Example #2
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;
}
/* 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;
}
Example #4
0
/*Ler as linhas e colunas uma Matriz via teclado e aloca memoria para a mesma*/
void ler_matriz(Matriz *matriz)
{
   uchar flag = TRUE;
   while(flag)
   {
      printf("Entre com os valores da linha e coluna da Matriz.: ");
      scanf("%hu %hu",&(matriz->row),&(matriz->col));
      if( (matriz->row < 1) || (matriz->col < 1) )
	 printf("Erro as linhas e colunas de uma Matriz sao numeros naturais\n");
      else
	 flag = FALSE;
   }
   matriz->address = aloca_matriz(&(matriz->row),&(matriz->col));/*aloca memoria para a Matriz*/
}
Example #5
0
int main(int argc, char *argv[]) {
	// Declara as variáveis
	char * inputFileName = argv[1];
	char * outputFileName = argv[2];
	int ** matrizA, ** matrizB, ** matrizResult;
	int numInstancias, numLinhasA, numLinhasB, numLinhasResult, numColunasA, numColunasB, numColunasResult, i, j, k, l, m;

	// Abrir arquivo de entrada
	FILE * inputFileOpen;
	if ((inputFileOpen = fopen(inputFileName, "r")) == NULL) {
		printf("Nao foi possivel abrir o arquivo.\n");
	} else {
		printf("Aberto arquivo de entrada %s \n", inputFileName);
	}

	// Abrir arquivo de saída
	FILE * outputFileOpen;
	if ((outputFileOpen = fopen(outputFileName, "w")) == NULL) {
		printf("Nao foi possivel abrir o arquivo.\n");
	} else {
		printf("Aberto arquivo de entrada %s \n", outputFileName);
	}

	// Lê o número de instâncias
	fscanf(inputFileOpen, "%d", &numInstancias);
	// Escreve o número de instâncias no arquivo de saída
	fprintf(outputFileOpen, "%d\n", numInstancias);

	for(m = 0; m < numInstancias; m++) {
		// Lê linhas e colunas da matriz A
		fscanf(inputFileOpen, "%d", &numLinhasA);
		fscanf(inputFileOpen, "%d", &numColunasA);	

		// Preenche a matriz A
		matrizA = preenche_matriz(inputFileOpen, numLinhasA, numColunasA);

		// Lê linhas e colunas da matriz B
		fscanf(inputFileOpen, "%d", &numLinhasB);
		fscanf(inputFileOpen, "%d", &numColunasB);

		// Preenche a matriz B
		matrizB = preenche_matriz(inputFileOpen, numLinhasB, numColunasB);

		// Seta linhas e colunas da matriz resultante
		numLinhasResult = numLinhasA * numLinhasB;
		numColunasResult = numColunasA * numColunasB;

		// Aloca a matriz resultante
		matrizResult = aloca_matriz(numLinhasResult, numColunasResult);

		// Preenche a matriz resultante (Produto de Kronecker)
		for (i = 0; i < numLinhasA; ++i) {
			for (j = 0; j < numColunasA; ++j) {
				for (k = 0; k < numLinhasB; ++k) {
					for (l = 0; l < numColunasB; ++l) {
						matrizResult[i * numLinhasB + k][j * numColunasB + l] = matrizA[i][j] * matrizB[k][l];
					}
				}
			}
		}

		// Libera as matrizes já utilizadas
		desaloca_matriz(matrizA, numLinhasA);
		desaloca_matriz(matrizB, numLinhasB);
		
		// Escreve o número de linhas e colunas no arquivo de saída
		fprintf(outputFileOpen, "%d ", numLinhasResult);
		fprintf(outputFileOpen, "%d\n", numColunasResult);

		// Escreve a matriz resultante no arquivo de saída
		for(i = 0; i < numLinhasResult; i++) {
			for(j = 0; j < numColunasResult; j++) {
				fprintf(outputFileOpen,"%d ", matrizResult[i][j]);
			}
			fprintf(outputFileOpen, "\n");
		}

		// Libera a matriz resultante
		desaloca_matriz(matrizResult, numLinhasResult);
	}

	// Retorna 0 se conseguiu fechar o arquivo com sucesso
	if(fclose(inputFileOpen) == 0) {
		printf("%s fechado com sucesso\n", inputFileName);
	}

	if(fclose(outputFileOpen) == 0) {
		printf("%s fechado com sucesso\n", outputFileName);
	}

	return 0;
}