HackerRank-style coding test ଅଭ୍ୟାସ

ପ୍ରକୃତ ପରୀକ୍ଷା ସାଧାରଣତଃ କିପରି ହୋଇଥାଏ

ଗୋଟିଏ ମାତ୍ର HackerRank test ନାହିଁ। HackerRank ଏକ ପ୍ଲାଟଫର୍ମ: ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ନିଜର test ତିଆରି କରନ୍ତି, ଯେଉଁଥିରେ ପ୍ରଶ୍ନ, ଅନୁମତିପ୍ରାପ୍ତ ଭାଷା ଏବଂ ସମୟସୀମା ବାଛନ୍ତି। ଆପଣଙ୍କ test ବିଷୟରେ ନିଯୁକ୍ତିଦାତାଙ୍କଠାରୁ ମିଳିଥିବା ନିମନ୍ତ୍ରଣ ହିଁ ସବୁଠାରୁ ଭଲ ମାର୍ଗଦର୍ଶକ।

ପ୍ରଶ୍ନର ପ୍ରକାର। HackerRank ନିଜ test ପାଇଁ ଅନେକ ପ୍ରକାରର ପ୍ରଶ୍ନ ତାଲିକାଭୁକ୍ତ କରେ। ଏଥିରେ coding, database, multiple choice, front-end, back-end, full-stack, code review, subjective ଏବଂ ଅନ୍ୟାନ୍ୟ (HackerRank) ରହିଛି। ଅଧିକାଂଶ coding test ଏଥିରୁ ଅଳ୍ପ କେତୋଟି ପ୍ରକାର ଉପରେ ନିର୍ଭର କରେ:

• Coding ପ୍ରଶ୍ନ: ଆପଣ ଏକ editor ରେ ସମାଧାନ ଲେଖନ୍ତି। HackerRank କହେ ଯେ ପ୍ରାର୍ଥୀମାନେ test cases ବ୍ୟବହାର କରି ନିଜ code ଚଳାଇପାରିବେ, ଏବଂ ପରେ ଯେଉଁ sample cases ଆପଣ ଦେଖିପାରିବେ ଓ hidden cases ଆପଣ ଦେଖିପାରିବେ ନାହିଁ, ସେଗୁଡ଼ିକ ଆଧାରରେ ତାହାର ମୂଲ୍ୟାୟନ ହୁଏ (HackerRank support).
• Database ପ୍ରଶ୍ନ: ଆପଣ ଏକ SQL query ଲେଖନ୍ତି, ଏବଂ ତାହାର ଫଳାଫଳକୁ ଆଶାକରାଯାଇଥିବା output ସହ ତୁଳନା କରାଯାଏ (HackerRank support).
• Multiple choice: ଧାରଣା, complexity ଏବଂ code ର ଏକ ଅଂଶ କଣ କରେ ସେ ବିଷୟରେ ପ୍ରଶ୍ନ, ଯାହାର ମୂଲ୍ୟାୟନ ସ୍ୱୟଂଚାଳିତ ଭାବେ ହୁଏ (HackerRank).

ପ୍ରଶ୍ନ ସଂଖ୍ୟାର ସାର୍ବଜନୀନ ଉଦାହରଣ। HackerRank ର ନିଜ skills test ଗୁଡ଼ିକରୁ ପ୍ରଶ୍ନ ସଂଖ୍ୟାର ଧାରଣା ମିଳେ: ଏହାର Python (Basic) test ରେ 90 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ଥିବା ଉଲ୍ଲେଖ ଅଛି (HackerRank) ଏବଂ ଏହାର SQL (Basic) test ରେ 30 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ଥିବା ଉଲ୍ଲେଖ ଅଛି (HackerRank)। ନିଯୁକ୍ତିଦାତାଙ୍କ test ଏହାଠାରୁ କମ୍ କିମ୍ବା ଅଧିକ ସମୟର ହୋଇପାରେ, ଏବଂ ଏଥିରେ ପ୍ରଶ୍ନ ସଂଖ୍ୟା ଅଧିକ କିମ୍ବା କମ୍ ହୋଇପାରେ।

Coding test ରେ ସାଧାରଣତଃ ଆସୁଥିବା ବିଷୟ: arrays ଏବଂ strings, hash maps ଏବଂ sets, sorting ଏବଂ searching, time complexity, ଖାଲି କିମ୍ବା ଋଣାତ୍ମକ input ଭଳି edge cases, ଏବଂ ମୌଳିକ SQL।

