De beste vrienden van CodeGym- studenten zijn programmeertaken, Java en de taakvalidator. Toch komt er een tijd dat elke padawan-ontwikkelaar buiten de gebaande paden moet gaan lopen, zijn eigen miniprojecten moet uitvinden en zich moet voorbereiden op interviews. Je zou denken dat het interview exact dezelfde praktische Java-taken bevat die in deze cursus voorkomen. En zo is het in de meeste gevallen, maar sommige bedrijven stellen graag strikvragen of iets onbekends. Om te voorkomen dat je tijdens een stressvol sollicitatiegesprek van streek raakt, is het handig om soortgelijke Java-taken zelf thuis op te lossen.
In dit artikel zullen we 5 van zulke lastige taken onderzoeken. Wij raden u aan om eerst de voorwaarden te lezen en zelf te proberen deze op te lossen. En nog een ding: vergeet niet elke dag Java-taken in deze cursus te doen!
Er is een codeblok verstrekt. Voeg toe om de lus oneindig te maken.
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 */
}
}
}
" Dat is niet moeilijk ", zegt u. U bent hoogstwaarschijnlijk herhaaldelijk in dit scenario terechtgekomen: tijdens het voltooien van een Java-taak creëerde u een oneindige lus en moest u nadenken over hoe u deze kunt verwijderen. Nou, dit is andersom. Dit is het lastige gedeelte: je kunt de lus zelf of de exit-voorwaarden niet wijzigen. Er zijn slechts twee iteraties. Maar ze zijn voldoende om een oneindige lus te creëren. Het lijkt erop dat het maar voor twee iteraties zou moeten worden uitgevoerd, maar je kunt het oneindig maken met behulp van overflow. Heb je al geraden hoe?
Oplossing
Vanwege overflow Integer.MAX_VALUEis dit de maximale waarde die een intin Java kan opslaan. Als u Integer.MAX_VALUEdeze waarde bereikt en verhoogt, rolt u terug naar Integer.MIN_VALUE, of beter gezegd, naar de laagst mogelijke Integerwaarde. intOm deze Java-taak te voltooien, moeten we dus gewoon 1 minder dan de maximale waarde aan de variabele toewijzen start. Java-code voor deze taak:
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
}
}
}
Wat gebeurt er? We beginnen met start=2147483645 (Integer.MAX_VALUE-1). In de volgende iteratie wordt de waarde 2147483645, dan 2147483646, dan -2147483648, -2147483647... enzovoort.
Taak 2: Maak een uitvoerbare opmerking
Nou, hier zijn we dan! Vanaf de allereerste lessen hebben we gehoord dat opmerkingen niet worden uitgevoerd. Daarom heten ze commentaren. We denken dat de oplossing voor deze taak niet altijd voor de hand ligt voor Java-programmeurs, zelfs niet voor ervaren programmeurs. Er is echter een lastige (maar "legale") manier om de JVM een opmerking te laten uitvoeren. Kun je voelen waar we naartoe gaan? Probeer te raden!
Oplossing
Java-code voor deze taak:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Als we deze Java-code in een IDE invoeren, krijgen we het volgende:
executable comment
Dit komt omdat de Java-compiler het Unicode-teken interpreteert \u000dals een nieuwe regel en onze code als volgt leest: Java-code voor deze taak, zoals deze wordt geïnterpreteerd door de compiler:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
Taak 3: maak een benoemde lus
Hier is nog een lid van de serie getiteld "Praktische Java-programmeerproblemen voor sferische koeien". In die zin dat het onduidelijk is waarom dit zelfs maar nodig is: het is niet waarschijnlijk dat de lus beledigd zal zijn door het feit dat het geen naam heeft gekregen. Hoe dan ook, het is om een andere reden belangrijk: de taal laat je een lus een naam geven.
Oplossing
Let op: deze "namen" zijn bij sommige mensen bekend als "labels", en het wordt niet aanbevolen om ze in de praktijk te gebruiken. Java-code voor het demonstreren van een benoemde lus
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);
}
}
}
}
Dit is wat er wordt uitgevoerd als u het programma uitvoert:
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
U kunt ook het trefwoord continue gebruiken om terug te keren naar het begin van een benoemde lus. En indien nodig kunt u break(of continue) gebruiken in een geneste if-elsemet een forlus om meerdere lussen te onderbreken met behulp van een if-else. Dit helpt voorkomen dat er een groot aantal vlaggen wordt gemaakt en deze in een if-elseinstructie worden gecontroleerd om te bepalen of de binnenste lus moet worden voortgezet of verlaten.
Taak 4: Zoek een enkel duplicaat in een reeks gehele getallen
U krijgt een integer-array (of een ArrayList, als u dat liever hebt) die elk Integervan 1 tot 100 bevat. De array heeft één en slechts één gedupliceerd element. Hoe vind je het? Het komt vaker voor dat een Java-programmeur dit soort taken krijgt dan de vorige drie. Omdat het meer om logica gaat dan om uw kennis van zelden gebruikte subtiliteiten van de taal. Je eerste ongebreidelde impuls om brute kracht te gebruiken, zal vrij snel voorbijgaan als je hersens beginnen of je beseft: "Ik ben een programmeur. Ik ben slim." Het enige probleem is dat tijdens een sollicitatiegesprek, als je onder stress staat, dit misschien niet gebeurt. Dus denk nu na voordat je naar de oplossing kijkt!
Hier is het algoritme
Bereken de som van alle getallen van 1 tot 100. We denken dat je weet hoe je dit kunt doen (bijvoorbeeld met behulp van de beroemde methode van Gauss). Bereken nu de som van de elementen in uw array of ArrayList. En... trek de eerste som af van de tweede. Bingo! Het resulterende getal is de waarde van het gedupliceerde element. Java-code voor deze taak met behulp van een 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);
}
}
Een andere oplossing
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));
}
}
Taak 5: Zoek een niet-uniek duplicaat in een reeks gehele getallen
Als de vorige taak te gemakkelijk voor je was, probeer dan deze: Je krijgt een lijst met gehele getallen van 1 tot 100. Er zitten duplicaten in (meer dan één). Hoe vind je de elementen die meer dan één keer voorkomen (vind de elementen en geef aan hoe vaak ze voorkomen)?
Oplossing
Hier zou de logische oplossing zijn om zoiets als een HashMap te gebruiken, omdat het de gegevens opslaat in sleutel-waardeparen. Code voor deze taak 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);
}
}
Conclusie
Er zijn veel verschillende soorten praktische Java-taken en je weet niet wat voor soort puzzels de interviewer je zal vragen op te lossen. Maar elke verstandige werkgever begrijpt dat uw vermogen om echte praktische taken uit te voeren , zoals die u tijdens uw werk zult tegenkomen, veel belangrijker is dan uw vermogen om strikvragen op te lossen. Doe deze dus zoveel mogelijk. Daarom hebben we CodeGym gemaakt. Materiaal van geeksforgeeks is gebruikt om dit artikel te maken.
GO TO FULL VERSION