Dicas para resolver os desafios de códigos

#Lógica de Programação

Tenho notado que muitos colegas estão solicitando ajuda em desafios de código e que ao analisar o código, percebo que alguns detalhes poderão ser aprimorados:

1 - Saída Conforme o Enunciado:

Certifique-se de imprimir as mensagens de saída exatamente como solicitado no enunciado.
Evite inserir mensagens desnecessárias, pois elas afetarão os resultados dos testes. Exemplos: print("Digite a senha"), console.log('Digite o valor do saque'), etc...

2 - Quebra de Linha:

Use a quebra de linha (como \n ou %n) apenas quando especificado no problema.
Não adicione quebras de linha extras sem necessidade.

3 - Sintaxe e Fechamento:

Lembre-se de fechar chaves, parênteses e usar ponto e vírgula no final das linhas (dependendo da linguagem).
Uma sintaxe correta é fundamental para o funcionamento correto do código.

4 - Acentuação e Formatação:

Utilize acentos corretamente quando necessário.
Adicione espaços entre as palavras e use maiúsculas e minúsculas adequadamente.
O caracter A (decimal 65) é diferente de a(decimal 97), por exemplo, Então se o enunciado espera pela primeira letra em maisculo, se enviar minusculo, vai estar errado.

Figura Tabela ASCII

5 - Exemplos de entrada:

Os exemplos de entrada são apenas utilizados para o entendimento do fluxo na qual o seu código deveria se comportar.
Evite alterar o código inserindo os valores de entrada dos exemplos como valores mágicos.

6 - Foco na Lógica:

Concentre-se na lógica do problema e deixe a saída o mais limpa possível.
Não é necessário reinventar a roda! Altere apenas onde o código de template está indicando, geralmente tem um comentário com "TODO: ", com as anotações do que deveria se fazer naquela região.

Uma forma de entendimento é, conforme a classe de Teste Unitário com JUnit, onde temos um exemplo em Java de um desafio chamado 1 - Registro de Transações Bancárias que faz parte do Curso de Desenvolvimento Java com IA onde está na categoria Dominando Desafios de Códigos Intermediários em Java:

Figura com os dados de entrada e a exibição da saída dos dados processados.

Figura com os exemplos de entradas e saídas (durante a escrita de seu código, não se preocupe com as entradas, elas são automatizadas).

Abaixo temos o código fonte do desafio:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class RegistroTransacoesBancarias {
public static void main(String[] args) {
  Scanner scanner = new Scanner(System.in);
  // Lê a Entrada que informa o saldo inicial da conta
  double saldo = scanner.nextDouble();
  // Lê a Entrada com a quantidade total de transações
  int quantidadeTransacoes = scanner.nextInt();
  // Lista para armazenar as transações
  List<String> transacoes = new ArrayList<>();
  // Loop para iterar sobre as transações
  for (int i = 1; i <= quantidadeTransacoes; i++) {
    // Lê a Entrada com o tipo de transação (D para depósito ou S para saque)
    // O método "toUpperCase" padroniza o tipo de transação com a letra maiúscula
    char tipoTransacao = scanner.next().toUpperCase().charAt(0);
    // Lê a Entrada com o valor da transação
    double valorTransacao = scanner.nextDouble();
    // Atualiza o saldo da conta e adicionar a transação à lista
    if (tipoTransacao == 'D') {
      saldo += valorTransacao;
      transacoes.add("Deposito de " + valorTransacao);
    } else if (tipoTransacao == 'S') {
      saldo -= valorTransacao;
      transacoes.add("Saque de " + valorTransacao);
    } else {
      System.out.println("Opção inválida. Utilize D para depósito ou S para saque.");
      i--; // Decrementa o índice para repetir a iteração
    }
  }
  // TODO: Exibir o saldo final e a lista de transações conforme a tabela de Exemplos.
  

  // Fechar o scanner para evitar vazamentos de recursos
  scanner.close();
}
}

Então devemos adicionar o que o desafio pede, neste caso, logo abaixo de TODO:

Na figura acima, temos a solução (código ofuscado). Insira ali a sua solução!

Abaixo temos o código fonte de uma classe de Test com JUnit, na qual eu escrevi para exemplificar como seria a validação de sua solução, conforme o enunciado:

import org.junit.jupiter.api.*;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.PrintStream;

