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.
![Java-opgaver med et twist: hej, interviews! - 1]()
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!
- Opgave 1: Skab en uendelig løkke fra bunden
- Opgave 2: Opret en eksekverbar kommentar
- Opgave 3: Opret en navngivet løkke
- Opgave 4: Find en enkelt dublet i en række heltal
- Opgave 5: Find en ikke-unik duplikat i en række heltal
Opgave 1: Skab en uendelig løkke fra bunden
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 */
}
}
}
Løsning
På grund af overløbInteger.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
}
}
}
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");
}
}
executable comment
\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);
}
}
}
}
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
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 etArrayList, 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 ellerArrayList. 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);
}
}
GO TO FULL VERSION