Mga gawain sa Java na may twist: kumusta, mga panayam!

Ang pinakamatalik na kaibigan ng mga mag-aaral ng CodeGym ay mga gawain sa programming, Java, at ang validator ng gawain. Gayunpaman, darating ang panahon na ang bawat developer ng padawan ay dapat magsimulang lumayo sa landas, mag-imbento ng sarili niyang mini-proyekto, at ihanda ang sarili para sa mga panayam. Iisipin ng isa na ang panayam ay magkakaroon ng eksaktong parehong praktikal na mga gawain sa Java na matatagpuan sa kursong ito. At gayon din sa karamihan ng mga kaso, ngunit ang ilang mga kumpanya ay gustong magtanong ng mga trick na tanong o isang bagay na hindi pamilyar. Upang maiwasang magalit sa panahon ng isang nakaka-stress na panayam, makatutulong na subukang lutasin ang mga katulad na gawain sa Java nang mag-isa sa bahay.

Sa artikulong ito, tutuklasin natin ang 5 ganoong nakakalito na gawain. Inirerekomenda namin na basahin mo muna ang mga kundisyon at subukang lutasin ang mga ito sa iyong sarili. At isa pang bagay: huwag kalimutang gawin ang mga gawain sa Java sa kursong ito araw-araw!

Gawain 1: Gumawa ng isang walang katapusang loop mula sa simula

Isang bloke ng code ang ibinigay. Idagdag dito para maging infinite ang loop.

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 */
        }
    }
}

" Hindi iyon mahirap, " sabi mo. Malamang na paulit-ulit mong natagpuan ang iyong sarili sa sitwasyong ito: habang kinukumpleto ang isang gawain sa Java, lumikha ka ng isang walang katapusang loop at kailangan mong isipin kung paano ito aalisin. Well, ito ay kabaligtaran. Narito ang nakakalito na bahagi: hindi mo mababago ang loop mismo o ang mga kundisyon sa paglabas nito. Mayroon lamang dalawang pag-ulit. Ngunit, sapat na ang mga ito upang lumikha ng isang walang katapusang loop. Mukhang dapat lang itong isakatuparan para sa dalawang pag-ulit, ngunit maaari mong gawin itong walang katapusan gamit ang overflow. Nahulaan mo na ba kung paano?

Solusyon

Dahil sa overflow, Integer.MAX_VALUEay ang pinakamataas na halaga na intmaaaring iimbak sa Java. Kung maabot Integer.MAX_VALUEat dagdagan mo ang halagang ito, babalik ka sa Integer.MIN_VALUE, o sa halip, sa pinakamababang posibleng Integerhalaga. Kaya, para makumpleto ang gawaing Java na ito, kailangan lang nating magtalaga ng 1 na mas mababa sa maximum na inthalaga sa startvariable. Java code para sa gawaing ito:

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
        }
    }
}

Ano ang mangyayari? Magsisimula tayo sa simula=2147483645 (Integer.MAX_VALUE-1). Sa susunod na pag-ulit, ang value ay magiging 2147483645, pagkatapos ay 2147483646, pagkatapos ay -2147483648, -2147483647... at iba pa.

Gawain 2: Gumawa ng maipapatupad na komento

Nandito na tayo! Mula sa pinakaunang mga aralin, narinig namin na ang mga komento ay hindi isinasagawa. Kaya nga tinatawag silang comments. Sa tingin namin, ang solusyon sa gawaing ito ay hindi palaging magiging halata sa mga programmer ng Java, kahit na sa mga may karanasan. Gayunpaman, mayroong isang nakakalito (ngunit "legal") na paraan upang magsagawa ng komento ang JVM. Naiintindihan mo ba kung saan tayo patungo? Hulaan mo!

Solusyon

Java code para sa gawaing ito:

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d System.out.println("executable comment");
    }
}

Kung ilalagay natin ang Java code na ito sa isang IDE, narito ang makukuha natin:

executable comment

Ito ay dahil binibigyang kahulugan ng Java compiler ang Unicode character \u000dbilang isang bagong linya, at binabasa ang aming code tulad nito: Java code para sa gawaing ito, dahil ito ay binibigyang kahulugan ng compiler:

public class ExecutableComment {
    public static void main(String[] args) {
        // The comment below will be executed!
        // \u000d
        System.out.println("comment executed");
    }
}

Gawain 3: Gumawa ng pinangalanang loop

Narito ang isa pang miyembro ng serye na pinamagatang "Practical Java Programming Problems for Spherical Cows". Sa diwa na hindi malinaw kung bakit kailangan pa ito: hindi malamang na masaktan ang loop sa katotohanang hindi ito nabigyan ng pangalan. Anyway, mahalaga ito sa isa pang dahilan: hinahayaan ka ng wika na pangalanan ang isang loop.

