Desafios e Soluções dos Bootcamps da Digital Innovation One 📚

Clique no logotipo da linguagem para conferir soluções que ainda não estão listadas abaixo:

Resolvendo um desafio de código na prática

Para te auxiliar na conclusão do bootcamp, a equipe da DIO realizou uma live explicando o passo a passo sobre como resolver os desafios de código, confira no Youtube:

LIVE - Resolvendo um desafio de código na prática

Há também um mini-curso e uma mentoria dentro da plataforma (Precisa estar logado):

• Resolvendo Desafios de Código em Java

• Mentoria DIO: Como Resolver desafios de código na sua jornada como dev

Esses desafios lhe ajudarão a praticar e aplicar os conceitos apresentados nas aulas e exercícios. Para ter destaque na carreira de desenvolvimento de software é necessário praticar muito com algoritmos.

O desafio lhe propõe praticar o pensamento computacional, exigindo a criação de uma solução implementada através do seu código com um conjunto de entradas e saídas esperadas.

Na área especificada acima, você deve digitar o seu código para a solução do desafio.

Clicando no botão "SALVAR", você pode ir salvando o seu código conforme for desenvolvendo.

No ícone de engrenagem, localizado no canto superior direito, você pode alterar as configurações do editor e deixar com a sua cara.

Ao clicar em instruções, confira algumas intruções e dicas para implementação da sua solução.

Em "TESTES", ficarão todos os testes que serão executados junto a sua implementação da solução.

Os testes abertos ( ▶ ) podem ser executados a qualquer momento para você avaliar o código criado como solução para o desafio. Os testes com cadeados ( 🔒 ) são ocultos e apenas serão executados quando você decidir entregar o seu código.

Através do botão "EXECUTAR TESTES", execute os testes abertos a qualquer momento para você avaliar o código criado como solução para o desafio.

Discord

Você também pode tirar dúvidas com milhares de Devs em nossa comunidade no Discord, acesse o link localizado no rodapé da página ou clique aqui

Após revisado e testado o seu código, você deve clicar no botão "ENTREGAR DESAFIO", para avaliação em tempo real.

Solução de Desafio Java, JavaScript e Kotlin

Link para o artigo no GitHub

Entradas

Todos os desafios possuem maneiras diferentes de entrada de dados, ou seja, todos os valores que o desafio mostra em cada teste:

• Entram por alguma função (método) de entrada;
• Passam pelo nosso código;
• Saem por alguma função (método) de saída.

Métodos de entrada

Dependendo da linguagem de programação que você esteja aprendendo o método de entrada é diferente. Aqui abaixo tem uma pequena lista com a linguagem e o método de entrada.

JavaScript gets()

const entrada = gets();

Lembrando que gets( ) é uma função que funciona apenas na plataforma para a linguagem JavaScript.

Java new Scanner(System.in)

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);        
    }
}

Kotlin readLine()

fun main() {
    val entrada = readLine()!! // Forma assertiva
}
fun main() {
    val entrada = readLine() ?: "" // Forma assegurada
}

Exemplos de entrada

Supondo que tenhamos um arquivo de entrada:

abacaxi
banana
cereja

Onde precisamos pegar os valores de cada linha e guardar em uma variável, como faríamos?

JavaScript

const entrada1 = gets(); // abacaxi
const entrada2 = gets(); // banana
const entrada3 = gets(); // cereja

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        String entrada1 = entrada.nextLine(); // abacaxi
        String entrada2 = entrada.nextLine(); // banana
        String entrada3 = entrada.nextLine(); // cereja
        entrada.close();
    }
}

Kotlin

fun main() {
    val entrada1 = readLine() ?: "" // abacaxi
    val entrada2 = readLine() ?: "" // banana
    val entrada3 = readLine() ?: "" // cereja
}

Exemplo com o código de soma

A partir de agora vamos fazer um código de soma simples e entender alguns comportamentos de entrada e de saída.

Entrada

15
20
7

Algoritmo

INÍCIO DO PROCESSO
    > Armazenar a primeira entrada.
    > Não armazenar a segunda entrada.
    > Armazenar a terceira entrada.
    > Armazenar a soma da primeira com a terceira entrada.
    > Exibir o resultado do cálculo.
FIM DO PROCESSO

Para que possamos "pular" a segunda entrada basta executar a função de entrada sem nunca atribui-la a uma variável, dessa maneira a entrada é obtida, porém nunca armazenada.

JavaScript

const entrada1 = Number(gets()); // 15
gets(); // "20"
const entrada3 = Number(gets()); // 7

