Tâches Java avec une touche : bonjour, les entretiens !

Les meilleurs amis des étudiants de CodeGym sont les tâches de programmation, Java et le validateur de tâches. Pourtant, il arrive un moment où chaque développeur de padawan doit commencer à sortir des sentiers battus, inventer ses propres mini-projets et se préparer aux entretiens. On pourrait penser que l'entretien comporterait exactement les mêmes tâches Java pratiques que celles trouvées dans ce cours. Et c'est le cas dans la plupart des cas, mais certaines entreprises aiment poser des questions pièges ou quelque chose d'inhabituel. Pour éviter d'être secoué lors d'un entretien stressant, il est utile d'essayer de résoudre des tâches Java similaires par vous-même à la maison. Dans cet article, nous allons explorer 5 de ces tâches délicates. Nous vous recommandons de lire d'abord les conditions et d'essayer de les résoudre vous-même. Et encore une chose : n'oubliez pas de faire des tâches Java dans ce cours tous les jours !

• Tâche 1 : Créer une boucle infinie à partir de rien
• Tâche 2 : Créer un commentaire exécutable
• Tâche 3 : Créer une boucle nommée
• Tâche 4 : Rechercher un seul doublon dans un tableau d'entiers
• Tâche 5 : Rechercher un doublon non unique dans un tableau d'entiers

Tâche 1 : Créer une boucle infinie à partir de rien

Un bloc de code a été fourni. Ajoutez-y pour rendre la boucle infinie.

class ToInfinity {
    public static void main(String[] args) {

// Insert code here

        for (int i = start; i <= start + 1; i++) {
             /* This should be an infinite loop, but don't change anything here */
        }
    }
}

" Ce n'est pas difficile ", dites-vous. Vous vous êtes plus que probablement retrouvé dans ce scénario à plusieurs reprises : lors de l'exécution d'une tâche Java, vous avez créé une boucle infinie et avez dû réfléchir à la manière de vous en débarrasser. Eh bien, c'est l'inverse. Voici la partie délicate : vous ne pouvez pas modifier la boucle elle-même ou ses conditions de sortie. Il n'y a que deux itérations. Mais, ils sont suffisants pour créer une boucle infinie. Il semble qu'il ne devrait s'exécuter que pour deux itérations, mais vous pouvez le rendre infini en utilisant le débordement. Avez-vous déjà deviné comment ?

Solution

En raison du débordement, Integer.MAX_VALUEest la valeur maximale qu'un intpeut stocker en Java. Si vous atteignez Integer.MAX_VALUEet augmentez cette valeur, vous revenez à Integer.MIN_VALUE, ou plutôt à la Integervaleur la plus basse possible. Ainsi, pour terminer cette tâche Java, nous devons simplement attribuer 1 de moins que la intvaleur maximale à la startvariable. Code Java pour cette tâche :

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            // Infinite loop
            System.out.println(i); // Be sure we are in an infinite loop
        }
    }
}

Ce qui se produit? Nous commençons par start=2147483645 (Integer.MAX_VALUE-1). A l'itération suivante, la valeur devient 2147483645, puis 2147483646, puis -2147483648, -2147483647... et ainsi de suite.

Tâche 2 : Créer un commentaire exécutable

Eh bien, nous y sommes ! Dès les premières leçons, nous avons entendu dire que les commentaires ne sont pas exécutés. C'est pourquoi on les appelle des commentaires. Nous pensons que la solution à cette tâche ne sera pas toujours évidente pour les programmeurs Java, même les plus expérimentés. Cependant, il existe un moyen délicat (mais "légal") de faire en sorte que la JVM exécute un commentaire. Pouvez-vous sentir où nous allons? Essaie de deviner!

Solution

Code Java pour cette tâche :

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d System.out.println("executable comment");
    }
}

Si nous entrons ce code Java dans un IDE, voici ce que nous obtiendrons :

executable comment

En effet, le compilateur Java interprète le caractère Unicode \u000dcomme une nouvelle ligne et lit notre code comme suit : Code Java pour cette tâche, tel qu'il est interprété par le compilateur :

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d
        System.out.println("comment executed");
    }
}

Tâche 3 : Créer une boucle nommée

Voici un autre membre de la série intitulée "Practical Java Programming Problems for Spherical Cows". Dans le sens où on ne sait pas pourquoi cela est même nécessaire : il est peu probable que la boucle soit offensée par le fait qu'elle n'a pas reçu de nom. Quoi qu'il en soit, c'est important pour une autre raison : le langage permet de nommer une boucle.

Solution

Remarque : ces "noms" sont connus de certaines personnes sous le nom d'"étiquettes" et leur utilisation n'est pas recommandée dans la pratique. Code Java pour démontrer une boucle nommée

public class NamedLoop {
    public static void main(String[] args) {
        loop1:
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i == 3)
                    break loop1;
                System.out.println("i = " + i + " j = " + j);
            }
        }
    }
}

