Code Challenge - Exploring Telephony Services

One of the things that I find really cool about DIO bootcamps is that during the trail there are some code exercises to be carried out, with an editor nearby and some conditions; a bit of a HackerRank vibe like that. It's really cool because it helps to consolidate the knowledge acquired during the theoretical parts and it's not a more complex approach like the project challenge: it's something more simplified, to test your logical reasoning and your knowledge of the language. Just like HackerRank, they give you some ready-made snippets and you develop your logic based on that.

This week was crazy, so the only thing I managed to do was solve the two challenges proposed in the module "Exploring Telephony Services". As the sponsor of this bootcamp is Claro, many of the themes will have a telecom flavor.

Contracted Service Verification

Statement:

A telecommunications concessionaire offers four types of services: mobile telephony, fixed telephony, broadband and pay TV. To facilitate customer service, it is necessary to implement a program that checks whether a specific customer has contracted a certain service. For example, when a customer calls the call center and mentions a service, the attendant must be able to quickly check whether that service is contracted by the customer.

Prohibited:

Two strings: One with the service that the application will check (for example, mobile, fixed, broadband, TV). The second must contain the customer's name and which products they have, separated by a comma (Alice, mobile, fixed)

Expected output:

If the customer contracted the service described in the first entry, the application must display Yes. Otherwise, it must display No.

Examples:

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 uneboucle foret vérifiemanuellementsi 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 toujoursJava. 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 versla 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 lesvaleursentre 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 syntaxelambda. 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!

The above is the detailed content of Code Challenge - Exploring Telephony Services. For more information, please follow other related articles on the PHP Chinese website!