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

package estudos;

public class Estudos {
  public static void main(String[] args){
    // vamos definir a ordem da matriz
    int ordem = 3; // 3 linhas e 3 colunas
    
    // e agora criamos a matriz. Podemos definir os elementos
    // diretamente ou pedir para o usuário informar os valores
    int matriz[][] = {{1, 3, 0}, {0, 2, 5}, {2, 4, 4}};
 
    // mostramos a matriz completa
    System.out.println("A matriz é:\n");
    
    for (int i = 0; i < ordem; i++) {
      for (int j = 0; j < ordem; j++){
        System.out.printf("%5d", matriz[i][j]);
      }
      System.out.print("\n");
    }
    
    // vamos calcular o determinante usando o Teorema de Laplace
    int determinante = calcularDeterminante(matriz, ordem);
    
    // e mostramos o resultado
    System.out.println("\nO determinante da matriz é: " + determinante);  
  } 
 
  // função recursiva que encontra e retorna o determinante de uma
  // matriz de qualquer ordem
  public static int calcularDeterminante(int matriz[][], int ordem){
    int determinante = 0; // para guardar e retornar o determinante
    // matriz de cofatores
    int cofatores[][] = new int[ordem][ordem];
    // para guardar o sinal de multiplicação
    int sinal = 1;
    
    // 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 (int f = 0; f < ordem; f++) {
      // vamos obter o cofator de matriz[0][f]
      calcularCofator(matriz, cofatores, 0, f, ordem);
      determinante = determinante + (sinal * matriz[0][f]
        * calcularDeterminante(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[][]
  public static void calcularCofator(int mat[][], int temp[][],
    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

Informe o ano de seu nascimento: 1985
Informe o ano atual: 2023
A idade em anos é: 38
A idade em meses é: 456
A idade em dias é: 13680
A idade em semanas é: 1976

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

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);  
    
    // vamos ler o ano de nascimento
    System.out.print("Informe o ano de seu nascimento: ");
    int ano_nascimento = Integer.parseInt(entrada.nextLine());
    System.out.print("Informe o ano atual: ");
    int ano_atual = Integer.parseInt(entrada.nextLine());
    
    // calcula a idade em anos
    int idade_anos = ano_atual - ano_nascimento;
    System.out.println("A idade em anos é: " + idade_anos);
    
    // calcula a idade em meses
    int idade_meses = idade_anos * 12;
    System.out.println("A idade em meses é: " + idade_meses);
    
    // calcula a idade em dias
    int idade_dias = idade_anos * 12 * 30;
    System.out.println("A idade em dias é: " + idade_dias);
    
    // calcula a idade em semanas
    int idade_semanas = idade_anos * 52;
    System.out.println("A idade em semanas é: " + idade_semanas);
  } 
}

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

package arquivodecodigos;

import java.util.Scanner;
 
public class Estudos {
  static int quantChamadasRecursivas = 0; // registra as chamadas recursivas  
     
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
       
    // vamos ler a quantidade de discos a serem usados na simulação
    System.out.print("Informe a quantidade de discos: ");
    int discos = Integer.parseInt(entrada.nextLine());
 
    // resolve o problema recusivamente
    System.out.println("\nOs movimentos para resolver o problema foram:\n");
    moverDiscos(discos, 'A', 'B', 'C');
    System.out.println("\nForam feitas " + quantChamadasRecursivas + 
      " chamadas recursivas");
    System.out.println();
  }
   
  // método recursivo que resolve o problema da Torre de Hanói
  public static void moverDiscos(int n, char daTorre, char paraTorre, 
    char torreAux) {
    quantChamadasRecursivas++; // registra mais uma chamada recursiva
       
    if(n == 1){ // condição de parada
      System.out.println("Movendo o disco " + n + " de " + daTorre + " para " + 
        paraTorre);
    }
    else{ // faz mais uma chamada recursiva
      moverDiscos(n - 1, daTorre, torreAux, paraTorre);
      System.out.println("Movendo o disco " + n + " de " + daTorre + " para " + 
        paraTorre);
      moverDiscos(n - 1, torreAux, paraTorre, daTorre);
    }
  }
}

0! = 1;
n! = n x (n - 1)!; sendo n > 0

public static long fatorial(int n){
  // sua implementação aqui
}

Informe um número inteiro: 5
O fatorial do número informado é: 120

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

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // cria um novo objeto da classe Scanner
    Scanner entrada = new Scanner(System.in);
    
    // vamos solicitar o número inteiro
    System.out.print("Informe um número inteiro: ");
    // lê o número
    int numero = Integer.parseInt(entrada.nextLine());
    
    // calcula o fatorial corresponde ao número informado
    System.out.print("O fatorial do número informado é: " + fatorial(numero));
    System.out.println("\n");
  }
  
  // método recursivo que calcula o fatorial de um inteiro informado
  public static long fatorial(int n){
    if(n == 0){ // caso base....retornar
      return 1;
    }
    else{
      return n * fatorial(n - 1); // efetua mais uma chamada recursiva
    }
  }
}

palavra = "python"
palavra.upper()
print(palavra)