Mga problema sa Java sa isang trick: Kumusta, mga panayam!

Para sa mga mag-aaral ng JavaRush , ang mga hamon sa programming, Java, at ang validator ay matalik na kaibigan. Gayunpaman, darating ang panahon para sa bawat developer na si Padawan na kailangan niyang magsimulang lumayo minsan, gumawa ng mga mini-proyekto para sa kanyang sarili at maghanda para sa mga panayam. Sa panayam, mukhang dapat kang makatagpo ng eksaktong parehong praktikal na mga problema sa Java tulad ng sa kurso. Sa karamihan ng mga kaso ito ay totoo, ngunit ang ilang mga kumpanya ay gustong magtanong ng mga trick na tanong o isang bagay na hindi karaniwan. Upang maiwasang malito sa panahon ng isang nakababahalang panayam, kapaki-pakinabang na subukang lutasin ang mga naturang problema sa Java sa iyong sarili, sa bahay. Sa artikulong ito titingnan natin ang kalahating dosenang mga nakakalito na gawain na ito. Inirerekomenda namin na basahin mo muna ang kundisyon at subukang lutasin ito sa iyong sarili. At isa pang bagay: huwag kalimutang lutasin ang mga problema sa Java mula sa kurso araw-araw!

• Gawain-1: Paglikha ng isang walang katapusang loop mula sa simula
• Gawain-2. Gumawa ng komento na isasagawa
• Gawain-3: Gumawa ng pinangalanang loop
• Gawain-4. Tungkol sa isang solong duplicate sa isang hanay ng mga integer
• Gawain-5. Tungkol sa isang hindi natatanging duplicate sa isang hanay ng mga integer

Problema sa Java - 1: Paglikha ng isang walang katapusang loop mula sa simula

Binigyan ng isang bloke ng code. Kumpletuhin ito upang ang loop ay maging walang katapusan.

class ToInfinity {
    public static void main(String[] args) {

//впишите code сюда

        for (int i = start; i <= start + 1; i++) {
             /* тут должен быть бесконечный цикл, менять ничего нельзя*/
        }
    }
}

"Walang kumplikado," sabi mo. Malamang, natagpuan mo ang iyong sarili sa sitwasyong ito nang higit sa isang beses: habang nilulutas ang mga problema sa Java, lumikha ka ng isang walang katapusang loop at naisip kung paano ito aalisin. Baliktad naman. Ang lansihin ay ang cycle mismo at ang mga kondisyon para sa paglabas nito ay hindi mababago. Mayroon lamang dalawang pag-ulit. Gayunpaman, mayroong sapat sa kanila upang lumikha ng isang walang katapusang loop. Mukhang dapat lang itong gumana para sa dalawang pag-ulit, ngunit maaari itong gawing walang katapusan sa pamamagitan ng paggamit ng overflow. Nahulaan mo na ba kung paano?

Solusyon

Dahil sa pag-apaw. Integer.MAX_VALUEay ang pinakamataas na halaga na intmaaaring maimbak sa Java. Kung naabot Integer.MAX_VALUEat dinaragdagan mo ang halagang ito, i-roll down mo sa Integer.MIN_VALUE, iyon ay, sa pinakamababang halaga Integer. Kaya, upang malutas ang problemang ito sa Java, kailangan lang nating magtalaga ng isang starthalaga sa variable na 1 mas mababa kaysa sa maximum na halaga para sa uri ng data int. Task code sa Java:

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            //бесконечный цикл
            System.out.println(i); //убеждаемся в бесконечности цикла
        }
    }
}

Ano ang mangyayari? Magsisimula tayo sa start=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.

Java task-2. Gumawa ng komento na isasagawa

Nandito na tayo! Mula sa pinakaunang mga lektura narinig namin na ang mga komento ay hindi naisakatuparan. Iyon ang mga komento nila. Sa tingin namin na ang solusyon sa problemang ito ay hindi palaging halata para sa isang Java programmer, kahit na isang may karanasan. Gayunpaman, mayroong isang nakakalito na paraan upang pilitin ang Java machine na "ligal" na magpatakbo ng komento para sa pagpapatupad. Nararamdaman mo ba kung saan nanggagaling ang hangin? Hulaan mo!

Solusyon

Code para sa paglutas ng problema sa Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // комментарий ниже будет выполнен!
        // \u000d System.out.println("выполняемый комментарий");
    }
}

Kung ita-type natin ang code para sa gawaing ito sa Java sa IDE, ito ang makukuha natin:

выполняемый комментарий

Ang dahilan ay binabasa ng Java compiler ang Unicod character \u000dbilang isang bagong linya, at binabasa ang aming code tulad ng sumusunod: Ang compiler ay nag-decipher ng code para sa paglutas ng problema sa Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // the line below this gives an output
        // \u000d
        System.out.println("comment executed");
    }
}

Java Task - 3: Lumikha ng pinangalanang loop

