ట్విస్ట్‌తో జావా టాస్క్‌లు: హలో, ఇంటర్వ్యూలు!

కోడ్‌జిమ్ విద్యార్థుల మంచి స్నేహితులు ప్రోగ్రామింగ్ టాస్క్‌లు, జావా మరియు టాస్క్ వాలిడేటర్. అయినప్పటికీ, ప్రతి పదవాన్ డెవలపర్ కూడా తన సొంత చిన్న-ప్రాజెక్టులను కనిపెట్టి, ఇంటర్వ్యూలకు సిద్ధపడాల్సిన సమయం వస్తుంది. ఇంటర్వ్యూలో ఈ కోర్సులో కనిపించే ఖచ్చితమైన ప్రాక్టికల్ జావా టాస్క్‌లు ఉంటాయని అనుకోవచ్చు. మరియు చాలా సందర్భాలలో ఇది జరుగుతుంది, కానీ కొన్ని కంపెనీలు ట్రిక్ ప్రశ్నలు లేదా తెలియని వాటిని అడగడానికి ఇష్టపడతాయి. ఒత్తిడితో కూడిన ఇంటర్వ్యూలో గందరగోళానికి గురికాకుండా ఉండటానికి, ఇంట్లో మీ స్వంతంగా ఇలాంటి జావా టాస్క్‌లను పరిష్కరించడానికి ప్రయత్నించడం సహాయకరంగా ఉంటుంది.

ఈ వ్యాసంలో, మేము అలాంటి 5 గమ్మత్తైన పనులను అన్వేషిస్తాము. మీరు మొదట షరతులను చదివి, వాటిని మీరే పరిష్కరించడానికి ప్రయత్నించాలని మేము సిఫార్సు చేస్తున్నాము. మరియు మరొక విషయం: ప్రతిరోజూ ఈ కోర్సులో జావా పనులు చేయడం మర్చిపోవద్దు!

టాస్క్ 1: మొదటి నుండి అనంతమైన లూప్‌ను సృష్టించండి

కోడ్ బ్లాక్ అందించబడింది. లూప్‌ను అనంతంగా చేయడానికి దానికి జోడించండి.

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

" అది కష్టం కాదు, " మీరు అంటున్నారు. మీరు ఈ దృష్టాంతంలో పదే పదే మిమ్మల్ని కనుగొన్నారు: జావా టాస్క్‌ను పూర్తి చేస్తున్నప్పుడు, మీరు అనంతమైన లూప్‌ను సృష్టించారు మరియు దాన్ని ఎలా వదిలించుకోవాలో ఆలోచించాల్సి వచ్చింది. సరే, ఇది మరో మార్గం. ఇక్కడ గమ్మత్తైన భాగం: మీరు లూప్‌ను లేదా దాని నిష్క్రమణ పరిస్థితులను మార్చలేరు. రెండు పునరావృత్తులు మాత్రమే ఉన్నాయి. కానీ, అవి అనంతమైన లూప్‌ను సృష్టించడానికి సరిపోతాయి. ఇది రెండు పునరావృతాల కోసం మాత్రమే అమలు చేయాలని కనిపిస్తోంది, కానీ మీరు ఓవర్‌ఫ్లో ఉపయోగించి దీన్ని అనంతంగా చేయవచ్చు. ఎలా అని మీరు ఇప్పటికే ఊహించారా?

పరిష్కారం

ఓవర్‌ఫ్లో కారణంగా, ఇది జావాలో నిల్వ చేయగల Integer.MAX_VALUEగరిష్ట విలువ . intమీరు Integer.MAX_VALUEఈ విలువను చేరుకుని, పెంచినట్లయితే, మీరు వెనుకకు వెళ్లండి Integer.MIN_VALUE, లేదా బదులుగా, సాధ్యమైనంత తక్కువ Integerవిలువకు. intఈ విధంగా, ఈ జావా పనిని పూర్తి చేయడానికి, మనం వేరియబుల్‌కు గరిష్ట విలువ కంటే 1 తక్కువగా కేటాయించాలి start. ఈ టాస్క్ కోసం జావా కోడ్:

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

