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_VALUE
est la valeur maximale qu'un int
peut stocker en Java. Si vous atteignez Integer.MAX_VALUE
et augmentez cette valeur, vous revenez à Integer.MIN_VALUE
, ou plutôt à la Integer
valeur la plus basse possible. Ainsi, pour terminer cette tâche Java, nous devons simplement attribuer 1 de moins que la int
valeur maximale à la start
variable. 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 \u000d
comme 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-else
avec une for
boucle 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-else
instruction 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 unArrayList
, si vous préférez) qui contient tous les nombres Integer
de 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 ouArrayList
. 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);
}
}
GO TO FULL VERSION