Code Challenge – Erkundung von Telefoniediensten

Eines der Dinge, die ich an DIO-Bootcamps wirklich cool finde, ist, dass während des Trails einige Codeübungen durchgeführt werden müssen, mit einem Editor in der Nähe und einigen Bedingungen; ein bisschen so eine HackerRank-Atmosphäre. Es ist wirklich cool, weil es hilft, das in den theoretischen Teilen erworbene Wissen zu festigen, und es ist kein komplexerer Ansatz wie die Projektherausforderung: Es ist etwas Vereinfachteres, um Ihr logisches Denken und Ihre Sprachkenntnisse zu testen. Genau wie HackerRank geben sie Ihnen einige vorgefertigte Snippets und Sie entwickeln darauf basierend Ihre Logik.

Diese Woche war verrückt, daher habe ich es nur geschafft, die beiden im Modul „Erkundung von Telefoniediensten“ vorgeschlagenen Herausforderungen zu lösen. Da der Sponsor dieses Bootcamps Claro ist, werden viele der Themen einen Telekommunikationsbezug haben.

Überprüfung der vertraglich vereinbarten Leistung

Stellungnahme:

Ein Telekommunikationskonzessionär bietet vier Arten von Diensten an: Mobiltelefonie, Festnetztelefonie, Breitband und Pay-TV. Um den Kundenservice zu erleichtern, ist es notwendig, ein Programm zu implementieren, das prüft, ob ein bestimmter Kunde einen bestimmten Service in Anspruch genommen hat. Wenn beispielsweise ein Kunde das Callcenter anruft und eine Dienstleistung erwähnt, muss der Mitarbeiter schnell überprüfen können, ob diese Dienstleistung vom Kunden in Anspruch genommen wird.

Verboten:

Zwei Zeichenfolgen: Eine mit dem Dienst, den die Anwendung überprüft (z. B. Mobilfunk, Festnetz, Breitband, TV). Die zweite muss den Namen des Kunden und die von ihm verwendeten Produkte enthalten, getrennt durch ein Komma (Alice, Mobil, Festnetz)

Erwartete Ausgabe:

Wenn der Kunde die im ersten Eintrag beschriebene Dienstleistung in Anspruch genommen hat, muss im Antrag „Ja“ angezeigt werden, andernfalls muss „Nein“ angezeigt werden.

Beispiele:

Entrada	Saída
movel Alice,movel,fixa	Sim
fixa Bob,movel,tv	Nao
tv Carol,movel,fixa,tv	Sim

Código inicial:

import java.util.Scanner;

public class VerificacaoServico {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Entrada do serviço a ser verificado
        String servico = scanner.nextLine().trim();

        // Entrada do nome do cliente e os serviços contratados
        String entradaCliente = scanner.nextLine().trim();

        // Separando o nome do cliente e os serviços contratados
        String[] partes = entradaCliente.split(",");
        String nomeCliente = partes[0];
        boolean contratado = false;

        // TODO: Verifique se o serviço está na lista de serviços contratados

        scanner.close();
    }
}

Resolução:

Esse é um desafio relativamente simples. A aplicação recebe uma string delimitada por vírgulas que é transformada em array e precisamos descobrir se dentro dela existe uma string que coincide com outra entrada do usuário, que é o serviço que queremos checar se o cliente possui. Fácil, né?

Pra mim, que tem um histórico de JavaScript e C#, é só usar um método verificador (como o Array.includes() ou o List.Contains()). Certo? Errado.

Não existe, em Java, um método como esse na classe Array. Isso pode ser devido à implementação ser muito mais próxima da que acontece em linguagens de baixo nível (como C), que estabelece que elas devem ser estruturas de dados simples e eficientes. Aparentemente esse tipo de consulta não faz parte das funções essenciais dessa estrutura.

Descobrir essa informação foi um choque. O que o Java espera que eu faça? Que eu escreva um loop for e cheque manualmente se cada elemento bate com o item que eu estou procurando? Irmão, eu trabalho em tempo integral, tenho uma filha de menos de dois anos e ainda estou estudando Java. Tenho tempo pra isso não, bicho.

