CodeGym- studerendes bedste venner er programmeringsopgaver, Java og opgavevalidatoren. Alligevel kommer der et tidspunkt, hvor enhver padawan-udvikler skal begynde at gå uden for den slagne vej, opfinde sine egne miniprojekter og forberede sig til interviews. Man skulle tro, at interviewet ville have præcis de samme praktiske Java-opgaver, som findes i dette kursus. Og sådan er det i de fleste tilfælde, men nogle virksomheder kan godt lide at stille trick spørgsmål eller noget ukendt. For at undgå at blive raslet under et stressende interview, er det nyttigt at prøve at løse lignende Java-opgaver på egen hånd derhjemme.
I denne artikel vil vi udforske 5 sådanne vanskelige opgaver. Vi anbefaler, at du først læser betingelserne og prøver at løse dem selv. Og en ting mere: Glem ikke at lave Java-opgaver i dette kursus hver dag!
Der er leveret en kodeblok. Tilføj til det for at gøre løkken uendelig.
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 */
}
}
}
" Det er ikke svært, " siger du. Du har mere end sandsynligt befundet dig i dette scenarie gentagne gange: mens du fuldførte en Java-opgave, oprettede du en uendelig løkke og måtte tænke på, hvordan du skulle slippe af med den. Nå, det er omvendt. Her er den vanskelige del: du kan ikke ændre selve løkken eller dens udgangsbetingelser. Der er kun to iterationer. Men de er nok til at skabe en uendelig løkke. Det ser ud til, at det kun skal køre i to iterationer, men du kan gøre det uendeligt ved at bruge overløb. Har du allerede gættet hvordan?
Løsning
På grund af overløb Integer.MAX_VALUEer den maksimale værdi, som en intkan gemme i Java. Hvis du når Integer.MAX_VALUEog øger denne værdi, ruller du tilbage til Integer.MIN_VALUEeller rettere sagt til den lavest mulige Integerværdi. For at fuldføre denne Java-opgave skal vi blot tildele 1 mindre end den maksimale intværdi til startvariablen. Java-kode til denne opgave:
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
}
}
}
Hvad der sker? Vi begynder med start=2147483645 (Integer.MAX_VALUE-1). I den næste iteration bliver værdien 2147483645, derefter 2147483646, derefter -2147483648, -2147483647... og så videre.
Opgave 2: Opret en eksekverbar kommentar
Nå, her er vi! Fra de allerførste lektioner har vi hørt, at kommentarer ikke udføres. Det er derfor, de kaldes kommentarer. Vi tror, at løsningen på denne opgave ikke altid vil være indlysende for Java-programmører, heller ikke erfarne. Der er dog en vanskelig (men "lovlig") måde at få JVM til at udføre en kommentar. Kan du fornemme, hvor vi er på vej hen? Forsøge at gætte!
Løsning
Java-kode til denne opgave:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Hvis vi indtaster denne Java-kode i en IDE, får vi her:
executable comment
Dette skyldes, at Java-kompileren fortolker Unicode-tegnet \u000dsom en ny linje, og læser vores kode således: Java-kode til denne opgave, som den fortolkes af compileren:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
Opgave 3: Opret en navngivet løkke
Her er endnu et medlem af serien med titlen "Praktiske Java-programmeringsproblemer for sfæriske køer". I den forstand, at det er uklart, hvorfor det overhovedet er nødvendigt: Det er ikke sandsynligt, at løkken vil blive stødt af, at den ikke har fået et navn. Det er i hvert fald vigtigt af en anden grund: sproget lader dig navngive en loop.
Løsning
Bemærk: disse "navne" er kendt af nogle mennesker som "etiketter", og de anbefales ikke at bruge i praksis. Java-kode til at demonstrere en navngivet loop
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);
}
}
}
}
Her er, hvad der vil blive output, hvis du kører programmet:
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
Du kan også bruge nøgleordet fortsæt for at vende tilbage til begyndelsen af en navngivet sløjfe. Og hvis det er nødvendigt, kan du bruge break(eller continue) i en indlejret if-elsemed en forløkke til at bryde flere løkker op ved hjælp af en if-else. Dette vil hjælpe med at undgå at oprette et stort antal flag og kontrollere dem i en if-elseerklæring for at afgøre, om du vil fortsætte eller forlade den indre løkke.
Opgave 4: Find en enkelt dublet i en række heltal
Du får et heltalsarray (eller et ArrayList, hvis du foretrækker det), der indeholder hver Integerfra 1 til 100. Arrayet har et og kun ét dubletelement. Hvordan finder du det? Det er mere almindeligt for en Java-programmør at få denne type opgaver end de tre foregående. For det handler om logik frem for din viden om sjældent brugte finesser i sproget. Din første uhæmmede impuls til at bruge brute force vil passere ret hurtigt, når din hjerne sætter ind, eller du indser "Jeg er en programmør. Jeg er smart." Det eneste problem er, at under et interview, når du er under stress, sker det måske ikke. Så tænk nu, før du ser på løsningen!
Her er algoritmen
Beregn summen af alle tal fra 1 til 100. Vi tror, du ved, hvordan du kan gøre dette (f.eks. ved at bruge Gauss' berømte metode). Beregn nu summen af elementerne i dit array eller ArrayList. Og... træk den første sum fra den anden. Bingo! Det resulterende tal er værdien af det duplikerede element. Java-kode til denne opgave ved hjælp af en 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);
}
}
En anden løsning
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));
}
}
Opgave 5: Find en ikke-unik duplikat i en række heltal
Hvis den forrige opgave var for nem for dig, så prøv at udføre denne: Du får en liste over heltal fra 1 til 100. Der er dubletter i den (mere end én). Hvordan finder man de elementer, der forekommer mere end én gang (find elementerne og angiv, hvor mange gange de forekommer)?
Løsning
Her ville den logiske løsning være at bruge noget som et HashMap, fordi det gemmer dataene i nøgle-værdi-par. Kode til denne opgave i 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);
}
}
Konklusion
Der er mange forskellige slags praktiske Java-opgaver, og du ved ikke, hvilken slags gåder, intervieweren vil bede dig om at løse. Men enhver fornuftig arbejdsgiver forstår, at din evne til at udføre rigtige praktiske opgaver , som dem du vil støde på på jobbet, er meget vigtigere end din evne til at løse trickspørgsmål. Så gør disse så meget som muligt. Derfor har vi skabt CodeGym. Materiale fra geeksforgeeks blev brugt til at skabe denne artikel.
GO TO FULL VERSION