Problèmes Java avec une astuce : bonjour, interviews !

Pour les étudiants JavaRush , les défis de programmation, Java et le validateur sont les meilleurs amis. Cependant, il arrive un moment pour chaque développeur Padawan où il doit parfois commencer à sortir des sentiers battus, imaginer des mini-projets pour lui-même et préparer des entretiens. Lors de l'entretien, il semblerait que vous rencontriez exactement les mêmes problèmes pratiques Java que lors du cours. Dans la plupart des cas, cela est vrai, mais certaines entreprises aiment poser des questions pièges ou quelque chose d'inhabituel. Pour éviter d'être confus lors d'un entretien stressant, il est utile d'essayer de résoudre ces problèmes Java vous-même, à la maison. Dans cet article, nous examinerons une demi-douzaine de ces tâches délicates. Nous vous recommandons de lire d'abord la condition et d'essayer de la résoudre vous-même. Et encore une chose : n’oubliez pas de résoudre chaque jour les problèmes Java du cours !

• Tâche 1 : Créer une boucle infinie à partir de zéro
• Tâche-2. Créer un commentaire qui sera exécuté
• Tâche 3 : Créer une boucle nommée
• Tâche-4. À propos d'un seul double dans un tableau d'entiers
• Tâche-5. À propos d'un doublon non unique dans un tableau d'entiers

Problème Java - 1 : Créer une boucle infinie à partir de zéro

Étant donné un bloc de code. Complétez-le pour que la boucle devienne infinie.

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

//впишите code сюда

        for (int i = start; i <= start + 1; i++) {
             /* тут должен быть бесконечный цикл, менять ничего нельзя*/
        }
    }
}

« Rien de compliqué », dites-vous. Très probablement, vous vous êtes retrouvé dans cette situation plus d'une fois : en résolvant des problèmes Java, vous avez créé une boucle infinie et réfléchi à la manière de vous en débarrasser. C'est l'inverse. Le problème est que le cycle lui-même et les conditions pour en sortir ne peuvent pas être modifiés. Il n'y a que deux itérations. Cependant, ils sont suffisamment nombreux pour créer une boucle infinie. Il semble que cela ne devrait fonctionner que pendant deux itérations, mais cela peut être rendu infini en utilisant le débordement. Avez-vous déjà deviné comment ?

Solution

En raison d'un débordement. Integer.MAX_VALUEest la valeur maximale pouvant intêtre stockée en Java. Si vous atteignez Integer.MAX_VALUEet incrémentez cette valeur, vous descendez jusqu'à Integer.MIN_VALUE, c'est-à-dire jusqu'à la valeur minimale Integer. Ainsi, pour résoudre ce problème Java, il suffit d'attribuer startà la variable une valeur inférieure de 1 à la valeur maximale du type de données int. Code de tâche en Java :

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            //бесконечный цикл
            System.out.println(i); //убеждаемся в бесконечности цикла
        }
    }
}

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

Tâche Java 2. Créer un commentaire qui sera exécuté

Eh bien, nous y sommes ! Dès les premières conférences, nous avons entendu dire que les commentaires ne sont pas exécutés. C'est pourquoi ce sont des commentaires. Nous pensons que la solution à ce problème n’est pas toujours évidente pour un programmeur Java, même expérimenté. Cependant, il existe un moyen délicat de forcer la machine Java à exécuter « légalement » un commentaire pour exécution. Sentez-vous d’où vient le vent ? Essaie de deviner!

Solution

Code pour résoudre le problème en Java :

public class ExecutableComment {
    public static void main(String[] args) {
        // комментарий ниже будет выполнен!
        // \u000d System.out.println("выполняемый комментарий");
    }
}

Si nous tapons le code de cette tâche en Java dans l'EDI, voici ce que nous obtenons :

выполняемый комментарий

La raison en est que le compilateur Java lit le caractère Unicod \u000dcomme une nouvelle ligne et lit notre code comme suit : Le compilateur a déchiffré le code pour résoudre le problème en Java :