ఏం జరుగుతుంది? మేము start=2147483645 (Integer.MAX_VALUE-1)తో ప్రారంభిస్తాము. తదుపరి పునరావృతంలో, విలువ 2147483645 అవుతుంది, ఆపై 2147483646, ఆపై -2147483648, -2147483647... మరియు మొదలైనవి.

టాస్క్ 2: ఎక్జిక్యూటబుల్ వ్యాఖ్యను సృష్టించండి

బాగా, మేము ఇక్కడ ఉన్నాము! మొదటి పాఠాల నుండి, వ్యాఖ్యలు అమలు చేయబడవని మేము విన్నాము. అందుకే వాటిని వ్యాఖ్యలు అంటారు. ఈ టాస్క్‌కి పరిష్కారం ఎల్లప్పుడూ జావా ప్రోగ్రామర్‌లకు, అనుభవజ్ఞులకు కూడా స్పష్టంగా కనిపించదని మేము భావిస్తున్నాము. అయితే, JVM వ్యాఖ్యను అమలు చేయడానికి ఒక గమ్మత్తైన (కానీ "చట్టపరమైన") మార్గం ఉంది. మేము ఎక్కడికి వెళ్తున్నామో మీరు గ్రహించగలరా? ఊహించడానికి ప్రయత్నించండి!

పరిష్కారం

ఈ టాస్క్ కోసం జావా కోడ్:

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

మనం ఈ జావా కోడ్‌ని IDEలో నమోదు చేస్తే, మనం పొందేది ఇక్కడ ఉంది:

executable comment

ఎందుకంటే జావా కంపైలర్ యూనికోడ్ క్యారెక్టర్‌ని \u000dకొత్త లైన్‌గా అన్వయిస్తుంది మరియు మా కోడ్‌ని ఇలా చదువుతుంది: ఈ టాస్క్ కోసం జావా కోడ్, కంపైలర్ ద్వారా వివరించబడింది:

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

టాస్క్ 3: పేరున్న లూప్‌ను సృష్టించండి

"గోళాకార ఆవుల కోసం ప్రాక్టికల్ జావా ప్రోగ్రామింగ్ సమస్యలు" పేరుతో సిరీస్‌లోని మరొక సభ్యుడు ఇక్కడ ఉన్నారు. ఇది ఎందుకు అవసరమో అస్పష్టంగా ఉంది అనే కోణంలో: లూప్‌కు పేరు పెట్టబడనందున మనస్తాపం చెందే అవకాశం లేదు. ఏది ఏమైనప్పటికీ, ఇది మరొక కారణంతో ముఖ్యమైనది: భాష మిమ్మల్ని లూప్‌కు పేరు పెట్టడానికి అనుమతిస్తుంది.

పరిష్కారం

గమనిక: ఈ "పేర్లు" కొంతమందికి "లేబుల్స్"గా తెలుసు మరియు వాటిని ఆచరణలో ఉపయోగించడానికి సిఫారసు చేయబడలేదు. పేరున్న లూప్‌ను ప్రదర్శించడానికి జావా కోడ్

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(లేదా ) ఉపయోగించవచ్చు . ఇది పెద్ద సంఖ్యలో ఫ్లాగ్‌లను సృష్టించడం మరియు ఇన్నర్ లూప్‌ను కొనసాగించాలా లేదా నిష్క్రమించాలా వద్దా అని నిర్ణయించడానికి వాటిని స్టేట్‌మెంట్‌లో తనిఖీ చేయడాన్ని నివారించడంలో సహాయపడుతుంది. continueif-elseforif-elseif-else

టాస్క్ 4: పూర్ణాంకాల శ్రేణిలో ఒకే నకిలీని కనుగొనండి