ଆମ mock test ଗୁଡ଼ିକରେ କଣ ରହିଛି। ପ୍ରତ୍ୟେକ ପୂର୍ଣ୍ଣ mock test ରେ 90 ମିନିଟ୍‌ରେ 14ଟି ପ୍ରଶ୍ନ ରହିଛି, ଯାହା ତିନୋଟି ବିଭାଗରେ ବିଭକ୍ତ: ଧାରଣା ଏବଂ code ପଢ଼ିବା (10), coding ସମସ୍ୟା (3) ଏବଂ ଏକ database ସମସ୍ୟା (1)। Coding ସମସ୍ୟାଗୁଡ଼ିକ ପାଇଁ ଆପଣ Python, JavaScript, Java କିମ୍ବା C++ ରେ ସମାଧାନ ଲେଖି ଚଳାଇବେ, ଏବଂ database ସମସ୍ୟା ପାଇଁ ଏକ SQL query ଲେଖିବେ; ପ୍ରତ୍ୟେକଟିକୁ hidden test cases ସହ ଯାଞ୍ଚ କରାଯାଏ ଏବଂ ଯେଉଁ case ରେ ଏହା ସଫଳ ହୁଏ, ସେଥିପାଇଁ credit ମିଳେ। Laptop ବ୍ୟବହାର କରିବାକୁ ପରାମର୍ଶ ଦିଆଯାଏ। ଆପଣ ପଛକୁ ଯାଇ ପ୍ରଶ୍ନଗୁଡ଼ିକୁ flag କରିପାରିବେ।

ଆମର ମାଗଣା sample ରେ କଣ ଭିନ୍ନ। 10ଟି ମାଗଣା ପ୍ରଶ୍ନ multiple choice ଅଟେ: coding ପ୍ରଶ୍ନଗୁଡ଼ିକରେ କେଉଁ ସମାଧାନ ସଫଳ ହୁଏ କିମ୍ବା କେଉଁ input ଗୋଟିଏ ସମାଧାନକୁ ବିଫଳ କରେ, ତାହା ପଚରାଯାଏ। ଏହା ସଫଳ code ଲେଖିବା ପଛରେ ଥିବା କୌଶଳ। ପୂର୍ଣ୍ଣ mock test ଗୁଡ଼ିକରେ ଆପଣ ନିଜେ code ଲେଖି ଚଳାଇବେ। ଆମର hidden cases ଛୋଟ ଏବଂ ସଠିକତା ଓ edge cases ଯାଞ୍ଚ କରେ। ତେଣୁ କିଛି ବାସ୍ତବ test ରେ ଯେପରି ବହୁତ ବଡ଼ input ଉପରେ ଧୀର ସମାଧାନର ସମୟ ମପାଯାଏ, ଏଠାରେ ସେପରି କରାଯାଏ ନାହିଁ; ବେଗ କେଉଁଠି ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ, ତାହା ବ୍ୟାଖ୍ୟାଗୁଡ଼ିକରେ କୁହାଯାଇଛି।

ସମାଧାନ ସହ ଉଦାହରଣ ଥିବା ପ୍ରଶ୍ନର ପ୍ରକାର

ପ୍ରତ୍ୟେକ ପ୍ରକାର ପ୍ରଶ୍ନ ପାଇଁ ଗୋଟିଏ ସମାଧାନ ସହ ଉଦାହରଣ, ଏବଂ ଅଧିକାଂଶ ଲୋକ କେଉଁ ଭୁଲରେ ପଡ଼ନ୍ତି ତାହା ସହ।

1. Time complexity। ଗୋଟିଏ list ଉପରେ ଥିବା loop ପ୍ରତିଥର "x in other_list" କୁ କଲ୍ କରେ। ଉଭୟ list ରେ nଟି item ଅଛି। loop n ଥର ଚାଲେ ଏବଂ ପ୍ରତ୍ୟେକ membership check ସର୍ବାଧିକ nଟି item ଯାଞ୍ଚ କରେ, ତେଣୁ ପୂରା କାମ O(n squared)। other_list କୁ set କଲେ ହାରାହାରି ପ୍ରତ୍ୟେକ ଯାଞ୍ଚ O(1) ହୁଏ ଏବଂ loop O(n) ହୁଏ। ଭୁଲର ସମ୍ଭାବନା: କେବଳ ଦେଖାଯାଉଥିବା loop କୁ ଗଣନା କରିବା। list ରେ "in", list.index ଏବଂ slicing ପରି built-in କଲ୍‌ଗୁଡ଼ିକ ମଧ୍ୟ କାମ କରେ।

