A CodeGym tanulók legjobb barátai a programozási feladatok, a Java és a feladatellenőrző. Mégis, eljön az idő, amikor minden padawan fejlesztőnek el kell kezdenie letérni a kitaposott ösvényről, ki kell találnia saját miniprojektjét, és fel kell készülnie az interjúkra. Azt gondolhatnánk, hogy az interjú pontosan ugyanazokat a gyakorlati Java feladatokat tartalmazza, mint ebben a kurzusban. És ez a legtöbb esetben így van, de egyes cégek szeretnek trükkös kérdéseket vagy valami ismeretlen dolgot feltenni. Annak elkerülése érdekében, hogy egy stresszes interjú során ne zörögjenek fel, hasznos, ha megpróbálja egyedül megoldani a hasonló Java feladatokat otthon.
Ebben a cikkben 5 ilyen trükkös feladatot fogunk megvizsgálni. Javasoljuk, hogy először olvassa el a feltételeket, és próbálja meg saját maga megoldani azokat. És még valami: ne felejts el minden nap Java feladatokat elvégezni ezen a tanfolyamon!
1. feladat: Hozz létre egy végtelen hurkot a semmiből
Egy kódblokk biztosított. Add hozzá, hogy a hurok végtelen legyen.
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 */
}
}
}
" Ez nem nehéz " - mondod. Több mint valószínű, hogy többször is ebben a forgatókönyvben találta magát: egy Java-feladat végrehajtása közben végtelen hurkot hozott létre, és azon kellett gondolkodnia, hogyan szabadulhat meg tőle. Nos, ez fordítva van. Itt van a trükkös rész: magát a hurkot vagy annak kilépési feltételeit nem tudod megváltoztatni. Csak két iteráció van. De ezek elegendőek egy végtelen hurok létrehozásához. Úgy tűnik, hogy csak két iterációt kell végrehajtania, de a túlcsordulás használatával végtelenné teheti. Kitaláltad már, hogyan?
Megoldás
A túlcsordulás miatt Integer.MAX_VALUEa maximális érték, amelyet egy intJava-ban tárolhat. Ha eléri Integer.MAX_VALUEés növeli ezt az értéket, akkor visszalép a -ra Integer.MIN_VALUE, vagy inkább a lehető legalacsonyabb Integerértékre. Így ennek a Java-feladatnak a végrehajtásához egyszerűen a maximális értéknél 1-gyel kevesebbet kell rendelnünk inta startváltozóhoz. Java kód ehhez a feladathoz:
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
}
}
}
Mi történik? Kezdjük azzal, hogy start=2147483645 (Integer.MAX_VALUE-1). A következő iterációban az érték 2147483645, majd 2147483646, majd -2147483648, -2147483647... és így tovább.
2. feladat: Hozzon létre egy végrehajtható megjegyzést
Nos, itt vagyunk! Az első óráktól kezdve azt hallottuk, hogy a megjegyzéseket nem hajtják végre. Ezért nevezik ezeket kommenteknek. Úgy gondoljuk, hogy ennek a feladatnak a megoldása nem mindig lesz nyilvánvaló a Java programozók számára, még a tapasztaltabbak számára sem. Van azonban egy trükkös (de "legális") módja annak, hogy a JVM megjegyzést hajtson végre. Érzi, merre tartunk? Próbáld meg kitalálni!
Megoldás
Java kód ehhez a feladathoz:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Ha ezt a Java kódot beírjuk egy IDE-be, a következőket kapjuk:
executable comment
Ennek az az oka, hogy a Java fordító a Unicode karaktert \u000dúj sorként értelmezi, és így olvassa be a kódunkat: Java kód erre a feladatra, ahogyan azt a fordító értelmezi:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
3. feladat: Hozzon létre egy elnevezett hurkot
Íme a sorozat másik tagja, melynek címe "Gyakorlati Java programozási problémák gömbölyű tehenek számára". Abban az értelemben, hogy nem világos, miért is van erre szükség: nem valószínű, hogy a hurok megsértődik attól, hogy nem kapott nevet. Különben is, ez egy másik okból is fontos: a nyelv lehetővé teszi egy ciklus elnevezését.
Megoldás
Megjegyzés: ezeket a "neveket" egyesek "címkékként" ismerik, és a gyakorlatban nem ajánlott használni őket. Java kód egy elnevezett ciklus bemutatására
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);
}
}
}
}
Íme, mi fog megjelenni, ha futtatja a programot:
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
Használhatja a tovább kulcsszót is, hogy visszatérjen egy elnevezett ciklus elejére. És ha szükséges, használhatja break(vagy continue) if-elseegy forciklussal egymásba ágyazott ciklusban, hogy több ciklust felszakítson egy if-else. Ez segít elkerülni, hogy nagyszámú jelzőt hozzon létre, és ellenőrizze őket egy if-elseutasításban, hogy megállapítsa, folytatni kell-e vagy ki kell-e lépni a belső ciklusból.
4. feladat: Keressen egyetlen ismétlődést egy egész számokból álló tömbben
Kapunk egy egész tömböt (vagy egy tömböt ArrayList, ha úgy tetszik), amely Integer1-től 100-ig minden számot tartalmaz. A tömbnek egy és csak egy ismétlődő eleme van. Hogyan találja meg? Gyakrabban fordul elő, hogy egy Java programozó kap ilyen típusú feladatot, mint az előző három. Mert ez inkább a logikáról szól, mint a nyelv ritkán használt finomságainak ismeretéről. Az első féktelen késztetésed a nyers erő alkalmazására meglehetősen gyorsan elmúlik, amikor az agyad beindul, vagy rájössz, hogy "programozó vagyok. okos vagyok." Az egyetlen probléma az, hogy egy interjú során, amikor stresszes vagy, ez nem biztos, hogy megtörténik. Tehát most gondolkozz, mielőtt a megoldást néznéd!
Íme az algoritmus
Számítsa ki az összes szám összegét 1-től 100-ig. Úgy gondoljuk, tudja, hogyan teheti ezt meg (például Gauss híres módszerével). Most számítsa ki a vagy a tömb elemeinek összegét ArrayList. És... vonjuk le az első összeget a másodikból. Bingó! Az eredményül kapott szám az ismétlődő elem értéke. Java kód ehhez a feladathoz egy 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);
}
}
Egy másik megoldás
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));
}
}
5. feladat: Keress egy nem egyedi másolatot egy egész számokból álló tömbben
Ha az előző feladat túl könnyű volt számodra, próbálkozz a következővel: Kapsz egy listát az egész számokról 1-től 100-ig. Vannak benne duplikátumok (több mint egy). Hogyan találja meg a többször előforduló elemeket (keresse meg az elemeket, és adja meg, hogy hányszor fordul elő)?
Megoldás
Itt az lenne a logikus megoldás, ha valami HashMap-hez hasonlót használnánk, mert az kulcs-érték párokban tárolja az adatokat. A feladat kódja Java nyelven:
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);
}
}
Következtetés
Sokféle gyakorlati Java feladat létezik, és nem tudhatod, milyen rejtvények megoldására kér majd a kérdező. De minden értelmes munkáltató megérti, hogy a valódi gyakorlati feladatok elvégzésének képessége , mint amilyenekkel a munka során találkozni fog, sokkal fontosabb, mint a trükkös kérdések megoldásának képessége. Tehát csináld ezeket, amennyire csak tudod. Ezért hoztuk létre a CodeGymet. A cikk elkészítéséhez a geeksforgeeks anyagát használták fel.
GO TO FULL VERSION