HackerRank శైలి coding test ప్రాక్టీస్

అసలు పరీక్ష సాధారణంగా ఎలా ఉంటుంది

ఒకే రకమైన HackerRank test అంటూ లేదు. HackerRank ఒక platform. ప్రతి employer ప్రశ్నలు, అనుమతించే languages, time limit ఎంచుకుని తమ సొంత test‌ను రూపొందిస్తారు. మీకు ఇచ్చిన test గురించి తెలుసుకోవడానికి employer పంపిన invitation అత్యుత్తమ సూచన.

ప్రశ్నల రకాలు. HackerRank తన tests‌లో coding, database, multiple choice, front-end, back-end, full-stack, code review, subjective తదితర అనేక రకాల ప్రశ్నలు ఉంటాయని పేర్కొంటుంది (HackerRank). చాలా coding tests‌లో వీటిలో కొన్ని రకాలే ఎక్కువగా ఉంటాయి:

• Coding questions: editor‌లో solution రాయాలి. Candidates తమ code‌ను test cases‌తో run చేయవచ్చని, ఆ తర్వాత కనిపించే sample cases మరియు కనిపించని hidden cases ఆధారంగా స్కోర్ ఇస్తారని HackerRank చెబుతోంది (HackerRank support).
• Database questions: SQL query రాయాలి. దాని ఫలితాన్ని ఆశించిన output‌తో పోలుస్తారు (HackerRank support).
• Multiple choice: concepts, complexity, code భాగం ఏమి చేస్తుందనే అంశాలకు ఆటోమేటిక్‌గా స్కోర్ ఇస్తారు (HackerRank).

పరీక్షల నిడివికి సంబంధించిన బహిరంగ ఉదాహరణలు. HackerRank నిర్వహించే skills tests నిడివిలో తేడా ఎలా ఉంటుందో తెలియజేస్తాయి: Python (Basic) test‌లో 90 minutes‌లో 2 questions ఉంటాయని (HackerRank), SQL (Basic) test‌లో 30 minutes‌లో 2 questions ఉంటాయని పేర్కొన్నారు (HackerRank). Employer నిర్వహించే test తక్కువ లేదా ఎక్కువ నిడివితో ఉండవచ్చు; ప్రశ్నలు కూడా ఎక్కువ లేదా తక్కువ ఉండవచ్చు.

Coding tests‌లో సాధారణంగా ఉంటాయని నివేదించే అంశాలు: arrays, strings, hash maps, sets, sorting, searching, time complexity, ఖాళీ లేదా negative input వంటి edge cases, ప్రాథమిక SQL.

మా mocks‌లో ఏముంటాయి. ప్రతి పూర్తి mock‌లో మూడు sections‌లో 90 minutes‌కు 14 questions ఉంటాయి: concepts, code reading (10), coding problems (3), database problem (1). Coding problems కోసం Python, JavaScript, Java లేదా C++లో solution రాసి run చేయాలి; database problem కోసం SQL query రాయాలి. ప్రతి దానినీ hidden test cases‌తో తనిఖీ చేసి, దాటిన ప్రతి case‌కు credit ఇస్తారు. Laptop ఉపయోగించడం మంచిది. వెనక్కి వెళ్లి ప్రశ్నలను flag చేయవచ్చు.

మా ఉచిత sample‌లో ఉండే తేడా. ఉచిత 10 questions multiple choice రూపంలో ఉంటాయి: coding questions‌లో ఏ solution విజయవంతమవుతుందో లేదా ఏ input దాన్ని విఫలం చేస్తుందో అడుగుతాం. ఇవి test cases‌ను దాటే code రాయడానికి అవసరమైన నైపుణ్యాలను పరీక్షిస్తాయి. పూర్తి mocks‌లో మీరు code రాసి run చేస్తారు. మా hidden cases చిన్నవిగా ఉండి correctness, edge cases‌ను తనిఖీ చేస్తాయి. కొన్ని నిజమైన tests‌లో లాగా భారీ inputs‌పై నెమ్మదిగా ఉండే solution‌కు సమయ పరిమితి విధించవు; speed ఎక్కడ ముఖ్యమో వివరణల్లో చెబుతాం.

వివరణాత్మక ఉదాహరణలతో ప్రశ్నల రకాలు

ప్రతి రకమైన ప్రశ్నకు ఒక worked example, ఎక్కువ మంది చేసే పొరపాటుతో సహా.

1. Time complexity. ఒక list‌పై loop నడుస్తూ, ప్రతిసారీ "x in other_list" అని తనిఖీ చేస్తుంది. రెండు lists‌లోనూ n items ఉన్నాయి. Loop n సార్లు నడుస్తుంది, ప్రతి membership check గరిష్ఠంగా n items‌ను పరిశీలిస్తుంది. కాబట్టి మొత్తం పని O(n squared). other_list‌ను set‌గా మార్చితే, ప్రతి check సగటున O(1) అవుతుంది, loop O(n) అవుతుంది. పొరపాటు: కనిపించే loop‌ను మాత్రమే లెక్కించడం. List‌లో "in", list.index, slicing వంటి built-in calls కూడా పని చేస్తాయి.