Solusyon

Tandaan: ang mga "pangalan" na ito ay kilala sa ilang mga tao bilang "mga label", at hindi inirerekomenda na gamitin ang mga ito sa pagsasanay. Java code para sa pagpapakita ng isang pinangalanang 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);
            }
        }
    }
}

Narito kung ano ang magiging output kung patakbuhin mo ang programa:

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

Maaari mo ring gamitin ang keyword na patuloy na bumalik sa simula ng isang pinangalanang loop. At kung kinakailangan, maaari mong gamitin break(o continue) sa isang nested if-elsena may isang forloop upang masira ang ilang mga loop gamit ang isang if-else. Makakatulong ito na maiwasan ang paggawa ng malaking bilang ng mga flag at suriin ang mga ito sa isang if-elsepahayag upang matukoy kung magpapatuloy o lalabas sa panloob na loop.

Gawain 4: Maghanap ng isang duplicate sa isang hanay ng mga integer

Bibigyan ka ng integer array (o isang ArrayList, kung gusto mo) na naglalaman ng bawat Integermula 1 hanggang 100. Ang array ay may isa, at isa lamang, dobleng elemento. Paano mo ito mahahanap? Mas karaniwan para sa isang Java programmer na makakuha ng ganitong uri ng gawain kaysa sa naunang tatlo. Dahil ito ay tungkol sa lohika kaysa sa iyong kaalaman sa mga bihirang ginagamit na subtleties ng wika. Ang iyong unang walang pigil na salpok na gumamit ng malupit na puwersa ay lilipas nang mabilis kapag ang iyong utak ay sumipa o napagtanto mong "Ako ay isang programmer. Ako ay matalino." Ang problema lang ay kapag nasa isang panayam, kapag ikaw ay nasa ilalim ng stress, maaaring hindi ito mangyari. Kaya isipin mo muna bago mo tingnan ang solusyon!

Narito ang algorithm

Kalkulahin ang kabuuan ng lahat ng mga numero mula 1 hanggang 100. Sa tingin namin ay alam mo kung paano mo ito magagawa (halimbawa, gamit ang sikat na paraan ni Gauss). Ngayon kalkulahin ang kabuuan ng mga elemento sa iyong array o ArrayList. At... ibawas ang unang kabuuan sa pangalawa. Bingo! Ang resultang numero ay ang halaga ng duplicate na elemento. Java code para sa gawaing ito gamit ang isang 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);
    }
}

Isa pang solusyon

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));
    }
}

Gawain 5: Maghanap ng di-natatanging duplicate sa hanay ng mga integer

Kung ang nakaraang gawain ay napakadali para sa iyo, subukang gawin ang isang ito: Bibigyan ka ng isang listahan ng mga integer mula 1 hanggang 100. May mga duplicate dito (higit sa isa). Paano mo mahahanap ang mga elemento na nangyayari nang higit sa isang beses (hanapin ang mga elemento at ipahiwatig kung gaano karaming beses naganap ang mga ito)?

Solusyon

Narito ang lohikal na solusyon ay ang paggamit ng isang bagay tulad ng isang HashMap, dahil iniimbak nito ang data sa mga pares ng key-value. Code para sa gawaing ito sa 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);
    }
}

Konklusyon

Mayroong maraming iba't ibang uri ng mga praktikal na gawain sa Java, at hindi mo alam kung anong uri ng mga palaisipan ang hihilingin sa iyo ng tagapanayam na lutasin. Ngunit, nauunawaan ng sinumang matalinong tagapag-empleyo na ang iyong kakayahang kumpletuhin ang mga tunay na praktikal na gawain , tulad ng mga makakaharap mo sa trabaho, ay higit na mahalaga kaysa sa iyong kakayahang lutasin ang mga tanong sa panlilinlang. Kaya gawin ang mga ito hangga't maaari. Iyon ang dahilan kung bakit ginawa namin ang CodeGym. Ginamit ang materyal mula sa mga geeksforgeeks upang likhain ang artikulong ito.

Higit pang pagbabasa:
Java Junior Interview Prep. Pinakamahusay na Mga Website na May Mga Tanong, Video at Mock na Panayam Paggalugad ng mga tanong at sagot mula sa isang job interview para sa isang Java developer position. Bahagi 12 Nangungunang 21 tanong sa panayam sa Java Paggalugad ng mga tanong at sagot mula sa isang job interview para sa isang Java developer position. Bahagi 4