Mas eu descobri que desde o Java 8 é possível converter a array em uma list e, esta sim, tem o método .contains(). Então, para a resolução desse problema, é só converter a array partes em uma lista, e então verificar se dentro dessa lista existe a string passada em servico.
Se existir imprimimos Sim e em caso contrário, imprimimos Não.

import java.util.Arrays;
import java.util.Scanner;

public class VerificacaoServico {
    public static void main(String[] args) {
        //...
        // TODO: Verifique se o serviço está na lista de serviços contratados
        contratado = Arrays.asList(partes).contains(servico);

        System.out.println(contratado ? "Sim" : "Nao");

        scanner.close();
    }
}

Com isso o exercício está concluído, mas durante a pesquisa que fiz descobri que desde o Java 8 existe uma abstração que ajuda a trabalhar com coleções de dados de uma maneira mais simples e de uma abordagem mais funcional, parecida com o que existe em JavaScript: as streams.

Assim como com listas, podemos converter o vetor em uma stream e checar se algum dos elementos presentes nela corresponde ao que foi passado em servico:

import java.util.Arrays;
import java.util.Scanner;

public class VerificacaoServico {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Entrada do serviço a ser verificado
        String servico = scanner.nextLine().trim();

        // Entrada do nome do cliente e os serviços contratados
        String entradaCliente = scanner.nextLine().trim();

        // Separando o nome do cliente e os serviços contratados
        String[] partes = entradaCliente.split(",");
        String nomeCliente = partes[0];
        boolean contratado = false;

        contratado = Arrays.stream(partes).anyMatch(servico::equals);

        System.out.println(contratado ? "Sim" : "Nao");

        scanner.close();
    }
}

Podíamos ter feito a verificação passando um callback para o método .anyMatch(p -> p == servico), mas isso checa se p e servico não apenas tem o mesmo valor mas também se apontam para o mesmo endereço de memória (ou seja, se são de fato o mesmo objeto). Normalmente, quando lidamos com strings, essa comparação vai retornar false mesmo se o valor for igual -- ou seja, um falso negativo. Por isso, a comparação usando servico::equals é mais adequada, porque compara apenas o valores entre os dois elementos, mais ou menos como o comparador de igualdade do JavaScript (==).

Com essa alteração, podemos julgar que o exercício está concluído. O que falta é rodar os testes e ver se eles passam:

Bom demais.
Esse exercício me deu outro motivo para reclamar de Java, que é a sintaxe da lambda. O uso da seta simples (->) ao invés da dupla (=>) me incomoda muito.

---

Verificação de Contratação de Combo Completo

Enunciado:

Implemente um sistema que verifique se um cliente de uma empresa de telecomunicações contratou um combo completo de serviços. Um combo completo inclui os três serviços principais oferecidos pela empresa: telefonia móvel, banda larga e TV por assinatura. O sistema deve ler uma lista de serviços contratados pelo cliente e determinar se todos os serviços necessários estão incluídos. Caso todos os três serviços estejam presentes, o sistema deve retornar "Combo Completo". Se faltar qualquer um dos serviços, o sistema deve retornar "Combo Incompleto".

Entrada:

Uma string contendo os serviços contratados pelo cliente, separados por vírgula. Os valores possíveis são movel, banda larga e tv.

Saída esperada:

Uma string contendo Combo Completo se o cliente tiver todos os serviços contratados, Combo Incompleto do contrário.

Exemplos:

Entrada	Saída
movel,banda larga,tv	Combo Completo
movel,tv	Combo Incompleto
banda larga,tv,movel	Combo Completo

Código inicial:

import java.util.Scanner;

public class VerificacaoComboCompleto {