2. Code చదవడం. print([x * 2 for x in range(3)]) ఏది చూపిస్తుంది? range(3) 0, 1, 2 ఇస్తుంది, కాబట్టి సమాధానం [0, 2, 4]. పొరపాటు: 1 నుంచి మొదలుపెట్టడం లేదా 3ను చేర్చడం. range చివరి విలువకు ముందే ఆగుతుంది.

3. ఏ solution ఉత్తీర్ణమవుతుంది. ఒక problem‌లో గరిష్ఠంగా 100,000 items ఉండవచ్చు. O(n squared) solution‌కు సుమారు 10 billion steps అవసరం. సాధారణ time limit‌కు ఇది చాలా నెమ్మదిగా ఉంటుంది. O(n) లేదా O(n log n) మాత్రం సరిపడా వేగంగా ఉంటుంది. పొరపాటు: చూడటానికి చిన్నదిగా ఉన్న solution‌ను ఎంచుకోవడం. ముందుగా ఇచ్చిన పరిమాణంతో దాని complexity‌ను పోల్చండి.

4. ఏ input సమస్య కలిగిస్తుంది. ఒక function list సగటును sum(nums) / len(nums)గా ఇస్తుంది. ఏ input దాన్ని విఫలం చేస్తుంది? ఖాళీ list. దాన్ని భాగిస్తే సున్నాతో భాగించినట్లవుతుంది. పొరపాటు: సాధారణ input‌లను మాత్రమే పరీక్షించడం. ఖాళీ list, ఒక item, అన్నీ సమానమైనవి, negative విలువలు, అనుమతించిన గరిష్ఠ పరిమాణం వంటి వాటిని ప్రయత్నించండి.

5. Database problem. ఏదీ ఖర్చు చేయని customers‌తో సహా, ప్రతి customer మొత్తం ఎంత ఖర్చు చేశారో తెలుసుకోవాలి. customers LEFT JOIN orders ఉపయోగించి, customer ఆధారంగా group చేసి, amount‌ను sum చేయండి. తర్వాత COALESCEతో NULL‌ను 0గా మార్చండి. పొరపాటు: inner join వాడటం. అది orders లేని customers‌ను చెప్పకుండా ఫలితం నుంచి తొలగిస్తుంది.

ఎలా సిద్ధం కావాలి

1. ముందుగా invitation చదవండి. Time limit, ప్రశ్నల సంఖ్య మరియు రకం, అనుమతించే languages గమనించండి. వీటన్నింటినీ employers నిర్ణయిస్తారు కాబట్టి, ముందే ఊహించకండి.
2. ఒక language ఎంచుకుని దానిపైనే సాధన చేయండి. Coding questions కోసం మీకు బాగా తెలిసిన language ఉపయోగించండి. దాని built-in lists, dictionaries, sets, sorting, string methods కోసం వెతకాల్సిన అవసరం లేకుండా వాటిని బాగా తెలుసుకోండి.
3. Input పరిమాణాన్ని బట్టి complexity తెలుసుకోండి. Code రాసే ముందు ఇచ్చిన limits తనిఖీ చేయండి. సుమారు 1,000 items వరకు O(n squared) సాధారణంగా సరిపోతుంది; 100,000 లేదా అంతకంటే ఎక్కువ items ఉంటే O(n) లేదా O(n log n) లక్ష్యంగా పెట్టుకోండి.
4. Edge cases‌ను ఉద్దేశపూర్వకంగా సాధన చేయండి. Empty input, ఒకే item, duplicates, negative values, చాలా పెద్ద values, గరిష్ఠ పరిమాణం వంటి వాటితో పరీక్షించండి. Coding questions‌కు hidden test cases ఆధారంగా స్కోర్ ఇస్తారు (HackerRank support); వాటిలో చాలావరకు ఇలాంటి cases ఉంటాయి.
5. ముందుగా sample cases run చేసి, తర్వాత మీవాటితో పరీక్షించండి. కనిపించే samples‌ను దాటడం ప్రారంభం మాత్రమే, ముగింపు కాదు. Submit చేసే ముందు మీరే కొన్ని cases జోడించండి.
6. ప్రాథమిక SQL‌ను మళ్లీ సాధన చేయండి. Joins, GROUP BY, HAVING, NULLs, sorting చాలా database questions‌కు సరిపోతాయి. Database answers‌ను ఆశించిన output‌తో పోలుస్తారు కాబట్టి, ఫలితాన్ని ప్రతి row చొప్పున తనిఖీ చేయండి (HackerRank support).
7. సమయ పరిమితిలో పూర్తి solutions రాయండి. మా పూర్తి mocks‌లో hidden cases‌తో code రాసి run చేస్తారు. మీ సొంత problems‌తో కూడా ఇదే సాధన చేయండి, అప్పుడు సమయ పరిమితిలో పూర్తి solution టైప్ చేయడం అలవాటవుతుంది.
8. నిజమైన వేగంతో సాధన చేయండి. పరీక్ష రోజున 90 minutes పాటు ఏకాగ్రతతో పని చేయడం సహజంగా అనిపించేలా, పూర్తి timed mocks తీసుకోండి.