Isa pang kinatawan ng serye na "mga problema sa praktikal na programming, Java sa isang spherical vacuum." Sa diwa na hindi malinaw kung bakit ito kinakailangan, malamang na ang pag-ikot ay nararamdaman na nasaktan sa katotohanan na ito ay hindi personal. Well, okay, may iba pang mahalaga: pinapayagan ka ng wika na bigyan ng pangalan ang cycle.

Solusyon

Tandaan: sa ilan, ang mga naturang "pangalan" ay kilala bilang "mga tag", na hindi inirerekomenda na gamitin sa pagsasanay. Code para sa paglutas ng problema sa Java, na nagpapakita 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);
            }
        }
    }
}

Ito 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

Dito maaari mo ring gamitin ang continue to go sa simula ng isang pinangalanang loop. At kung kinakailangan, maaari mong gamitin break(o continue) sa isang nested if-elsena may for-loop upang masira ang ilang mga loop gamit ang if-else. Makakatulong ito na maiwasan ang pagtatakda ng maraming mga flag at subukan ang mga ito if-elseupang malaman kung magpapatuloy o lalabas sa panloob na loop.

Problema sa Java - 4. Tungkol sa tanging duplicate sa isang hanay ng mga integer

Ibinigay ang array (o ArrayList, ayon sa gusto mo) ng mga integer na naglalaman ng mga elemento Integermula 1 hanggang 100. Ang array na ito ay may isa at isa lamang na dobleng elemento. Paano ito mahahanap? Ang ganitong mga gawain ay mas pamilyar sa isang Java programmer kaysa sa nakaraang tatlo. Dahil ito ay hindi tungkol sa pag-alam sa mga subtleties ng wika, na halos hindi ginagamit, ngunit tungkol sa lohika. Ang unang walang pigil na salpok upang malutas sa pamamagitan ng malupit na puwersa ay mabilis na nawawala kapag ang iyong ulo ay umikot o may saloobin na "Ako ay isang programmer, ako ay matalino." Ang masama lang ay sa panahon ng isang panayam, sa ilalim ng stress, maaaring hindi ito mangyari. Kaya mag-isip ngayon bago mo tingnan ang solusyon!

Ang algorithm ng solusyon ay ang mga sumusunod:

Kalkulahin ang kabuuan ng lahat ng mga numero mula 1 hanggang 100. Sa tingin namin ay alam mo na kung paano gawin ito (halimbawa, gamit ang sikat na paraan ng Gauss). Ngayon kalkulahin ang kabuuan ng mga elemento ng iyong array o ArrayList’а. At... ibawas ang unang halaga sa pangalawa. Bingo! Ang resultang numero ay ang halaga ng duplicate na elemento. Java problem solution code para sa 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();
//находим сумму всех элементов списка
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("Элемент, который повторяется : " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
//создаем список последовательных элементов на промежутке [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
//устанавливаем элементу с индексом 53 meaning 23
        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);
        }
        //добавляем дубликат в список
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("Элемент, который повторяется: " + dn.findDuplicateNumber(numbers));
    }
}

Problema sa Java - 5. Tungkol sa isang hindi natatanging duplicate sa isang hanay ng mga integer

Kung ang nakaraang problema ay tila napakadali para sa iyo, pagkatapos ay subukang lutasin ang sumusunod: binigyan ng isang sheet ng mga integer mula 1 hanggang 100. Naglalaman ito ng mga duplicate (higit sa isa). Paano mahahanap ang mga elemento na nangyayari nang higit sa isang beses (hanapin ang elemento mismo at ipahiwatig kung gaano karaming beses ito nangyayari)?

Solusyon

Ang pinakalohikal na solusyon dito ay ang paggamit ng isang istraktura tulad ng HashMap, dahil nag-iimbak ito ng data sa mga pares ng key-value. Code para sa paglutas ng problema 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 < >();
//заполняем Map duplicates значениями по принципу:
// ключ – meaning element, meaning – сколько раз он встречается
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
//из duplicates убираем все элементы, которые встретorсь не более 1 раза,
//и сохраняем //результат в список (для удобства обработки на следующем шаге)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
//выводим результат для всех элементов в списке result
        result.forEach(e -> System.out.println(String.format("Элемент %d  встречается %d раз", 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

Ang mga praktikal na problema sa Java ay ibang-iba, at hindi mo alam kung anong uri ng hindi kilalang palaisipan ang magpapasya na ibigay sa iyo ng tagapanayam. Gayunpaman, nauunawaan ng sinumang sapat na tagapag-empleyo na higit na mahalaga kaysa sa iyong kakayahang lutasin ang mga nakakalito na problema sa Java ay ang iyong kakayahang lutasin ang mga tunay na praktikal na problema , tulad ng mga makakaharap mo sa iyong trabaho. Kaya lutasin ang mga ito hangga't maaari. Ito ang dahilan kung bakit nilikha ang JavaRush. Ginamit ang mga materyales mula sa geeksforgeeks sa paghahanda ng artikulong ito.