I migliori amici degli studenti di CodeGym sono attività di programmazione, Java e il validatore di attività. Tuttavia, arriva un momento in cui ogni sviluppatore padawan deve iniziare a uscire dai sentieri battuti, inventare i propri mini-progetti e prepararsi per le interviste. Si potrebbe pensare che l'intervista abbia esattamente le stesse attività pratiche Java che si trovano in questo corso. E così è nella maggior parte dei casi, ma ad alcune aziende piace fare domande trabocchetto o qualcosa di non familiare. Per evitare di essere scosso durante un colloquio stressante, è utile provare a risolvere compiti Java simili da soli a casa.
In questo articolo, esploreremo 5 compiti così complicati. Ti consigliamo di leggere prima le condizioni e provare a risolverle da solo. E un'altra cosa: non dimenticare di svolgere attività Java in questo corso ogni giorno!
È stato fornito un blocco di codice. Aggiungi ad esso per rendere il ciclo infinito.
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 */
}
}
}
" Non è difficile ", dici. Molto probabilmente ti sei trovato ripetutamente in questo scenario: durante il completamento di un'attività Java, hai creato un ciclo infinito e hai dovuto pensare a come sbarazzartene. Bene, questo è il contrario. Ecco la parte difficile: non puoi cambiare il ciclo stesso o le sue condizioni di uscita. Ci sono solo due iterazioni. Ma sono sufficienti per creare un ciclo infinito. Sembra che dovrebbe essere eseguito solo per due iterazioni, ma puoi renderlo infinito usando l'overflow. Hai già indovinato come?
Soluzione
A causa dell'overflow, Integer.MAX_VALUEè il valore massimo che intpuò essere memorizzato in Java. Se raggiungi Integer.MAX_VALUEe incrementi questo valore, ritorni a Integer.MIN_VALUE, o meglio, al Integervalore più basso possibile. Pertanto, per completare questa attività Java, è sufficiente assegnare intalla startvariabile 1 in meno del valore massimo. Codice Java per questa attività:
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
}
}
}
Che succede? Iniziamo con start=2147483645 (Integer.MAX_VALUE-1). Nell'iterazione successiva, il valore diventa 2147483645, quindi 2147483646, quindi -2147483648, -2147483647... e così via.
Attività 2: creare un commento eseguibile
Bene, eccoci qui! Fin dalle prime lezioni, abbiamo sentito che i commenti non vengono eseguiti. Ecco perché si chiamano commenti. Pensiamo che la soluzione a questo compito non sarà sempre ovvia per i programmatori Java, anche quelli esperti. Tuttavia, esiste un modo complicato (ma "legale") per fare in modo che JVM esegua un commento. Riesci a percepire dove siamo diretti? Provare ad indovinare!
Soluzione
Codice Java per questa attività:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Se inseriamo questo codice Java in un IDE, ecco cosa otterremo:
executable comment
Questo perché il compilatore Java interpreta il carattere Unicode \u000dcome una nuova riga e legge il nostro codice in questo modo: Codice Java per questa attività, così come viene interpretato dal compilatore:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
Attività 3: crea un loop con nome
Ecco un altro membro della serie intitolata "Practical Java Programming Problems for Spherical Cows". Nel senso che non è chiaro perché ciò sia necessario: non è probabile che il loop venga offeso dal fatto che non gli è stato dato un nome. Ad ogni modo, è importante per un altro motivo: il linguaggio ti consente di nominare un loop.
Soluzione
Nota: questi "nomi" sono noti ad alcune persone come "etichette" e non è consigliabile utilizzarli nella pratica. Codice Java per la dimostrazione di un ciclo denominato
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);
}
}
}
}
Ecco cosa verrà prodotto se esegui il programma:
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
È inoltre possibile utilizzare la parola chiave continue per tornare all'inizio di un ciclo denominato. E se necessario, puoi usare break(o continue) in un annidato if-elsecon un forciclo per spezzare più cicli usando un if-else. Ciò contribuirà a evitare di creare un numero elevato di flag e di controllarli in un'istruzione if-elseper determinare se continuare o uscire dal ciclo interno.
Compito 4: trova un singolo duplicato in un array di numeri interi
Ti viene fornito un array di interi (o un ArrayList, se preferisci) che contiene ogni numero Integerda 1 a 100. L'array ha uno e solo un elemento duplicato. Come lo trovi? È più comune per un programmatore Java ottenere questo tipo di attività rispetto alle tre precedenti. Perché si tratta di logica piuttosto che della tua conoscenza di sottigliezze del linguaggio usate raramente. Il tuo primo impulso sfrenato a usare la forza bruta passerà piuttosto rapidamente quando il tuo cervello entra in azione o realizzi "Sono un programmatore. Sono intelligente". L'unico problema è che durante un colloquio, quando sei sotto stress, questo potrebbe non accadere. Quindi pensa ora prima di guardare la soluzione!
Ecco l'algoritmo
Calcola la somma di tutti i numeri da 1 a 100. Pensiamo che tu sappia come farlo (ad esempio, usando il famoso metodo di Gauss). Ora calcola la somma degli elementi nel tuo array o ArrayList. E... sottrai la prima somma dalla seconda. Tombola! Il numero risultante è il valore dell'elemento duplicato. Codice Java per questa attività utilizzando un file 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);
}
}
Un'altra soluzione
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));
}
}
Attività 5: trova un duplicato non univoco in un array di numeri interi
Se l'attività precedente è stata troppo facile per te, prova a fare questa: ti viene fornito un elenco di numeri interi da 1 a 100. Ci sono duplicati in esso (più di uno). Come trovi gli elementi che si verificano più di una volta (trova gli elementi e indica quante volte si verificano)?
Soluzione
Qui la soluzione logica sarebbe usare qualcosa come HashMap, perché memorizza i dati in coppie chiave-valore. Codice per questa attività in 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);
}
}
Conclusione
Esistono molti tipi diversi di attività pratiche in Java e non sai che tipo di enigmi l'intervistatore ti chiederà di risolvere. Ma qualsiasi datore di lavoro ragionevole comprende che la tua capacità di completare compiti pratici reali , come quelli che incontrerai sul posto di lavoro, è molto più importante della tua capacità di risolvere domande trabocchetto. Quindi fallo il più possibile. Ecco perché abbiamo creato CodeGym. Il materiale di geeksforgeeks è stato utilizzato per creare questo articolo.
GO TO FULL VERSION