Codility-శైలి కోడింగ్ టెస్ట్ సాధన

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

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

Codility తెలిపిన వివరాలు. ప్రతి task‌కు నిర్ణీత ప్రమాణాల ఆధారంగా ఆటోమేటిక్‌గా స్కోర్ ఇస్తామని Codility చెబుతోంది (Codility). ప్రోగ్రామర్ల కోసం ఉచిత lessons (Codility)లో task‌ల విధానం కనిపిస్తుంది: చిన్న సమస్య, రాయాల్సిన function, ఇచ్చిన input పరిమితులు. ఉదాహరణకు, BinaryGap lesson‌లో 2,147,483,647 వరకు ఉన్న inputs కోసం "an efficient algorithm" రాయమని అడుగుతుంది (Codility). ఒక lesson పేరు Time Complexity (Codility).

Codility tests గురించి సాధారణంగా నివేదించేవి (candidates, guides నుంచి వచ్చిన సమాచారం; మేము తెరవగలిగిన Codility పేజీలో నిర్ధారించలేదు):

• మొత్తం test‌కు ఒకే timer కింద కొన్ని tasks ఉంటాయి. సాధారణంగా 30 minutes నుంచి 2 hours వరకు సమయం ఉంటుంది.
• కనిపించని correctness tests: task‌లోని ఉదాహరణకు మించి, మీకు కనిపించని test cases‌తో మీ code‌ను తనిఖీ చేస్తారు.
• Algorithmic tasks‌లో పెద్ద inputs‌పై పనితీరు ముఖ్యం: సరైనదైనా నెమ్మదిగా ఉండే solution‌కు తక్కువ points రావచ్చు.
• పరిమితిలోపు మీరు తీసుకునే సమయం స్కోర్‌లో భాగం కాదు.

మా mocks‌లో ఏముంటాయి. ప్రతి పూర్తి mock‌లో సులభమైన task నుంచి కష్టమైన task వరకు 90 minutes‌లో మూడు coding tasks ఉంటాయి. మీరు Python, JavaScript, Java లేదా C++లో solution రాసి run చేస్తారు. కనిపించని test cases‌తో దాన్ని తనిఖీ చేస్తారు; ప్రతి test case‌ను దాటినందుకు credit లభిస్తుంది. Laptop ఉపయోగించడం మంచిది. Submit చేసే వరకు వెనక్కి వెళ్లి solution మార్చుకోవచ్చు.

మా mocks‌లో ఉండే తేడా. నిజమైన Codility tasks‌లో correctness‌ను, అలాగే చాలా tasks‌లో పెద్ద inputs‌పై పనితీరును తనిఖీ చేస్తారని సాధారణంగా నివేదిస్తారు. మా hidden cases చిన్నవిగా ఉండి correctness, edge cases‌ను తనిఖీ చేస్తాయి. అందువల్ల నెమ్మదిగా ఉండే solution‌కు సమయం ముగిసిపోదు; పెద్ద input‌కు అవసరమైన complexity ఏమిటో ప్రతి task వివరణలో చెబుతాం. ఉచిత 10 questions multiple choice రూపంలో ఉంటాయి. వాటిలో correctness, complexity, edge cases, speed గురించి అడుగుతాం. ఈ checks‌లో ఉత్తీర్ణత సాధించడానికి అవసరమైన ఆలోచనా విధానాన్ని అవి పరీక్షిస్తాయి.

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

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

1. ఏ solution సరైనది. Task: ఒక list‌లోని వేర్వేరు విలువల సంఖ్యను ఇవ్వాలి. Solution: len(set(A)). ఖాళీ list‌తో సహా ప్రతి list‌కు ఇది సరైనదే. ఖాళీ list‌కు 0 వస్తుంది. పొరపాటు: sorted list‌తో మీరే loop రాసి, మొదటి లేదా చివరి item‌ను మర్చిపోవడం. Built-in‌తో పని పూర్తయితే, అది edge cases‌ను సరిగ్గా నిర్వహిస్తుందో చూసి ఉపయోగించండి.

