----------------------------------------------------------------------
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++;
        }
      }
    }
  }
}

A matriz é:

    1    3    0
    0    2    5
    2    4    4

O determinante da matriz é: 18

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>
#include <algorithm>
#include <time.h>

using namespace std;

int main(int argc, char *argv[]){
  // vamos iniciar o gerador de números
  // aleatórios
  srand(time(NULL));

  // vamos criar uma string
  string palavra = "JAVASCRIPT";
  cout << "Palavra original: " << palavra << endl;
  
  // vamos embaralhar as palavras da string
  random_shuffle(palavra.begin(), palavra.end());

  // exibe o resultado
  cout << "Palavra com caracteres embaralhados: " << palavra << "\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>
#include <cstdlib>
   
using namespace std;
   
int main(int argc, char *argv[]){
  int numero;
  bool primo = true;
	
  // vamos solicitar um número inteiro positivo
  cout << "Informe um número inteiro positivo: ";
  cin >> numero;
    
  // o número é negativo?
  if(numero < 0){
    cout << "Número inválido.\n\n";
  }
  // é 0 ou 1?
  else if((numero == 0) || (numero == 1)){
    cout << "Número válido, mas não é primo.\n\n";
  }
  // passou até aqui. Vamos testar se o número é primo
  else{
    for (int i = 2; i <= (numero / 2); i++){
      // se passar no teste, não é primo
      if (numero % i == 0) {
        primo = false;
        break;
      }
    }
      
    if(primo){
      cout << "O número informado é primo\n\n";
    }
    else{
      cout << "O número informado não é primo\n\n";
    }
  }
       
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

string& replace(size_t pos1, size_t n1, const string& str);

----------------------------------------------------------------------
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[]){
  // vamos criar uma string
  string frase = "Gosto de Java";
  cout << "A frase e: " << frase << endl;	
	
  // vamos substituir Java por C++
  frase.replace(9, 4, "PHP"); 
	 
  // e mostramos o resultado	 
  cout << "Depois da substituicao: " << frase << endl; 
	 
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}