2. କୋଡ୍ ପଢ଼ିବା। print([x * 2 for x in range(3)]) କ'ଣ ଦେଖାଏ? range(3) ରୁ 0, 1 ଏବଂ 2 ମିଳେ, ତେଣୁ ଉତ୍ତର [0, 2, 4]। ଭୁଲର ସମ୍ଭାବନା: 1 ରୁ ଆରମ୍ଭ କରିବା କିମ୍ବା 3 କୁ ସାମିଲ କରିବା। range ଶେଷ ମୂଲ୍ୟ ପୂର୍ବରୁ ଥମିଯାଏ।

3. କେଉଁ ସମାଧାନଟି ସଠିକ୍ ଉତ୍ତର ଦିଏ। ଗୋଟିଏ ସମସ୍ୟାରେ 100,000 ପର୍ଯ୍ୟନ୍ତ item ଥାଇପାରେ। O(n squared) ସମାଧାନକୁ ପ୍ରାୟ 10 billion ପଦକ୍ଷେପ ଦରକାର, ଯାହା ସାଧାରଣ time limit ପାଇଁ ବହୁତ ଧୀର; ହେଲେ O(n) କିମ୍ବା O(n log n) ସହଜରେ କାମ କରିବ। ଭୁଲର ସମ୍ଭାବନା: ଦେଖିବାକୁ ସବୁଠାରୁ ଛୋଟ ଲାଗୁଥିବା ସମାଧାନ ବାଛିବା। ପ୍ରଥମେ ଦିଆଯାଇଥିବା ଆକାର ଅନୁଯାୟୀ ଏହାର complexity ଯାଞ୍ଚ କରନ୍ତୁ।

4. କେଉଁ input ରେ ସମସ୍ୟା ହୁଏ। ଗୋଟିଏ function ଏକ list ର ହାରାହାରିକୁ sum(nums) / len(nums) ଭାବେ ଫେରାଏ। କେଉଁ input ରେ ଏହା ସମସ୍ୟା କରିବ? ଖାଲି list, କାରଣ ଏଥିରେ ଶୂନ୍ୟ ଦ୍ୱାରା ଭାଗ ହୁଏ। ଭୁଲର ସମ୍ଭାବନା: କେବଳ ସାଧାରଣ input ଯାଞ୍ଚ କରିବା। ଖାଲି, ଗୋଟିଏ item, ସବୁ ସମାନ, ଋଣାତ୍ମକ ସଂଖ୍ୟା ଏବଂ ଅନୁମତିପ୍ରାପ୍ତ ସବୁଠାରୁ ବଡ଼ ଆକାର ଚେଷ୍ଟା କରନ୍ତୁ।

5. Database ସମସ୍ୟା। କିଛି ଖର୍ଚ୍ଚ କରିନଥିବା ଗ୍ରାହକଙ୍କ ସମେତ ପ୍ରତ୍ୟେକ ଗ୍ରାହକଙ୍କ ମୋଟ ଖର୍ଚ୍ଚ ଆପଣଙ୍କୁ ଦରକାର। customers LEFT JOIN orders ବ୍ୟବହାର କରନ୍ତୁ, customer ଅନୁସାରେ group କରନ୍ତୁ ଏବଂ amount ର ଯୋଗ କରନ୍ତୁ, ତାପରେ COALESCE ଦ୍ୱାରା NULL କୁ 0 କରନ୍ତୁ। ଭୁଲର ସମ୍ଭାବନା: inner join ବ୍ୟବହାର କରିବା, ଯାହା ଚୁପଚାପ ଅର୍ଡର ନଥିବା ଗ୍ରାହକଙ୍କୁ ବାଦ ଦିଏ।

କିପରି ପ୍ରସ୍ତୁତି ନେବେ

