Você está aqui: C++ ::: C++ para Engenharia ::: Geometria Analítica e Álgebra Linear |
Como calcular o determinante de uma matriz usando o Teorema de Laplace em C++Quantidade de visualizações: 551 vezes |
Como já vimos em dicas anteriores, o determinante de uma matriz de ordem 3 (três linhas e três colunas) pode ser obtido por meio da Regra de Sarrus. No entanto, quando temos matrizes de ordem 4 ou superior, a regra mais comumente aplicada é o Método dos Cofatores, ou Regra de Laplace. O Método dos Cofatores, ou Expansão de Cofatores, ou ainda Determinante por Laplace, foi um método para o cálculo de determinantes inventado por Pierre Laplace. Nesta dica mostrarei um código C++ completo para calcular o determinante de uma matriz de ordem 3 usando expansão de cofatores. Note que a função calcularDeterminante() é uma função recursiva cujo caso base é a redução da matriz original em apenas uma linha e uma coluna. Veja o código completo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <string> #include <iostream> #include <iomanip> // vamos definir a ordem da matriz #define ORDEM 3 // 3 linhas e 3 colunas using namespace std; // protótipo das funções int calcular_determinante(int matriz[ORDEM][ORDEM], int ordem); void calcular_cofator(int mat[ORDEM][ORDEM], int temp[ORDEM][ORDEM], int p, int q, int ordem); int main(int argc, char *argv[]){ // variáveis auxiliares int i, j, determinante; // e agora criamos a matriz. Podemos definir os elementos // diretamente ou pedir para o usuário informar os valores int matriz[ORDEM][ORDEM] = {{1, 3, 0}, {0, 2, 5}, {2, 4, 4}}; // mostramos a matriz completa cout << "A matriz e:\n\n"; for (i = 0; i < ORDEM; i++) { for (j = 0; j < ORDEM; j++){ cout << setw(5) << matriz[i][j]; } cout << "\n"; } // vamos calcular o determinante usando o Teorema de Laplace determinante = calcular_determinante(matriz, ORDEM); // e mostramos o resultado cout << "\nO determinante da matriz e: " << determinante << endl; cout << "\n" << endl; system("PAUSE"); // pausa o programa return EXIT_SUCCESS; } // função recursiva que encontra e retorna o determinante de uma // matriz de qualquer ordem int calcular_determinante(int matriz[ORDEM][ORDEM], int ordem){ int determinante = 0; // para guardar e retornar o determinante // matriz de cofatores int cofatores[ORDEM][ORDEM]; // para guardar o sinal de multiplicação int sinal = 1; // variáveis auxiliares nesta função int f; // caso base da recursividade: // se a matriz possuir apenas um elemento, retorna ele if (ordem == 1){ return matriz[0][0]; } // vamos percorrer cada um dos elementos da primeira linha for (f = 0; f < ordem; f++) { // vamos obter o cofator de matriz[0][f] calcular_cofator(matriz, cofatores, 0, f, ordem); determinante = determinante + (sinal * matriz[0][f] * calcular_determinante(cofatores, ordem - 1)); // alterna o sinal sinal = -sinal; } // retorna o determinante return determinante; } // função para retornar o cofator de mat[p][q] em temp[][] // ordem é a ordem atual da matriz mat[][] void calcular_cofator(int mat[ORDEM][ORDEM], int temp[ORDEM][ORDEM], int p, int q, int ordem){ // nos parâmetros, p indica linha e q indica coluna // variáveis auxiliares int i = 0, j = 0; // percorre cada um dos elementos da matriz recebida for (int linha = 0; linha < ordem; linha++) { // percorre as colunas for (int coluna = 0; coluna < ordem; coluna++) { // copia para a matriz temporária apenas os // elementos que não se encaixam na linha // e coluna informadas if (linha != p && coluna != q) { temp[i][j++] = mat[linha][coluna]; // preenchemos a linha. Hora de aumentar // o índice da linha e resetar o índice // da coluna if (j == ordem - 1) { j = 0; i++; } } } } } Ao executar este código C++ nós teremos o seguinte resultado: A matriz é: 1 3 0 0 2 5 2 4 4 O determinante da matriz é: 18 |
![]() |
C++ ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade) |
Exercício Resolvido de C++ - Um método recursivo que calcula o número de Fibonacci para um dado índiceQuantidade de visualizações: 655 vezes |
Pergunta/Tarefa: Observe a série de números Fibonacci abaixo: Série: 0 1 1 2 3 5 8 13 21 34 55 89 Índice: 0 1 2 3 4 5 6 7 8 9 10 11 Este algoritmo consiste em, dado um determinado índice, retornar o número de Fibonacci correspondente. Recursivamente, o cálculo pode ser feito da seguinte forma: fib(0) = 0; fib(1) = 1; fib(indice) = fib(indice - 2) + fib(indice - 1); sendo o indice >= 2 Os casos nos quais os índices são 0 ou 1 são os casos bases (aqueles que indicam que a recursividade deve parar). Seu método deverá possuir a seguinte assinatura: int fibonacci(int indice){ // sua implementação aqui } Informe o índice: 6 O número de Fibonacci no índice informado é: 8 Veja a resolução comentada deste exercício usando C++: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <string> #include <iostream> using namespace std; // assinatura da função recursiva int fibonacci(int indice); int main(int argc, char *argv[]){ // variáveis usadas na resolução do problema int indice; // vamos solicitar o índice do número de Fibonacci cout << "Informe o índice: "; // lê o índice cin >> indice; // calcula o número de Fibonacci no índice informado cout << "O número de Fibonacci no índice informado é: " << fibonacci(indice) << endl; system("PAUSE"); // pausa o programa return EXIT_SUCCESS; } // função recursiva que o número de Fibonacci em um determinado índice int fibonacci(int indice){ if(indice == 0){ // caso base; interrompe a recursividade return 0; } else if(indice == 1){ // caso base; interrompe a recursividade return 1; } else{ // efetua uma nova chamada recursiva return fibonacci(indice - 1) + fibonacci(indice - 2); } } |
C++ ::: Dicas & Truques ::: Programação Orientada a Objetos |
Programação Orientada a Objetos em C++ - Como controlar o acesso a membros de uma classe C++ usando o modificar publicQuantidade de visualizações: 8171 vezes |
Membros de uma classe são suas funções e variáveis. A visibilidade de tais membros pode ser controlada, ou seja, algumas funções e variáveis podem ser ocultadas do mundo externo. Este é o princípio de encapsulamento da programação orientada a objetos. O modificador public define que os membros de uma classe estarão acessíveis a qualquer função fora da classe. Veja um exemplo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <iostream> using namespace std; class Cliente{ public: char *nome; }; int main(int argc, char *argv[]) { // Cria uma instância da classe Cliente Cliente *cliente = new Cliente(); // Define o nome do cliente cliente->nome = "Osmar J. Silva"; // Obtém o nome do cliente cout << "Nome do cliente: " << cliente->nome << "\n\n"; system("PAUSE"); return EXIT_SUCCESS; } Como o atributo nome foi declarado na seção public, o código da função main possui acesso a ele sem a necessidade de métodos acessórios (get) ou mutatórios (set). Quando usamos o modificador public antes do nome de uma classe base (durante a herança), estamos definindo que os membros public e protected da classe base serão public e protected na classe derivada. O acesso padrão (sem modificador) dos membros de uma classe é private. Em uniões (union) e estruturas (structure), o acesso padrão é public. O acesso padrão de uma classe base (durante a herança) é private para classes e public para estruturas. Uniões não podem possuir classes bases. |
C++ ::: Fundamentos da Linguagem ::: Estruturas de Controle |
Como usar o laço do...while da linguagem C++ - Apostila C++ para iniciantesQuantidade de visualizações: 24546 vezes |
O laço do..while é usado quando queremos executar um bloco de códigos repetidamente ENQUANTO uma condição for satisfeita. Porém, ao contrário do laço while, o laço do..while é sempre executado no mínimo uma vez, visto que a condição é testada antes da segunda interação, ou seja, o teste só ocorre no final da interação atual. Veja:---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- do{ bloco de instruções }while(condição); Veja um exemplo de um laço do..while que conta de 10 à 0: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <string> #include <iostream> using namespace std; int main(int argc, char *argv[]){ // um laço do..while que conta de // 10 até 0 int valor = 10; do{ cout << valor << "\n"; valor--; }while(valor >= 0); cout << "\n\n"; system("PAUSE"); // pausa o programa return EXIT_SUCCESS; } |
Desafios, Exercícios e Algoritmos Resolvidos de C++ |
Veja mais Dicas e truques de C++ |
Dicas e truques de outras linguagens |
Códigos Fonte |
![]() Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
![]() Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
1º lugar: Java |