2. Time complexity. ఒక solution Aపై loop నడుపుతూ, loop లోపల max(A[:i])ను పిలుస్తుంది. Slice, max రెండూ గరిష్ఠంగా i items‌ను పరిశీలిస్తాయి. కాబట్టి మొత్తం పని సుమారు N squared divided by 2 steps, అంటే O(N squared). బదులుగా running maximum‌ను ఉంచుకుంటే O(N) అవుతుంది. పొరపాటు: ఒక loop కనిపించగానే దాన్ని O(N)గా పరిగణించడం. అందులో slices, sums, counts, searches ఉన్నాయేమో చూడండి.

3. ఏ input దాన్ని విఫలం చేస్తుంది. Task: Aలో లేని అతి చిన్న positive integer‌ను ఇవ్వాలి. ఒక solution max(A) + 1 ఇస్తుంది. A = [1, 2, 3] ప్రయత్నించండి: అది సరైన సమాధానమైన 4 ఇస్తుంది. A = [1, 3] ప్రయత్నించండి: అది 4 ఇస్తుంది, కానీ 2 లేదు, కాబట్టి సమాధానం 2. A = [-3, -1] ప్రయత్నించండి: అది 0 ఇస్తుంది, కానీ సమాధానం 1. పొరపాటు: ఒక సరైన case తర్వాత పరీక్షించడం ఆపేయడం. Edge cases‌ను ఉద్దేశపూర్వకంగా జాబితా చేయండి: మధ్యలో ఖాళీలు, అన్నీ negative విలువలు, అనుమతిస్తే ఖాళీ list, ఒక item, అన్నీ సమానమైనవి, అనుమతించిన గరిష్ఠ విలువలు.

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

5. Limits చదవడం. విలువలు 1,000,000,000 వరకు ఉండవచ్చు, N 100,000 అయితే మొత్తం 100 trillion వరకు చేరవచ్చు. Python integers దీన్ని నిర్వహిస్తాయి. కానీ fixed-size integers ఉన్న languages‌లో overflow కావచ్చు. పొరపాటు: విలువల పరిధిని పట్టించుకోకపోవడం. దీని ద్వారా overflow వచ్చే అవకాశం, counting array వంటి పద్ధతులు సాధ్యమా కాదా అనేది తెలుస్తుంది.

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

1. ముందుగా invitation చదవండి. Tasks సంఖ్య, మొత్తం సమయం, అనుమతించే languages గమనించండి. వీటిని employers నిర్ణయిస్తారు కాబట్టి, ముందే ఊహించకండి.
2. మీకు బాగా తెలిసిన ఒక language ఉపయోగించండి. దాని lists, dictionaries, sets, sorting, string methods కోసం వెతకాల్సిన అవసరం లేకుండా వాటిని తెలుసుకోండి.
3. Code రాసే ముందు limits చదవండి. Task‌లో ఇచ్చిన input పరిమాణాలు, values పరిధి ఆధారంగా solution ఎంత వేగంగా ఉండాలో, ఏ edge cases ముఖ్యమో తెలుస్తుంది. Codility lesson tasks‌లో కూడా ఇదే విధానం కనిపిస్తుంది (Codility).
4. ముందుగా సరైనదిగా చేయండి, తర్వాత వేగం పెంచండి. మొదట సరళమైన, సరైన version రాయండి. అది O(N squared) అయి, N విలువ 100,000 వరకు వెళ్లగలిగితే, దాని complexity తగ్గించడానికి running total, dictionary, set లేదా sorting ఉపయోగించవచ్చేమో చూడండి.
5. Edge cases‌ను మీరే పరీక్షించండి. Task‌లో ఇచ్చిన ఉదాహరణ ఒక్క case మాత్రమే. అనుమతిస్తే empty input, ఒక item, అన్ని values సమానంగా ఉండటం, negative values, అతి చిన్న మరియు అతి పెద్ద values, గరిష్ఠ Nతో పరీక్షించండి.
6. సాధారణ patterns నేర్చుకోండి. Prefix sums, sliding windows, dictionaryతో counting, two pointers, మొదట sorting చేయడం, సరళమైన greedy choices వంటివి చాలా చిన్న algorithm tasks‌కు ఉపయోగపడతాయి. Codility ఉచిత lessons‌లో ఈ విధానం తెలుసుకోవచ్చు (Codility).
7. సమయ పరిమితిలో పూర్తి solutions రాయండి. మా పూర్తి mocks‌లో hidden cases‌తో code రాసి run చేస్తారు. ఇదే విధంగా మీ సొంత tasks‌తో సాధన చేయండి, అప్పుడు సమయ పరిమితిలో రాయడం అలవాటవుతుంది.
8. నిజమైన వేగంతో సాధన చేయండి. ఒకే timer‌లో మూడు tasks పూర్తి చేయడం పరీక్ష రోజున సహజంగా అనిపించేలా, పూర్తి timed mocks తీసుకోండి.

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