const soma = entrada1 + entrada3;
console.log(soma); // 22

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        int entrada1 = entrada.nextInt(); // 15
        entrada.nextInt(); // 20
        int entrada3 = entrada.nextInt(); // 7
        entrada.close();

        System.out.println(entrada1 + entrada3); // 22
    }
}

Kotlin

fun main() {
    val entrada1 = readLine()?.toInt() ?: 0 // 15
    readLine() // "20"
    val entrada3 = readLine()?.toInt() ?: 0 // 7

    println(entrada1 + entrada2) // 22
}

Caso mudemos a entrada o nosso código deverá exibir a saída esperada para cada ocasião.

Exemplos

Considerando o algoritmo acima que "pula" a segunda entrada temos:

Teste 1

Entrada

10
20
30

Saída esperada

40

Teste 2

Entrada

55
4890
15

Saída esperada

70

Logo o código feito para cada linguagem daria certo em ambos os testes, pois sempre entrariam a primeira e a terceira linha de entrada, faria-se a soma e seria por fim exibido o resultado que é igual a saída esperada por cada teste.

Solução de Desafio C#

Link original

Antes de iniciar qualquer desafio de código, é importante entender o que está sendo pedido e como a informação será processada pelo console.

Para exemplificar, vou usar o desafio Múltiplos.

using System;
class minhaClasse {
       static void Main(string[] args) {
           //continue a solucao com a insercao da variavel corretamente
           
       }
   }

O que esse bloco de código está me dizendo?

• Na linha 1, temos a diretiva using fazendo referência ao namespace System. Na prática isso significa que posso usar os tipos da System de forma não qualificada. Ou seja, posso chamar o Console diretamente, em vez de ter que chamar System.Console.
• Na linha 2, temos a classe que está sendo declarada.
• Na linha 3, temos o método Main, que é o único membro da classe minhaClasse. Ele também é o ponto de entrada desse programa e está recebendo um array de strings.

Agora vamos olhar a solução que precisa ser feita:

1. Instrução: Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem "São Multiplos" ou "Não são Multiplos", indicando se os valores lidos são múltiplos entre si.
2. Entrada: A entrada contém valores inteiros.
3. Saída: A saída deve conter uma das mensagens conforme descrito acima.

Vamos receber os dados:

using System;
class minhaClasse {
       static void Main(string[] args) {
           //continue a solucao com a insercao da variavel corretamente

           string[] valores = Console.ReadLine().Split(' ');
           int A = int.Parse(valores[0]);
           int B = int.Parse(valores[1]);
       }
    } 

• Na linha 6, temos o Console.ReadLine() lendo os dados e o Split(' ') separando esses dados por um espaço. Isso está sendo atribuído a variável valores que é um array.
• Na linha 7, estou selecionando o índice 0 do array. Dentro dele está o 1º item desse array, que é do tipo string. Para poder trabalhar com ele como se fosse um número, preciso convertê-lo. É isso que o int.Parse() está fazendo. Esse dado, já devidamente convertido, está sendo atribuído a variável A.
• Na linha 8, está acontecendo a mesma coisa. A diferença é que estou acessando o índice 1, que contém o 2º item do array.

Agora é preciso pensar no problema em si. Como que eu sei que 2 números são ou não são múltiplos um do outro? Como a tabuada é o exemplo clássico dos múltiplos, vamos olhar para ela:

• Tabuada de 2:
• 2x1 = 2 // 2x2 = 4 // 2x3 = 6 // 2x4 = 8 // 2x5 = 10
• Conjunto dos Múltiplos de 2 = {2, 4, 6, 8, 10, ...}

Então se observa que os múltiplos de um número são divisíveis por esse número, então o resto dessa divisão será 0.

• 2 / (qualquer múltiplo de 2) = (a um número natural) => Resto será 0
• 2 / 2 = 1 => resto 0
• 2 / 4 = 2 => resto 0
• 2 / 6 = 3 => resto 0

Vamos implementar isso:

using System;
class minhaClasse {
       static void Main(string[] args) {
           //continue a solucao com a insercao da variavel corretamente

           string[] valores = Console.ReadLine().Split(' ');
           int A = int.Parse(valores[0]);
           int B = int.Parse(valores[1]);

           if (A % B  == 0) {
               Console.WriteLine("Sao Multiplos");
           }
           else {
                Console.WriteLine("Nao sao Multiplos");
            }
        }
 }

• Na linha 10, ele vai dividir o valor A pelo valor B e se o resto for igual a 0, ele vai executar o que está dentro das { }
• Na linha 11, ele vai retornar a saída "Sao Multiplos", caso o if da linha 10 seja verdadeiro.
• Na linha 13, se o if da linha 10 for falso, ele vai executar o que está dentro das { } do else.
• Na linha 14, ele vai retornar a saída "Nao sao Multiplos", indicando que a verificação do if retornou falsa.

