Code Challenge - Explorer les services de téléphonie

Une des choses que je trouve vraiment cool dans les bootcamps DIO, c'est que pendant le trail il y a quelques exercices de code à réaliser, avec un éditeur à proximité et certaines conditions ; un peu une ambiance HackerRank comme ça. C'est vraiment cool car ça permet de consolider les connaissances acquises lors des parties théoriques et ce n'est pas une approche plus complexe comme le défi projet : c'est quelque chose de plus simplifié, pour tester ton raisonnement logique et ta connaissance de la langue. Tout comme HackerRank, ils vous donnent des extraits prêts à l'emploi et vous développez votre logique sur cette base.

Cette semaine a été folle, alors la seule chose que j'ai réussi à faire a été de résoudre les deux défis proposés dans le module "Explorer les services de téléphonie". Comme le sponsor de ce bootcamp est Claro, de nombreux thèmes auront une saveur télécom.

Vérification des services sous contrat

Déclaration:

Un concessionnaire de télécommunications propose quatre types de services : téléphonie mobile, téléphonie fixe, haut débit et télévision payante. Pour faciliter le service client, il est nécessaire de mettre en œuvre un programme qui vérifie si un client spécifique a souscrit à un certain service. Par exemple, lorsqu'un client appelle le centre d'appels et mentionne un service, le préposé doit pouvoir vérifier rapidement si ce service est souscrit par le client.

Interdit:

Deux chaînes : Une avec le service que l'application va vérifier (par exemple, mobile, fixe, haut débit, TV). La seconde doit contenir le nom du client et les produits dont il dispose, séparés par une virgule (Alice, mobile, fixe)

Résultat attendu :

Si le client a souscrit au service décrit dans la première entrée, l'application doit afficher Oui. Sinon, elle doit afficher Non.

Exemples :

Code initial :

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();
    }
}

Résolution:

C'est un défi relativement simple. L'application reçoit une chaîne délimitée par des virgules qui est transformée en tableau et nous devons savoir s'il contient une chaîne qui correspond à une autre entrée utilisateur, qui est le service dont nous voulons vérifier si le client dispose. Facile, non ?

Pour moi, qui a un historique de JavaScript et de C#, utilisez simplement une méthode de vérification (comme Array.includes() ou List.Contains()). Droite? Faux.

En Java, il n'existe pas de méthode comme celle-ci dans la classe Array. Cela peut être dû au fait que l'implémentation est beaucoup plus proche de ce qui se passe dans les langages de bas niveau (tels que C), ce qui établit qu'il doit s'agir de structures de données simples et efficaces. Apparemment ce type de requête ne fait pas partie des fonctions essentielles de cette structure.

Découvrir cette information a été un choc. Qu’est-ce que Java attend de moi ? Que j'écris une boucle for et vérifie manuellement si chaque élément correspond à l'élément que je recherche ? Frère, je travaille à temps plein, j'ai une fille de moins de deux ans et j'étudie toujours Java. Je n'ai pas le temps pour ça, mec.

Mais j'ai découvert que depuis Java 8 il est possible de convertir le tableau en liste et celle-ci possède la méthode .contains(). Donc, pour résoudre ce problème, convertissez simplement le tableau de pièces en liste, puis vérifiez si la chaîne transmise dans le service existe dans cette liste.
S'il existe, on imprime Oui et sinon, on imprime Non.

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();
    }
}

Avec cela l'exercice est terminé, mais au cours des recherches que j'ai faites j'ai découvert que depuis Java 8 il existe une abstraction qui permet de travailler avec des collections de données de manière plus simple et avec une approche plus fonctionnelle, similaire à ce qui existe en JavaScript : les ruisseaux.

Tout comme avec les listes, nous pouvons convertir le vecteur en flux et vérifier si l'un des éléments présents correspond à ce qui a été transmis dans le service :

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();
    }
}

Nous aurions pu effectuer la vérification en passant un rappel à la méthode .anyMatch(p -> p == servico), mais cela vérifie si p et servico ont non seulement la même valeur mais pointent également vers la même adresse mémoire (c'est-à-dire s'il s'agit en fait du même objet). Normalement, lorsqu'il s'agit de chaînes, cette comparaison renvoie false même si la valeur est égale, c'est-à-dire un faux négatif. Par conséquent, la comparaison utilisant servico::equals est plus appropriée, car elle compare uniquement les valeurs entre les deux éléments, plus ou moins comme le comparateur d'égalité de JavaScript (==).

Avec ce changement, on peut juger que l'exercice est terminé. Il ne reste plus qu'à lancer les tests et voir s'ils réussissent :

Trop bien.
Cet exercice m'a donné une autre raison de me plaindre de Java, qui est la syntaxe lambda. L'utilisation de la flèche simple (->) au lieu de la flèche double (=>) me dérange beaucoup.

Vérification d'embauche combinée complète

Déclaration:

Mettre en place un système qui vérifie si un client d'une entreprise de télécommunications a souscrit à une combinaison complète de services. Un combo complet comprend les trois principaux services proposés par l'entreprise : téléphonie mobile, haut débit et télévision payante. Le système doit lire une liste de services contractés par le client et déterminer si tous les services nécessaires sont inclus. Si les trois services sont présents, le système doit renvoyer « Complete Combo ». Si l'un des services est manquant, le système devrait renvoyer "Combo incomplet".

Interdit:

Une chaîne contenant les services souscrits par le client, séparés par une virgule. Les valeurs possibles sont le mobile, le haut débit et la télévision.

Résultat attendu :

Une chaîne contenant Complete Combo si le client dispose de tous les services souscrits, Incomplete Combo sinon.

Exemples :

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!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!