1. ପ୍ରଥମେ ଆପଣଙ୍କ ନିମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ସମୟ ସୀମା, ପ୍ରଶ୍ନର ସଂଖ୍ୟା ଓ ପ୍ରକାର, ଏବଂ ଅନୁମତିପ୍ରାପ୍ତ ଭାଷା ଲେଖି ରଖନ୍ତୁ। ଏସବୁ ନିଯୁକ୍ତିଦାତା ନିର୍ଦ୍ଧାରଣ କରନ୍ତି, ତେଣୁ ଅନୁମାନ କରନ୍ତୁ ନାହିଁ।
2. ଗୋଟିଏ ଭାଷା ବାଛନ୍ତୁ ଏବଂ ସେହି ଭାଷାରେ ଅଭ୍ୟାସ କରନ୍ତୁ। କୋଡିଂ ପ୍ରଶ୍ନ ପାଇଁ ଆପଣ ଭଲ ଭାବେ ଜାଣିଥିବା ଭାଷା ବ୍ୟବହାର କରନ୍ତୁ। ଏହାର built-in lists, dictionaries, sets, sorting ଏବଂ string methods ଏତେ ଭଲ ଭାବେ ଜାଣନ୍ତୁ ଯେ ଖୋଜିବାକୁ ନପଡ଼େ।
3. ଇନ୍‌ପୁଟ୍‌ର ଆକାର ଅନୁଯାୟୀ କମ୍ପ୍ଲେକ୍ସିଟି ବୁଝନ୍ତୁ। କୋଡ୍ ଲେଖିବା ପୂର୍ବରୁ ଦିଆଯାଇଥିବା ସୀମା ଯାଞ୍ଚ କରନ୍ତୁ। ପ୍ରାୟ 1,000ଟି item ପର୍ଯ୍ୟନ୍ତ O(n squared) ସାଧାରଣତଃ ଠିକ୍ ଥାଏ; 100,000 କିମ୍ବା ତାଠାରୁ ଅଧିକ ହେଲେ O(n) କିମ୍ବା O(n log n) ଲକ୍ଷ୍ୟ ରଖନ୍ତୁ।
4. ଉଦ୍ଦେଶ୍ୟପୂର୍ବକ edge cases ଅଭ୍ୟାସ କରନ୍ତୁ। ଖାଲି input, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତ ମୂଲ୍ୟ, ନେଗେଟିଭ୍ ମୂଲ୍ୟ, ବହୁତ ବଡ଼ ମୂଲ୍ୟ ଏବଂ ସର୍ବାଧିକ ଆକାର ପରୀକ୍ଷା କରନ୍ତୁ। କୋଡିଂ ପ୍ରଶ୍ନର ସ୍କୋର ଲୁକ୍କାୟିତ ଟେଷ୍ଟ କେସ୍ ଆଧାରରେ ଦିଆଯାଏ (HackerRank support), ଏବଂ ସେହି କେସ୍‌ଗୁଡ଼ିକ ମଧ୍ୟରେ ଏଗୁଡ଼ିକ ଅଧିକାଂଶ ସମୟରେ ଲୁଚିଥାଏ।
5. ନମୁନା କେସ୍ ଚଲାନ୍ତୁ, ତା’ପରେ ନିଜ କେସ୍ ପରୀକ୍ଷା କରନ୍ତୁ। ଦେଖାଯାଉଥିବା ନମୁନା ପାସ୍ କରିବା ଆରମ୍ଭ, ଶେଷ ନୁହେଁ। ଦାଖଲ କରିବା ପୂର୍ବରୁ ନିଜେ କିଛି କେସ୍ ଯୋଡ଼ନ୍ତୁ।
6. ମୌଳିକ SQL ମନେ ପକାନ୍ତୁ। Joins, GROUP BY, HAVING, NULLs ଏବଂ sorting ଅଧିକାଂଶ ଡାଟାବେସ୍ ପ୍ରଶ୍ନ ପାଇଁ ଯଥେଷ୍ଟ। ଫଳାଫଳକୁ ଧାଡ଼ି ଅନୁଯାୟୀ ଯାଞ୍ଚ କରନ୍ତୁ, କାରଣ ଡାଟାବେସ୍ ଉତ୍ତରକୁ ଆଶା କରାଯାଉଥିବା ଆଉଟ୍‌ପୁଟ୍ ସହ ତୁଳନା କରାଯାଏ (HackerRank support)।
7. ସମୟ ସୀମା ମଧ୍ୟରେ ପୂରା ସମାଧାନ ଲେଖନ୍ତୁ। ଆମର ପୂର୍ଣ୍ଣ ମକ୍ ଟେଷ୍ଟ୍‌ରେ ଆପଣ ଲୁକ୍କାୟିତ କେସ୍‌ ସହ କୋଡ୍ ଲେଖି ଚଲାଇବେ। ନିଜେ ବାଛିଥିବା ସମସ୍ୟାରେ ମଧ୍ୟ ସେହିପରି କରନ୍ତୁ, ଯାହାଦ୍ୱାରା ସମୟ ମଧ୍ୟରେ ପୂରା ସମାଧାନ ଟାଇପ୍ କରିବା ସ୍ୱାଭାବିକ ଲାଗିବ।
8. ପ୍ରକୃତ ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। ପୂର୍ଣ୍ଣ timed mock ଦିଅନ୍ତୁ, ଯାହାଦ୍ୱାରା ପରୀକ୍ଷା ଦିନ 90 ମିନିଟ୍ ଧରି ଏକାଗ୍ର ହୋଇ କାମ କରିବା ସ୍ୱାଭାବିକ ଲାଗିବ।