Esse código está bom, mas tem um problema. Ele só retorna verdadeiro quando A é múltiplo de B. Mas eu preciso que ele retorne verdadeiro também nos casos em que B é múltiplo de A.

• Porque? Porque a instrução pede que se verifique se os números recebidos são múltiplos entre si, em qualquer ordem.
• Sabemos que 2 e 4 são múltiplos entre si.
• Mas o meu código só vai retornar verdadeiro quando A = 4 e B = 2.
• Se eu receber esses números na ordem inversa, com A = 2 e B = 4 ele vai retornar falso.

Para resolver isso, vou adicionar o operador lógico ou (||) dentro do meu if.

using System;
class minhaClasse {
       static void Main(string[] args) {
           //continue a solucao com a insercao da variavel corretamente

           string[] valores = Console.ReadLine().Split(' ');
           int A = int.Parse(valores[0]);
           int B = int.Parse(valores[1]);

           if (A % B  == 0 || B % A == 0) {
               Console.WriteLine("Sao Multiplos");
           }
           else {
                Console.WriteLine("Nao sao Multiplos");
            }
        }
 }

Na linha 10, ele vai ver se o resto da divisão entre A e B é igual a 0 OU se o resto da divisão entre B e A é igual a 0. Se qualquer uma dessas condições for verdadeira, o if será verdadeiro e ele irá executar o que está dentro das { }

Pronto, agora o código vai passar em todos os testes de saída.

Conversores de Código

• Java para C#
• Java para Kotlin ou Kotlin para Java

uDebug do URI e testes fechados

Link original

Os desafios de código da DIO vem do URI online judge e no URI tem uma seção de debug (exemplo: https://www.udebug.com/URI/1040), onde tem vários casos de teste que são por propostos por usuários para ajudar quem está fazendo um desafio a testar seu código. A DIO utiliza os testes do uDebug nos seus casos de teste, porém como os testes são criados por usuários eles podem estar errados, não são testes oficiais sugeridos pelo URI. No Debug do URI é possível ver se o resultado do código bate com os testes, independente do resultado dos testes do uDebug do URI fazerem sentido ou não, no fim o que importa é os seus resultados baterem.

Passo 1 - O primeiro passo é bem simples, que é achar o desafio da DIO no URI, para isso escreva no google mesmo urionlinejudge + (nome do desafio da DIO ou parte do enunciado do desafio).

Passo 2 - No URI vc vai no canto superior direito e clica em uDebug.

Passo 3 - Na tela do uDebug você seleciona um caso de teste e clica em "Get Accepted Output".

Passo 4 - Assim que vc clicar em "Get Accepted Output", a saida esperada do caso de teste vai aparecer abaixo, você copia a sua saida e cola ao lado em "your output" e clica em "Compare outputs".

Obs: recomendo cuidado ao copiar a sua saida, copie tudo, inclusive quebra de linha que possa haver ao final dela. É melhor usar um ctrl+a ou qualquer outro comando seleção completa.

Obs2: Não existe nenhuma trapaça em fazer isso, nem o URI e nem o uDebug vai te dar a solução dos desafios, você ainda terá que desenvolver o código. Essa é apenas uma ajuda para evitar dores de cabeça com casos de teste com erros.

Clean Code e Refactoring

• RESOLVEMOS! Bug: (bootcamp da everis New Talents - .NET) - Desafios avançados em C# - Desafio 3/3 - Tempo de Jogo com Minutos | Clean Code e Refactoring

• Refatorando => Desafios avançado 1/3 de C#. Melhorando a qualidade e legibilidade do código. Aplicando Clean Code e Refactoring.

🐛 Issues

Sinta-se à vontade para registrar um novo problema com o respectivo título e descrição no repositório do projeto. Se você já encontrou uma solução para seu problema, adoraria revisar sua solicitação de pull!

🤝 Contribuições

Siga os passos abaixo para contribuir:

1. Faça o fork do projeto (https://github.com/shyoutarou/desafios-DIO.git)

2. Clone o seu fork para sua maquína (git clone https://github.com/user_name/desafios-DIO.git)

3. Crie uma branch para realizar sua modificação (git checkout -b feature/name_new_feature)

4. Adicione suas modificações e faça o commit (git commit -m "Descreva sua modificação")

5. Push (git push origin feature/name_new_feature)

6. Crie um novo Pull Request

7. Pronto, agora só aguardar a análise 🚀

📜 License

O projeto lançado em 2021 sobre a licença MIT ❤️

Made with ♥ by Shyoutarou

Gostou? Deixe uma estrelinha para ajudar o projeto ⭐