Voici ce qui sera affiché si vous exécutez le programme :

i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 0 j = 3
i = 0 j = 4
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 1 j = 4
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2
i = 2 j = 3
i = 2 j = 4

Vous pouvez également utiliser le mot clé continue pour revenir au début d'une boucle nommée. Et si nécessaire, vous pouvez utiliser break(ou continue) dans un imbriqué if-elseavec une forboucle pour décomposer plusieurs boucles à l'aide d'un if-else. Cela aidera à éviter de créer un grand nombre d'indicateurs et de les vérifier dans une if-elseinstruction pour déterminer s'il faut continuer ou quitter la boucle interne.

Tâche 4 : Rechercher un seul doublon dans un tableau d'entiers

On vous donne un tableau d'entiers (ou un ArrayList, si vous préférez) qui contient tous les nombres Integerde 1 à 100. Le tableau a un et un seul élément en double. Comment tu le trouves? Il est plus courant pour un programmeur Java d'obtenir ce type de tâche que les trois précédents. Parce qu'il s'agit de logique plutôt que de votre connaissance des subtilités rarement utilisées de la langue. Votre première impulsion effrénée à utiliser la force brute passera assez rapidement lorsque votre cerveau s'activera ou que vous réaliserez "Je suis un programmeur. Je suis intelligent." Le seul problème est que lors d'un entretien, lorsque vous êtes stressé, cela peut ne pas arriver. Alors réfléchissez maintenant avant de regarder la solution !

Voici l'algorithme

Calculez la somme de tous les nombres de 1 à 100. Nous pensons que vous savez comment vous pouvez faire cela (par exemple, en utilisant la célèbre méthode de Gauss). Calculez maintenant la somme des éléments de votre tableau ou ArrayList. Et... soustrayez la première somme de la seconde. Bingo ! Le nombre résultant est la valeur de l'élément dupliqué. Code Java pour cette tâche à l'aide d'un fichier ArrayList.

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class FindDuplicate {
    private static void findDuplicate(List<Integer> elements) {

        int distinctSum = elements.stream().distinct().mapToInt(e -> e).sum();
// Find the sum of all list elements
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("The repeated element is: " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
// Create a list of sequential elements in the interval [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
// Add the value 23 at index 53
        elements.set(53, 23);
        findDuplicate(elements);
    }
}

Une autre solution

import java.util.List;
import java.util.ArrayList;

public class Duplicate {

    public int findDuplicateNumber(List<Integer> numbers) {

        int highestNumber = numbers.size() - 1;
        int total = getSum(numbers);
        int duplicate = total - (highestNumber * (highestNumber + 1) / 2);
        return duplicate;
    }

    public int getSum(List<Integer> numbers) {

        int sum = 0;
        for (int num : numbers) {
            sum = sum + num;
        }
        return sum;
    }

    public static void main(String a[]) {
        List <Integer> numbers = new ArrayList <Integer>();
        for (int i = 1; i < 100; i++) {
            numbers.add(i);
        }
        // Add a duplicate to the list
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("The repeated element is: " + dn.findDuplicateNumber(numbers));
    }
}

Tâche 5 : Rechercher un doublon non unique dans un tableau d'entiers

Si la tâche précédente était trop facile pour vous, essayez de faire celle-ci : on vous donne une liste d'entiers de 1 à 100. Il y a des doublons (plus d'un). Comment trouvez-vous les éléments qui se produisent plus d'une fois (trouvez les éléments et indiquez combien de fois ils se produisent) ?

Solution

Ici, la solution logique serait d'utiliser quelque chose comme un HashMap, car il stocke les données dans des paires clé-valeur. Code pour cette tâche en Java :

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SomeDuplicates {
    private static void findDuplicates(List<Integer> elements) {
        HashMap <Integer, Integer> duplicates = new HashMap <>();
// Use the following rule to populate the Map duplicates:
// the key is the element value, and the value is the number of times it occurs
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
// Remove any elements that don't occur more than once from the Map duplicates
// and store the result as a list (to make it easy to work with in the next step)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
// Write the results for all elements to the result list
        result.forEach(e -> System.out.println(String.format("Element %d  occurs %d times", e.getKey(), e.getValue())));
    }

    public static void main(String[] args) {
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
        elements.set(97, 23);
        elements.set(27, 51);
        elements.set(99, 23);
        findDuplicates(elements);
    }
}

Conclusion

Il existe de nombreux types de tâches Java pratiques et vous ne savez pas quel type d'énigmes l'intervieweur vous demandera de résoudre. Mais, tout employeur sensé comprend que votre capacité à accomplir de vraies tâches pratiques , comme celles que vous rencontrerez au travail, est beaucoup plus importante que votre capacité à résoudre des questions pièges. Alors faites-les autant que possible. C'est pourquoi nous avons créé CodeGym. Le matériel de geeksforgeeks a été utilisé pour créer cet article.