import static org.junit.jupiter.api.Assertions.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class RegistroTransacoesBancariasTest {

  private RegistroTransacoesBancarias registro;

  @BeforeEach
  public void setup() {
      registro = new RegistroTransacoesBancarias();
  }

  /*
   * Neste cenario as entradas são:
   * 2500
   * 2
   * d
   * 100
   * s
   * 500
   * E as saidas são:
   * Saldo: 2100.0
   * Transacoes:
   * 1. Deposito de 100.0
   * 2. Saque de 500.0
   */
  @Test
  @Order(1)
  public void deveRealizarPrimeiroCenario_retornarIguais() {
      String entradaAutomatizada = "2500\n2\nd\n100\ns\n500\n";
      InputStream inputStream = new ByteArrayInputStream(entradaAutomatizada.getBytes());
      ByteArrayOutputStream suaSaida = new ByteArrayOutputStream();
      System.setOut(new PrintStream(suaSaida));
      PrintStream saidaImpressa = System.out;
      System.setIn(inputStream);
      registro.main(null);
      String saidaEsperada = "Saldo: 2100.0\n" +
              "Transacoes:\n" +
              "1. Deposito de 100.0\n" +
              "2. Saque de 500.0\n";
      assertEquals(saidaEsperada, suaSaida.toString()
              .replaceAll("\r\n", "\n")
              .replaceAll(",", "."));
      System.setOut(saidaImpressa);
  }

  /*
   * Neste cenario as entradas são:
   * 900
   * 1
   * s
   * 100
   * E as saidas são:
   * Saldo: 800.0
   * Transacoes:
   * 1. Saque de 100.0
   */
  @Test
  @Order(2)
  public void deveRealizarSegundoCenario_retornarIguais() {
      String entradaAutomatizada = "900\n1\ns\n100";
      InputStream inputStream = new ByteArrayInputStream(entradaAutomatizada.getBytes());
      ByteArrayOutputStream suaSaida = new ByteArrayOutputStream();
      PrintStream saidaImpressa = System.out;
      System.setOut(new PrintStream(suaSaida));

      System.setIn(inputStream);
      registro.main(null);
      String saidaEsperada = "Saldo: 800.0\n" +
              "Transacoes:\n" +
              "1. Saque de 100.0\n";
      assertEquals(saidaEsperada, suaSaida.toString()
              .replaceAll("\r\n", "\n")
              .replaceAll(",", "."));
      System.setOut(saidaImpressa);
  }

  /*
   * Neste cenario as entradas são:
   * 0
   * 0
   * E as saidas são:
   * Saldo: 0.0
   * Transacoes:
   */
  @Test
  @Order(3)
  public void deveRealizarTerceiroCenario_retornarIguais() {
      String entradaAutomatizada = "0\n0\n";
      InputStream inputStream = new ByteArrayInputStream(entradaAutomatizada.getBytes());
      PrintStream saidaImpressa = System.out;
      ByteArrayOutputStream suaSaida = new ByteArrayOutputStream();
      System.setOut(new PrintStream(suaSaida));

      System.setIn(inputStream);
      registro.main(null);
      String saidaEsperada = "Saldo: 0.0\n" +
              "Transacoes:\n";

      assertEquals(saidaEsperada, suaSaida.toString()
              .replaceAll("\r\n", "\n")
              .replaceAll(",", "."));
      System.setOut(saidaImpressa);
  }
}

Note que no exemplo da classe de teste, é esperado o texto conforme o enunciado (inclusive com o valor exibindo uma casa decimal) e sem nenhuma acentuação não solicitada, nenhuma mensagem extra de saída, etc...

Abaixo temos a figura com código do desafio que foi transcrito para o IntelliJ e executado. Inserindo os valores do exemplo e gerando as saídas que o desafio pede.

Figura com exemplo de mensagens corretas.

Abaixo temos outro exemplo do que está sendo esperado (Saída esperada) e o que o seu programa está imprimindo na saída (Sua Saída). Propositalmente foi adicionado o símbolo da moeda Real na linha 41, fazendo o teste falhar.

Figura de erro quando o teste falha.

Em resumo, deverá imprimir exatamente igual o que se espera em "Saída esperada".

Com esse artigo, espero que você tenha entendido um pouco sobre como funcionam os testes.

Aqui na DIO temos um curso sobre o assunto Desafios de Código e Conhecendo o ambiente e resolvendo um desafio (com Venilton Jr, Natália Fernandes e a Adriana Silva).

Lembre-se de que a simplicidade e a clareza são essenciais ao resolver desafios de código.

Boa sorte e bons estudos! 🚀