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


Link para compartilhar na Internet ou com seus amigos:

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 índice

Quantidade 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 
Cada número da série é a soma dos dois números anteriores. A linha de baixo reflete o índice do número. Assim, quando falamos "O quinto número de Fibonacci", nós estamos nos referindo ao índice 4, ou seja, o valor 3.

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
}
Sua saída deverá ser parecida com:
Informe o índice: 6
O número de Fibonacci no índice informado é: 8

Resposta/Solução:

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 public

Quantidade 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 iniciantes

Quantidade 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

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
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
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
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
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 77 usuários muito felizes estudando em nosso site.