ସାଧାରଣତଃ ସ୍କୋର କିପରି ନିର୍ଣ୍ଣୟ କରାଯାଏ

ସ୍କୋରିଂ ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ନିଜେ ନିର୍ଦ୍ଧାରଣ କରନ୍ତି। HackerRank ଏହାର ପ୍ରଶ୍ନ ପ୍ରକାରଗୁଡ଼ିକର ସ୍କୋରିଂ କିପରି ହୁଏ ତାହା ବର୍ଣ୍ଣନା କରେ, ଏବଂ କେଉଁ ଫଳାଫଳ ଯଥେଷ୍ଟ ଭଲ ତାହା ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ସ୍ଥିର କରନ୍ତି। ସମସ୍ତଙ୍କ ପାଇଁ ଏକ ସାଧାରଣ ପାସ୍ ମାର୍କ ନାହିଁ।

• Coding ପ୍ରଶ୍ନ: HackerRank ଅନୁସାରେ, ସିଷ୍ଟମ୍ ଆପଣଙ୍କ code କୁ ପ୍ରତ୍ୟେକ test case ରେ ଚଳାଏ ଏବଂ ପ୍ରତ୍ୟେକ output କୁ ଆଶା କରାଯାଉଥିବା output ସହ ତୁଳନା କରେ। ପ୍ରତ୍ୟେକ test case ପାଇଁ ଏକ ନିର୍ଦ୍ଧାରିତ ସ୍କୋର ରହେ: ପାସ୍ କଲେ ସମ୍ପୂର୍ଣ୍ଣ ସ୍କୋର ମିଳେ, ବିଫଳ ହେଲେ କିଛି ମିଳେ ନାହିଁ। ଗୋଟିଏ test case ମଧ୍ୟରେ ଆଂଶିକ ସ୍କୋରିଂ ନାହିଁ। ପ୍ରଶ୍ନରେ ଆପଣଙ୍କ ସ୍କୋର ହେଉଛି ଆପଣ ପାସ୍ କରିଥିବା test case ଗୁଡ଼ିକର ମୋଟ ସ୍କୋର। ଆପଣ ଦେଖିପାରୁଥିବା ନମୁନା case ଗୁଡ଼ିକର ମୂଲ୍ୟ 0 ପଏଣ୍ଟ ହୋଇପାରେ, ଯେତେବେଳେ ଲୁକ୍କାୟିତ case ଗୁଡ଼ିକରେ ପଏଣ୍ଟ ରହେ (HackerRank support)।
• Database ପ୍ରଶ୍ନ: ଆପଣଙ୍କ query ର ଫଳାଫଳକୁ ଆଶା କରାଯାଉଥିବା output ସହ ତୁଳନା କରାଯାଏ: ମେଳ ହେଲେ ସମ୍ପୂର୍ଣ୍ଣ ସ୍କୋର ମିଳେ, ନଚେତ୍ ଶୂନ୍ୟ। ତେବେ ନିଯୁକ୍ତିଦାତା ଯଦି ନିଜେ ଯାଞ୍ଚ କରି ଆଂଶିକ ମାର୍କ ଦିଅନ୍ତି, ଏହା ଲାଗୁ ହୁଏ ନାହିଁ (HackerRank support)।
• Multiple choice: ସ୍ୱୟଂଚାଳିତ ଭାବେ ସ୍କୋର କରାଯାଏ (HackerRank)।

ଏହି କାରଣରୁ ପ୍ରାୟ ଠିକ୍ ଥିବା ସମାଧାନ, କିମ୍ବା ଠିକ୍ ହେଲେ ମଧ୍ୟ ଅତ୍ୟଧିକ ଧୀର ସମାଧାନ, ଅଧିକାଂଶ ପଏଣ୍ଟ ହରାଇପାରେ: ପ୍ରତ୍ୟେକ ଲୁକ୍କାୟିତ case ପାସ୍ କିମ୍ବା ଫେଲ୍ ହୁଏ।