స్కోరింగ్‌ను ప్రతి యజమాని సంస్థ నిర్ణయిస్తుంది. ప్రతి టాస్క్‌కు నిర్దిష్ట ప్రమాణాల ఆధారంగా ఆటోమేటిక్‌గా స్కోర్ ఇస్తారని Codility చెబుతోంది (Codility). ఏ ఫలితం సరిపోతుందో ప్రతి యజమాని సంస్థ నిర్ణయిస్తుంది. అందరికీ వర్తించే ఒకే ఉత్తీర్ణత మార్కు లేదు.

ఆ ప్రమాణాలు ఎలా పనిచేస్తాయనే దాని గురించి సాధారణంగా నివేదించబడిన సమాచారం: ఒక టాస్క్ స్కోర్ అనేది కనిపించని correctness పరీక్షలు, అలాగే అనేక algorithmic టాస్క్‌లలో పెద్ద inputs‌పై చేసే performance పరీక్షల ఆధారంగా ఉంటుంది. వీటిని కలిపి ఆ టాస్క్‌కు, ఆ తర్వాత మొత్తం పరీక్షకు శాతంగా లెక్కిస్తారు. చిన్న inputs‌పై సరిగ్గా పనిచేసినా, పెద్ద inputs‌పై చాలా నెమ్మదిగా ఉండే solution‌కు performance పాయింట్లు తగ్గవచ్చు. edge case‌లో విఫలమైతే correctness స్కోర్‌లో కొంత కోల్పోతుంది. అందుకే మా mock పరీక్షల్లో "ఇది సరైనదా?" మరియు "ఇది తగినంత వేగంగా ఉందా?" అని వేర్వేరుగా అడుగుతాం.

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

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

• ఉదాహరణనే నమ్మడం. ఒక taskలో ఇచ్చిన ఉదాహరణ, దాచిన అనేక test casesలో ఒకటి మాత్రమే. ఒక solution ఆ ఉదాహరణలో pass అయినా, మొత్తం scoreలో చాలా భాగంలో fail కావచ్చు.
• Nను పట్టించుకోకపోవడం. సరైన O(N squared) solution కూడా N = 100,000 వద్ద performance checksలో fail కావచ్చు. ముందుగా limits చూడండి.
• Loopలో దాగి ఉండే పని. Loopలో listపై చేసే slice, sum, count, index లేదా "in" ఆపరేషన్ ఖర్చును ఎన్నో రెట్లు పెంచుతుంది.
• చివరి itemను మిస్ చేయడం. Off-by-one ranges, అలాగే list చివరికి చేరినప్పుడు ముగిసే runs తరచూ failureకు దారితీస్తాయి. చివరి దశను చేతితో trace చేయండి.
• తప్పు ప్రారంభ విలువలు. Maximumను 0తో ప్రారంభించడం లేదా minimumకు ఊహించిన పెద్ద సంఖ్యను పెట్టడం, negative లేదా చాలా పెద్ద values ఉన్నప్పుడు సమస్య కలిగిస్తుంది. మొదటి itemతో ప్రారంభించండి.
• Task ఆధారపడిన క్రమాన్ని మార్చడం. Sorting మంచి సాధనం, కానీ సమాధానం positionsపై లేదా "listలో మొదటిది" అనే దానిపై ఆధారపడితే దాన్ని ఉపయోగించకండి.
• ఒక taskపైనే మొత్తం సమయం వెచ్చించడం. ముందుగా ప్రతి taskకు సరైన versionను submit చేయండి. సమయం ఉంటే వేగాన్ని మెరుగుపరచండి.