    // Função para verificar se o cliente contratou um combo completo
    public static String verificarComboCompleto(String[] servicosContratados) {
        // Variáveis booleanas para verificar a contratação de cada serviço
        boolean movelContratado = false;
        boolean bandaLargaContratada = false;
        boolean tvContratada = false;

        // TODO: Itere sobre os serviços contratados
        for (String servico : servicosContratados) {
        }

        // TODO: Verifique se todos os serviços foram contratados
        if () {
            return "Combo Completo";
        } else {
            return "Combo Incompleto";
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Solicitando ao usuário a lista de serviços contratados
        String input = scanner.nextLine();

        // Convertendo a entrada em uma lista de strings
        String[] servicosContratados = input.split(",");

        // Verificando se o cliente contratou um combo completo
        String resultado = verificarComboCompleto(servicosContratados);

        // Exibindo o resultado
        System.out.println(resultado);

        // Fechando o scanner
        scanner.close();
    }
}

Resolução:

De novo, esse é um desafio simples. Para chegar no resultado, apenas alguns passos precisam ser seguidos:

1. Iterar sobre a array gerada pelo método main a partir da string inserida pelo usuário;
2. Checar se os serviços disponibilizados (descritos nas variáveis booleanas logo acima) foram contratados;
   • Em caso positivo, a variável correspondente deve ter seu valor alterado para true.
3. Verificar se todos os serviços estão com o valor true. Apesar de ter mais passos, é bem mais direto que o anterior. Podemos começar a resolver esse trem de um jeito bem tosco, com uma série de ifs encadeados:

for (String servico : servicosContratados) {
    if(servico.equals("movel")) movelContratado = true;
    if(servico.equals("bandaLarga")) bandaLargaContratada = true;
    if(servico.equals("tv")) tvContratada = true;
}

E preenchemos a condição do nosso if:

if (movelContratado && bandaLargaContratada && tvContratada) {
    return "Combo Completo";
} else {
    return "Combo Incompleto";

Assim como no primeiro, com essas adições o desafio pode ser considerado como completo, mas esses ifs, um seguido do outro me incomoda um pouco. Podemos alterar isso pra um switch pra ficar menos feio:

for (String servico : servicosContratados) {
    switch (servico) {
        case "movel":
            movelContratado = true;
            break;
        case "banda larga":
            bandaLargaContratada = true;
            break;
        case "tv":
            tvContratada = true;
            break;
        default:
            System.out.println("Serviço inválido.");
            break;
    }
}

Há quem diga que os ifs são de mais fácil leitura e que o ganho que a otimização traria para um switch tão pequeno como esse é desprezível. Outros diriam que eu tenho pouca consistência interna, reclamando de checar manualmente strings em um exercício e fazendo sem um pio em outro.
Pra essas pessoas eu digo:

O código final ficaria então:

import java.util.Scanner;
public class VerificacaoComboCompleto {
    // Função para verificar se o cliente contratou um combo completo
    public static String verificarComboCompleto(String[] servicosContratados) {
        // Variáveis booleanas para verificar a contratação de cada serviço
        boolean movelContratado = false;
        boolean bandaLargaContratada = false;
        boolean tvContratada = false;

        for (String servico : servicosContratados) {
            switch (servico) {
                case "movel":
                    movelContratado = true;
                    break;
                case "banda larga":
                    bandaLargaContratada = true;
                    break;
                case "tv":
                    tvContratada = true;
                    break;
                default:
                    System.out.println("Serviço inválido.");
                    break;
            }
        }

        if (movelContratado && bandaLargaContratada && tvContratada) {
            return "Combo Completo";
        } else {  
            return "Combo Incompleto";
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // Solicitando ao usuário a lista de serviços contratados
        String input = scanner.nextLine();
        // Convertendo a entrada em uma lista de strings
        String[] servicosContratados = input.split(",");
        // Verificando se o cliente contratou um combo completo
        String resultado = verificarComboCompleto(servicosContratados);
        // Exibindo o resultado
        System.out.println(resultado);
        // Fechando o scanner
        scanner.close();
    }
}

Que, ao rodar a suite de testes, nos mostra que deu tudo certo:

O código desses (e dos demais) desafios está aqui.
Então é isso, pessoal. Até a próxima!

Das obige ist der detaillierte Inhalt vonCode Challenge – Erkundung von Telefoniediensten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!