public class ExecutableComment {
    public static void main(String[] args) {
        // the line below this gives an output
        // \u000d
        System.out.println("comment executed");
    }
}

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

Un autre représentant de la série « Problèmes pratiques de programmation, Java dans le vide sphérique ». Dans le sens où l’on ne sait pas pourquoi cela est nécessaire, il est peu probable que le cycle se sente offensé par le fait qu’il soit impersonnel. Bon, d'accord, autre chose est important : le langage permet de donner un nom au cycle.

Solution

Remarque : pour certains, ces « noms » sont connus sous le nom de « balises », dont l'utilisation n'est pas recommandée dans la pratique. Code pour résoudre le problème en Java, démontrant 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 le résultat 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

Ici, vous pouvez également utiliser continue pour aller au début d'une boucle nommée. Et si nécessaire, vous pouvez utiliser break(ou continue) dans une boucle if-elsewith forimbriquée pour diviser plusieurs boucles en utilisant if-else. Cela permettra d'éviter de définir de nombreux indicateurs et de les tester if-elsepour déterminer s'il faut continuer ou quitter la boucle interne.

Problème Java - 4. À propos du seul doublon dans un tableau d'entiers

Étant donné un tableau (ou ArrayList, comme vous préférez) d'entiers contenant des éléments Integerde 1 à 100. Ce tableau a un et un seul élément dupliqué. Comment le trouver ? De telles tâches sont plus familières à un programmeur Java que les trois précédentes. Car il ne s’agit pas de connaître les subtilités du langage, qui ne sont presque jamais utilisées, mais de logique. La première impulsion effrénée de résoudre par la force brute disparaît assez rapidement lorsque votre tête s'éveille ou qu'il y a une attitude "Je suis un programmeur, je suis intelligent". Le seul inconvénient est que lors d'un entretien, sous le stress, cela peut ne pas se produire. Alors réfléchissez maintenant avant de chercher la solution !

L'algorithme de résolution est le suivant :

Calculez la somme de tous les nombres de 1 à 100. Nous pensons que vous savez comment faire (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 le premier montant du second. Bingo ! Le nombre résultant est la valeur de l'élément en double. Code de solution au problème Java pour 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();
//находим сумму всех элементов списка
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("Элемент, который повторяется : " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
//создаем список последовательных элементов на промежутке [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
//устанавливаем элементу с индексом 53 meaning 23
        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);
        }
        //добавляем дубликат в список
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("Элемент, который повторяется: " + dn.findDuplicateNumber(numbers));
    }
}

Problème Java - 5. À propos d'un doublon non unique dans un tableau d'entiers

Si le problème précédent vous a semblé trop simple, alors essayez de résoudre le suivant : étant donné une feuille d'entiers de 1 à 100. Elle contient des doublons (plus d'un). Comment trouver des éléments qui apparaissent plus d'une fois (trouver l'élément lui-même et indiquer combien de fois il apparaît) ?

Solution

La solution la plus logique ici consiste à utiliser une structure telle que HashMap, car elle stocke les données dans des paires clé-valeur. Code pour résoudre le problème 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 < >();
//заполняем Map duplicates значениями по принципу:
// ключ – meaning element, meaning – сколько раз он встречается
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
//из duplicates убираем все элементы, которые встретorсь не более 1 раза,
//и сохраняем //результат в список (для удобства обработки на следующем шаге)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
//выводим результат для всех элементов в списке result
        result.forEach(e -> System.out.println(String.format("Элемент %d  встречается %d раз", 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

Les problèmes pratiques de Java sont très différents et vous ne savez pas quel genre de puzzle inconnu l'intervieweur décidera de vous proposer. Cependant, tout employeur adéquat comprend que bien plus importante que la capacité à résoudre des problèmes Java délicats sera votre capacité à résoudre de vrais problèmes pratiques , tels que ceux que vous rencontrerez au cours de votre travail. Alors résolvez-les autant que possible. C'est pourquoi JavaRush a été créé. Des matériaux provenant de geeksforgeeks ont été utilisés pour préparer cet article.