ArrayListమీకు పూర్ణాంక శ్రేణి (లేదా ఒక , మీరు కావాలనుకుంటే) ఇవ్వబడింది , అది Integer1 నుండి 100 వరకు ప్రతి ఒక్కటి కలిగి ఉంటుంది. శ్రేణిలో ఒకటి మరియు ఒకే ఒక నకిలీ మూలకం ఉంటుంది. మీరు దానిని ఎలా కనుగొంటారు? మునుపటి మూడింటి కంటే జావా ప్రోగ్రామర్ ఈ రకమైన పనిని పొందడం సర్వసాధారణం. ఎందుకంటే ఇది లాజిక్ గురించి కాకుండా భాష యొక్క అరుదుగా ఉపయోగించే సూక్ష్మబేధాల గురించి మీ జ్ఞానం గురించి. బ్రూట్ ఫోర్స్‌ని ఉపయోగించాలనే మీ మొదటి అపరిమిత ప్రేరణ మీ మెదడులోకి ప్రవేశించినప్పుడు లేదా "నేను ప్రోగ్రామర్‌ని. నేను తెలివైనవాడిని" అని మీరు గ్రహించినప్పుడు త్వరగా దాటిపోతుంది. ఒకే సమస్య ఏమిటంటే, ఇంటర్వ్యూలో, మీరు ఒత్తిడిలో ఉన్నప్పుడు, ఇది జరగకపోవచ్చు. కాబట్టి మీరు పరిష్కారాన్ని చూసే ముందు ఇప్పుడు ఆలోచించండి!

అల్గోరిథం ఇక్కడ ఉంది

1 నుండి 100 వరకు ఉన్న అన్ని సంఖ్యల మొత్తాన్ని లెక్కించండి. మీరు దీన్ని ఎలా చేయగలరో మీకు తెలుసని మేము భావిస్తున్నాము (ఉదాహరణకు, గాస్ యొక్క ప్రసిద్ధ పద్ధతిని ఉపయోగించి). ఇప్పుడు మీ శ్రేణిలోని మూలకాల మొత్తాన్ని లెక్కించండి లేదా ArrayList. మరియు... మొదటి మొత్తాన్ని రెండవదాని నుండి తీసివేయండి. పేకాట! ఫలిత సంఖ్య నకిలీ మూలకం యొక్క విలువ. ఈ టాస్క్ కోసం జావా కోడ్ ఒక 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);
    }
}

మరొక పరిష్కారం

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: పూర్ణాంకాల శ్రేణిలో నాన్-యూనిక్ డూప్లికేట్‌ను కనుగొనండి

మునుపటి పని మీకు చాలా సులభం అయితే, దీన్ని ప్రయత్నించండి: మీకు 1 నుండి 100 వరకు పూర్ణాంకాల జాబితా ఇవ్వబడింది. దానిలో నకిలీలు ఉన్నాయి (ఒకటి కంటే ఎక్కువ). మీరు ఒకసారి కంటే ఎక్కువసార్లు సంభవించే మూలకాలను ఎలా కనుగొంటారు (మూలకాలను కనుగొని, అవి ఎన్నిసార్లు సంభవిస్తాయో సూచించండి)?

పరిష్కారం

ఇక్కడ తార్కిక పరిష్కారం HashMap వంటిది ఉపయోగించడం, ఎందుకంటే ఇది డేటాను కీ-విలువ జతలలో నిల్వ చేస్తుంది. జావాలో ఈ టాస్క్ కోసం కోడ్:

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

ముగింపు

అనేక రకాల ఆచరణాత్మక జావా టాస్క్‌లు ఉన్నాయి మరియు ఇంటర్వ్యూయర్ మిమ్మల్ని ఏ విధమైన పజిల్‌లను పరిష్కరించమని అడుగుతారో మీకు తెలియదు. కానీ, ట్రిక్ ప్రశ్నలను పరిష్కరించే మీ సామర్థ్యం కంటే మీరు ఉద్యోగంలో ఎదుర్కొనే వాస్తవమైన ఆచరణాత్మక పనులను పూర్తి చేయగల మీ సామర్థ్యం చాలా ముఖ్యమైనదని తెలివిగల యజమాని ఎవరైనా అర్థం చేసుకుంటారు . కాబట్టి వీలైనంత వరకు వీటిని చేయండి. అందుకే మేము కోడ్‌జిమ్‌ని సృష్టించాము. ఈ కథనాన్ని రూపొందించడానికి geeksforgeeks నుండి మెటీరియల్ ఉపయోగించబడింది.

మరింత పఠనం: