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! 🚀