సాధారణంగా స్కోరింగ్ ఎలా జరుగుతుంది

స్కోరింగ్‌ను ప్రతి యజమాని సంస్థ నిర్ణయిస్తుంది. తన ప్రశ్న రకాలకు ఎలా స్కోర్ ఇస్తారో HackerRank వివరిస్తుంది. ఏ ఫలితం సరిపోతుందో ప్రతి యజమాని సంస్థ నిర్ణయిస్తుంది. అందరికీ వర్తించే ఒకే ఉత్తీర్ణత మార్కు లేదు.

• Coding ప్రశ్నలు: ప్రతి test case‌పై మీ code‌ను అమలు చేసి, ప్రతి output‌ను ఆశించిన output‌తో పోలుస్తుందని HackerRank చెబుతోంది. ప్రతి test case‌కు నిర్ణీత స్కోర్ ఉంటుంది: ఉత్తీర్ణమైతే పూర్తి స్కోర్, విఫలమైతే స్కోర్ ఉండదు. ఒక test case‌కు పాక్షిక స్కోరింగ్ ఉండదు. మీరు ఉత్తీర్ణమైన test case‌ల స్కోర్ల మొత్తమే ఆ ప్రశ్నకు మీ స్కోర్. మీకు కనిపించే నమూనా test case‌లకు 0 పాయింట్లు ఉండవచ్చు; కనిపించని test case‌లకే పాయింట్లు ఉండవచ్చు (HackerRank support).
• Database ప్రశ్నలు: మీ query ఫలితాన్ని ఆశించిన output‌తో పోలుస్తారు. సరిపోతే పూర్తి స్కోర్, లేకపోతే సున్నా. అయితే యజమాని సంస్థ స్వయంగా పరిశీలించి పాక్షిక మార్కులు ఇవ్వవచ్చు (HackerRank support).
• Multiple choice: ఆటోమేటిక్‌గా స్కోర్ చేస్తారు (HackerRank).

అందుకే దాదాపు సరైన solution అయినా, లేదా సరైనదే అయినా చాలా నెమ్మదిగా ఉన్నా, ఎక్కువ పాయింట్లు కోల్పోవచ్చు: కనిపించని ప్రతి test case‌లో ఉత్తీర్ణత లేదా వైఫల్యం మాత్రమే ఉంటుంది.

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

సాధారణ తప్పులు

• సాంపిల్స్ పాస్ అయిన వెంటనే ఆపేయడం. కనిపించే సాంపిల్స్ మొత్తం కేసుల్లో చిన్న భాగం మాత్రమే. ఖాళీ ఇన్‌పుట్, ఒక అంశం, నెగటివ్ నంబర్లు, గరిష్ఠ సైజ్ వంటి వాటిని మీరే పరీక్షించండి.
• ఇన్‌పుట్ పరిమితులను పట్టించుకోకపోవడం. సరైనదైనా నెమ్మదిగా పనిచేసే పరిష్కారం పెద్ద హిడెన్ కేసుల్లో ఫెయిల్ కావచ్చు. విధానాన్ని ఎంచుకునే ముందు పరిమితులను చదవండి.
• గరిష్ఠ విలువను 0తో ప్రారంభించడం. మొదటి అంశంతో ప్రారంభించండి. లేదంటే నెగటివ్ నంబర్ల విషయంలో తప్పు వస్తుంది.
• లూప్ చేస్తున్న లిస్ట్‌ను మార్చడం. లూప్ చేస్తూనే అంశాలను తీసేస్తే కొన్ని అంశాలు దాటవేయబడతాయి. బదులుగా కొత్త లిస్ట్‌ను రూపొందించండి.
• పరిధిలో ఒకటి ఎక్కువ లేదా తక్కువగా తీసుకోవడం. range(a, b)లో bకు ముందు ఆగుతుంది, స్లైస్‌లూ అలాగే పనిచేస్తాయి. చిన్న ఉదాహరణతో మొదటి, చివరి ఇండెక్స్‌లను తనిఖీ చేయండి.
• అదనపు అవుట్‌పుట్ ప్రింట్ చేయడం. కోడింగ్ సమాధానాలను ఆశించిన అవుట్‌పుట్‌తో పోలుస్తారు. కాబట్టి అనుకోకుండా వచ్చే debug prints లేదా అదనపు ఖాళీలు ఒక కేసును ఫెయిల్ చేయవచ్చు.
• ఒక సమస్యపైనే ఎక్కువ సమయం వెచ్చించడం. ముందుగా పనిచేసే పరిష్కారాన్ని సమర్పించండి. సమయం మిగిలితే దాన్ని మెరుగుపరచండి.