ଆମର ଅଭ୍ୟାସ ସ୍କୋର ହେଉଛି ଆମର ନିଜ ପ୍ରଶ୍ନଗୁଡ଼ିକ ମଧ୍ୟରୁ ଆପଣ ଠିକ୍ ଉତ୍ତର ଦେଇଥିବା ପ୍ରଶ୍ନର ସଂଖ୍ୟା, ବିଭାଗ ଅନୁସାରେ ବିବରଣୀ ସହିତ, ଯାହାଦ୍ୱାରା କେଉଁଠି ଅଧିକ ଧ୍ୟାନ ଦେବେ ତାହା ଜାଣିପାରିବେ। ଏହା ଏକ ଅଭ୍ୟାସ ସ୍କୋର: ଏହା HackerRank ସ୍କୋର କିମ୍ବା କୌଣସି ନିଯୁକ୍ତିଦାତାଙ୍କ ଫଳାଫଳ ନୁହେଁ, ଏବଂ ଆପଣ ପାସ୍ କରିବେ କି ନାହିଁ ତାହାର ପୂର୍ବାନୁମାନ କରେ ନାହିଁ।

ସାଧାରଣ ଭୁଲ

• ନମୁନାଗୁଡ଼ିକ ପାସ୍ ହେବା ପରେ ଅଟକିଯିବା। ଦେଖାଯାଉଥିବା ନମୁନାଗୁଡ଼ିକ ସମସ୍ତ test caseର ଏକ ଛୋଟ ଅଂଶ ମାତ୍ର। ଖାଲି input, ଗୋଟିଏ item, ଋଣାତ୍ମକ ସଂଖ୍ୟା ଏବଂ ସବୁଠାରୁ ବଡ଼ size ନିଜେ ପରୀକ୍ଷା କରନ୍ତୁ।
• Inputର ସୀମାକୁ ଅଣଦେଖା କରିବା। ସଠିକ୍, କିନ୍ତୁ ଧୀର solution ବଡ଼ ଲୁକ୍କାୟିତ test caseରେ ବିଫଳ ହୋଇପାରେ। ପଦ୍ଧତି ବାଛିବା ପୂର୍ବରୁ ସୀମାଗୁଡ଼ିକ ପଢ଼ନ୍ତୁ।
• ସର୍ବାଧିକ ମୂଲ୍ୟକୁ 0ରୁ ଆରମ୍ଭ କରିବା। ପ୍ରଥମ itemରୁ ଆରମ୍ଭ କରନ୍ତୁ, ନଚେତ ଋଣାତ୍ମକ ସଂଖ୍ୟା ଏହାକୁ ଭୁଲ୍ କରିଦେବ।
• ଯେଉଁ list ଉପରେ ଲୁପ୍ ଚାଲୁଛି, ତାହାକୁ ବଦଳାଇବା। ଲୁପ୍ ଚାଲିଥିବା ବେଳେ item ହଟାଇଲେ କିଛି ଉପାଦାନ ଛାଡ଼ିଯାଏ। ତାହା ବଦଳରେ ନୂଆ list ତିଆରି କରନ୍ତୁ।
• Off-by-one rangeର ଭୁଲ୍। range(a, b)ରେ b ପୂର୍ବରୁ ଥମିଯାଏ, ଏବଂ slices ମଧ୍ୟ ସେହିପରି କାମ କରେ। ଛୋଟ ଉଦାହରଣରେ ପ୍ରଥମ ଏବଂ ଶେଷ index ଯାଞ୍ଚ କରନ୍ତୁ।
• ଅତିରିକ୍ତ output ପ୍ରିଣ୍ଟ କରିବା। Coding ଉତ୍ତରଗୁଡ଼ିକୁ ଆଶାକରା output ସହ ତୁଳନା କରାଯାଏ, ତେଣୁ ଅତିରିକ୍ତ debug print କିମ୍ବା ଖାଲି ସ୍ଥାନ ଥିଲେ test case ବିଫଳ ହୋଇପାରେ।
• ଗୋଟିଏ ସମସ୍ୟାରେ ଅତ୍ୟଧିକ ସମୟ ଦେବା। ପ୍ରଥମେ କାମ କରୁଥିବା solution submit କରନ୍ତୁ, ତାପରେ ସମୟ ବଳିଥିଲେ ଏହାକୁ ଉନ୍ନତ କରନ୍ତୁ।