Python କୋଡିଂ ପରୀକ୍ଷା ଅଭ୍ୟାସ

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

Python coding ପାଇଁ ଗୋଟିଏ ମାତ୍ର ପରୀକ୍ଷା ନାହିଁ। ପ୍ରତ୍ୟେକ ନିଯୋକ୍ତା ନିଜେ ଏକ testing platform ବାଛନ୍ତି ଏବଂ ନିଜର ପ୍ରଶ୍ନ, କାର୍ଯ୍ୟ ସଂଖ୍ୟା, ସମୟସୀମା ଓ ଅନୁମତିପ୍ରାପ୍ତ ଭାଷା ନିର୍ଦ୍ଧାରଣ କରନ୍ତି। ଆପଣଙ୍କ ପରୀକ୍ଷା ନିମନ୍ତ୍ରଣରେ ଥିବା ସୂଚନା ହିଁ ଆପଣଙ୍କ ପରୀକ୍ଷା ବିଷୟରେ ଜାଣିବାର ସର୍ବୋତ୍ତମ ଉପାୟ। ସାର୍ବଜନିକ ଉଦାହରଣଗୁଡ଼ିକରୁ ପରୀକ୍ଷାର ବିଭିନ୍ନତା ଜଣାପଡ଼େ:

• HackerRank. HackerRank ଏହାର Python (Basic) skills test କୁ 1 hour 30 minutes ରେ 2 questions ଭାବେ ତାଲିକାଭୁକ୍ତ କରେ। ଏଥିରେ scalar types ଭଳି ବିଷୟ ରହିଛି (HackerRank)। ଏହାର help center ରେ ନିଯୋକ୍ତାମାନେ ପରୀକ୍ଷାରେ ରଖିପାରୁଥିବା ପ୍ରଶ୍ନର ପ୍ରକାର ଦିଆଯାଇଛି। ସେଥିରେ coding, multiple choice, database, code review ଏବଂ subjective questions ଅନ୍ତର୍ଭୁକ୍ତ। ନିଯୋକ୍ତାମାନେ HackerRank ର library ରୁ ପ୍ରଶ୍ନ ଯୋଡ଼ିପାରିବେ କିମ୍ବା ନିଜେ ଲେଖିପାରିବେ ବୋଲି ମଧ୍ୟ କୁହାଯାଇଛି (HackerRank Help)।
• TestGorilla. TestGorilla ର Python coding tests ପୃଷ୍ଠା ଅନୁସାରେ, ଏହାର ଅଧିକାଂଶ ଅଲଗା coding test ପାଇଁ 15 to 35 minutes ଲାଗେ। ଏଥିରେ ନବାଗତଙ୍କ ପାଇଁ ଏକ algorithms test ର ସମୟ 15 minutes ବୋଲି ଦିଆଯାଇଛି। ନିଯୋକ୍ତା ଅନୁମତି ଦେଇଥିବା Python କିମ୍ବା ଅନ୍ୟ ଭାଷାରେ ପ୍ରାର୍ଥୀମାନେ ସମସ୍ୟା ସମାଧାନ କରିପାରିବେ ବୋଲି ମଧ୍ୟ କୁହାଯାଇଛି (TestGorilla)।

ନିଯୋକ୍ତାଙ୍କ Python ପରୀକ୍ଷାରେ ସାଧାରଣତଃ ରହୁଥିବା ଅଂଶ:

• Coding କାର୍ଯ୍ୟ: ଏକ online editor ରେ function ଲେଖନ୍ତୁ, ନମୁନା input ଦେଇ ଏହାକୁ ଚଲାନ୍ତୁ, ତା'ପରେ ଦାଖଲ କରନ୍ତୁ। ଆପଣ ଦେଖିପାରୁନଥିବା ଅନ୍ୟ test case ଦେଇ ଏହା ଯାଞ୍ଚ ହୋଇପାରେ।
• Multiple choice: Python ଧାରଣା, ଏକ code snippet ଚଲାଇଲେ କ'ଣ ଦେଖାଯିବ ଏବଂ କେଉଁ code ସଠିକ୍।
• Debugging କିମ୍ବା code review: ଅନ୍ୟ କେହି ଲେଖିଥିବା code ରେ ସମସ୍ୟା ଖୋଜି ସୁଧାରନ୍ତୁ।
• କେବେ କେବେ ଅନ୍ୟ ବିଷୟ: ଏକ SQL ପ୍ରଶ୍ନ, ବଡ଼ project କାର୍ଯ୍ୟ, ଘରେ କରିବାକୁ ଦିଆଯାଇଥିବା assignment, କିମ୍ବା ପରୀକ୍ଷା ସମୟରେ webcam ଓ screen ଉପରେ ନଜରଦାରି।

ଆମର mock test ରେ କ'ଣ ରହିଛି। ଆମର full mock ରେ 60 minutes ରେ 20 questions ଏବଂ ଚାରିଟି ଭାଗ ରହିଛି: Python ଧାରଣା (6), code ଚଲାଇଲେ କ'ଣ ଦେଖାଯିବ (6), bug ଖୋଜିବା (5) ଏବଂ ସମାଧାନ ତିଆରି କରିବା (3)। ସମସ୍ତ code Python 3 ରେ ଅଛି। ଦାଖଲ କରିବା ପର୍ଯ୍ୟନ୍ତ ଆପଣ ପଛକୁ ଯାଇପାରିବେ, ଉତ୍ତର ବଦଳାଇପାରିବେ ଏବଂ ପ୍ରଶ୍ନଗୁଡ଼ିକୁ flag କରିପାରିବେ। ଆମର mock test ଗୁଡ଼ିକ code ପଢ଼ିବା, ତାହାର ଧାରା ବୁଝିବା, debugging କରିବା ଏବଂ ଠିକ୍ code ବାଛିବାର ଅଭ୍ୟାସ କରାଏ। ଆପଣ ଲେଖିଥିବା code ଏଗୁଡ଼ିକ ଚଲାଏ ନାହିଁ। ଅନେକ ପ୍ରକୃତ assessment ରେ ଲୁଚାଯାଇଥିବା test case ବିରୋଧରେ ଚାଲୁଥିବା code ଲେଖିବାକୁ କୁହାଯାଏ। ଏହି ଅଭ୍ୟାସ ସେଥିପାଇଁ ଆବଶ୍ୟକ code ପଢ଼ିବା, ଧାରା ବୁଝିବା ଓ debugging କୌଶଳ ଗଢ଼ିଥାଏ। ତେଣୁ ଏକ ପ୍ରକୃତ editor ରେ ସମୟ ଧରି ମଧ୍ୟ ଅଭ୍ୟାସ କରନ୍ତୁ। ଆମର mock test ଗୁଡ଼ିକରେ proctoring, plagiarism ଯାଞ୍ଚ, video interview, ଘରେ କରିବାକୁ ଦିଆଯାଉଥିବା କାମ, project କାର୍ଯ୍ୟ ଏବଂ ନିଯୋକ୍ତାଙ୍କ pass mark ଅନ୍ତର୍ଭୁକ୍ତ ନୁହେଁ।

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

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

1. Python ଧାରଣା। a == b ଏବଂ a is b ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କ’ଣ? ପ୍ରଥମଟି ଦୁଇଟି ମୂଲ୍ୟ ସମାନ କି ନାହିଁ ପଚାରେ; ଦ୍ୱିତୀୟଟି ସେଗୁଡ଼ିକ ଏକେ object କି ନୁହେଁ ପଚାରେ। ଅଲଗା ଦୁଇଟି list [1, 2] ସମାନ, କିନ୍ତୁ ଏକେ object ନୁହେଁ। ଫାନ୍ଦ: ସଂଖ୍ୟା କିମ୍ବା string ତୁଳନା କରିବାକୁ is ବ୍ୟବହାର କରିବା। ଛୋଟ ମୂଲ୍ୟ ପାଇଁ ଏହା କାମ କରୁଥିବା ଭଳି ଲାଗିପାରେ, କିନ୍ତୁ ପରେ ବିଫଳ ହୋଇପାରେ।

2. Code କ’ଣ ପ୍ରିଣ୍ଟ କରେ। ପ୍ରଥମେ x = [0] * 3, ତା’ପରେ x[1] = 5 ଏବଂ print(x)। ଏହାକୁ ଅନୁସରଣ କରନ୍ତୁ: [0, 0, 0] ବଦଳି [0, 5, 0] ହୁଏ। ଏବେ grid = [[0] * 2] * 2 ଏବଂ ତା’ପରେ grid[0][0] = 1 ଚେଷ୍ଟା କରନ୍ତୁ। ଏହା [[1, 0], [1, 0]] ପ୍ରିଣ୍ଟ କରେ, କାରଣ ଉଭୟ row ଏକେ inner list। ଫାନ୍ଦ: Python ଯେପରି code ଚଲାଏ ସେହିଭଳି ନୁହେଁ, code କିପରି ଚାଲିବ ବୋଲି ଆପଣ ଭାବୁଛନ୍ତି ସେହିଭଳି ପଢ଼ିବା। ପ୍ରତ୍ୟେକ ଲାଇନ୍‌ରେ ପ୍ରତ୍ୟେକ variable ର ମୂଲ୍ୟ ଲେଖି ରଖନ୍ତୁ।

3. Bug ଖୋଜିବା। for i in range(len(items) - 1): loop ଟି ପ୍ରତ୍ୟେକ item ପ୍ରିଣ୍ଟ କରିବା ପାଇଁ, କିନ୍ତୁ ଶେଷଟିକୁ ଛାଡ଼ିଦିଏ। Bug ଟି ହେଉଛି - 1: range(len(items)) ନିଜେ ଲମ୍ବର ପୂର୍ବରୁ ଅଟକିଯାଏ। ଫାନ୍ଦ: ଭୁଲ୍ ଫଳ ଦେଉଥିବା ଲାଇନ୍ ବଦଳରେ crash କରୁଥିବା କିମ୍ବା ଅଜବ ଦେଖାଯାଉଥିବା ଲାଇନ୍‌ଟିକୁ ଠିକ୍ କରିବା। ମନେମନେ ଦୁଇଟି item ଥିବା list ପରି ଏକ ଛୋଟ input ଦେଇ code ଯାଞ୍ଚ କରନ୍ତୁ।

4. ସମାଧାନ ତିଆରି କରିବା। ଏକ list ରେ ପ୍ରତ୍ୟେକ ଶବ୍ଦ କେତେଥର ଆସିଛି ଗଣନା କରିବାକୁ ପଡ଼ିବ। collections.Counter(words) ଗୋଟିଏ ପଦକ୍ଷେପରେ ଏହା କରେ; loop ଭିତରେ counts[w] = counts.get(w, 0) + 1 ବ୍ୟବହାର କରୁଥିବା dictionary ଦ୍ୱାରା ମାନୁଆଲ୍ ଭାବେ ଏହା କରାଯାଏ। ଫାନ୍ଦ: ସାଧାରଣ ପରିସ୍ଥିତିରେ କାମ କରେ, କିନ୍ତୁ ସୀମାନ୍ତ ପରିସ୍ଥିତିରେ ନୁହେଁ, ଏପରି ବିକଳ୍ପ ବାଛିବା। ଖାଲି list, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତି ଏବଂ ଋଣାତ୍ମକ ସଂଖ୍ୟା ସହ ପ୍ରତ୍ୟେକ ବିକଳ୍ପ ଯାଞ୍ଚ କରନ୍ତୁ।

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

1. ପ୍ରଥମେ ଆପଣଙ୍କ ଆମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ଆପଣ କେଉଁ ପ୍ଲାଟଫର୍ମ ବ୍ୟବହାର କରିବେ, କେତୋଟି task ଅଛି, ସମୟ ସୀମା କେତେ, Python 3 ବାଛିପାରିବେ କି ନାହିଁ, ଏବଂ ପରୀକ୍ଷା ନିରୀକ୍ଷଣ ହେବ କି ନାହିଁ, ଜାଣନ୍ତୁ। ପରୀକ୍ଷାର ଢାଞ୍ଚା ଏତେ ଭିନ୍ନ ହୋଇପାରେ ଯେ ଅନୁମାନ କରିବା ଠିକ୍ ନୁହେଁ।
2. ପ୍ଲାଟଫର୍ମରେ ଅଭ୍ୟାସ କରିବା ପାଇଁ ବିଭାଗ ଥିଲେ ତାହା ବ୍ୟବହାର କରନ୍ତୁ। Editor, Run button ଏବଂ sample test case କିପରି ଦେଖାଯାଏ, ସେଥିରେ ଅଭ୍ୟସ୍ତ ହୁଅନ୍ତୁ, ଯାହାଦ୍ୱାରା ପରୀକ୍ଷା ଦିନ ସେହି screen ନୂଆ ଲାଗିବ ନାହିଁ। ଉଦାହରଣ ସ୍ୱରୂପ, HackerRank କହେ ଯେ ପ୍ରାର୍ଥୀମାନେ କାମ କରୁଥିବା ସମୟରେ Run ଉପରେ click କରି test case ଚଲାନ୍ତି (HackerRank Support)।
3. ହାତରେ code ଅନୁସରଣ କରନ୍ତୁ। ଛୋଟ code snippet ପାଇଁ, ପ୍ରତ୍ୟେକ line ପରେ ପ୍ରତ୍ୟେକ variable ର value ଲେଖନ୍ତୁ। Output ଓ debugging ପ୍ରଶ୍ନର ମୂଳ ଦକ୍ଷତା ଏହା, ଏବଂ code ଚଲାଇବା ଛାଡ଼ି ନିଜ code ଯାଞ୍ଚ କରିବାର ଉପାୟ ମଧ୍ୟ ଏହା।
4. ଦୈନନ୍ଦିନ ବ୍ୟବହାରର tools ଜାଣନ୍ତୁ। List, dictionary, set, string, slicing, sorted ଏବଂ list.sort ମଧ୍ୟର ତଫାତ, enumerate, zip, list ଓ dictionary comprehension, ଏବଂ collections.Counter।
5. ଉତ୍ତର ଦାଖଲ ପୂର୍ବରୁ edge case ବିଷୟରେ ଭାବନ୍ତୁ। ଖାଲି input, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତ value, ଋଣାତ୍ମକ ସଂଖ୍ୟା, ବହୁତ ବଡ଼ input। ଲୁକ୍କାୟିତ test case ଗୁଡ଼ିକ ପ୍ରାୟତଃ ଏହିସବୁକୁ ହିଁ ଯାଞ୍ଚ କରେ।
6. ସମୟ ଧରି code ଲେଖନ୍ତୁ। ଆମର mock test ଗୁଡ଼ିକ ପଢ଼ିବା ଓ debugging ର ଅଭ୍ୟାସ କରାଏ। ଚାପରେ code ଲେଖିବା ଓ ଚଲାଇବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ timer ଲଗାଇ ପ୍ରକୃତ editor ରେ କିଛି ଛୋଟ ସମସ୍ୟା ମଧ୍ୟ ସମାଧାନ କରନ୍ତୁ।
7. ପ୍ରକୃତ ପରୀକ୍ଷାର ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। ଆପଣଙ୍କ ପରୀକ୍ଷା HackerRank ର Python (Basic) ଉଦାହରଣ ପରି ହେଲେ, 1 ଘଣ୍ଟା 30 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ଅର୍ଥାତ୍ ପ୍ରତ୍ୟେକ ସମସ୍ୟା ପାଇଁ ପ୍ରାୟ 45 ମିନିଟ୍ (HackerRank)। ସମୟ ନିଜେ ଠିକ୍ ଭାବେ ବାଣ୍ଟିବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ ପୂରା timed mock test ଦିଅନ୍ତୁ।

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

ସ୍କୋରିଂ ପ୍ଲାଟଫର୍ମ ଏବଂ ନିଯୁକ୍ତିଦାତା ଉପରେ ନିର୍ଭର କରେ। କୌଣସି ସାର୍ବଜନୀନ ସ୍କେଲ୍ କିମ୍ବା ଉତ୍ତୀର୍ଣ୍ଣ ମାନଦଣ୍ଡ ନାହିଁ। କୋଡିଂ ପ୍ରଶ୍ନଗୁଡ଼ିକର ସ୍କୋର ସାଧାରଣତଃ test case ସହ ତୁଳନା କରି ସ୍ୱୟଂଚାଳିତ ଭାବେ ଦିଆଯାଏ। ଦୁଇଟି ସାର୍ବଜନୀନ ବିବରଣୀ:

• HackerRank କହେ ଯେ ସଠିକତା ଏବଂ କାର୍ଯ୍ୟଦକ୍ଷତା ମାପୁଥିବା ପୂର୍ବନିର୍ଦ୍ଧାରିତ test case ମାଧ୍ୟମରେ କୋଡିଂ ପ୍ରଶ୍ନଗୁଡ଼ିକର ମୂଲ୍ୟାୟନ କରାଯାଏ। ପ୍ରତ୍ୟେକ test case ପାଇଁ ଅଲଗା ସ୍କୋର ଥାଏ: କୌଣସି test case ରେ ସଫଳ ହେଉଥିବା କୋଡ୍ ସେହି test case ର ପୂରା ସ୍କୋର ପାଏ, ଏବଂ ବିଫଳ ହେଉଥିବା କୋଡ୍ ଶୂନ୍ୟ ପାଏ। ପ୍ରଶ୍ନର ମୋଟ ସ୍କୋର ହେଉଛି ଉତ୍ତୀର୍ଣ୍ଣ ହୋଇଥିବା test case ଗୁଡ଼ିକର ସ୍କୋରର ଯୋଗଫଳ। ତେଣୁ କିଛି test case ରେ ସଫଳ ହେଉଥିବା ସମାଧାନ ଆଂଶିକ ନମ୍ବର ପାଏ (HackerRank ସହାୟତା). କୋଡିଂ ଏବଂ ବହୁବିକଳ୍ପ ପ୍ରଶ୍ନଗୁଡ଼ିକର ମୂଲ୍ୟାୟନ ସ୍ୱୟଂଚାଳିତ ଭାବେ ହୁଏ। ତେବେ କେତେକ ପ୍ରକାର, ଯେପରିକି ମତାମତ ଭିତ୍ତିକ ଉତ୍ତର ଏବଂ ଫାଇଲ୍ ଅପଲୋଡ୍, ହାତରେ ମୂଲ୍ୟାୟନ କରାଯାଏ (HackerRank ସହାୟତା).
• TestGorilla ସାମଗ୍ରିକ ସଠିକତା ଉପରେ ଆଧାରିତ ପର୍ସେଣ୍ଟାଇଲ୍ ସ୍କୋରିଂ ବିଷୟରେ କହେ। ଏହାର ଅର୍ଥ ହେଉଛି, ଦିଆଯାଇଥିବା input ରୁ ସଠିକ୍ output ମିଳୁଛି କି ନାହିଁ। ଏହା ପ୍ରତ୍ୟେକ test case ର ଫଳାଫଳ ଦେଖାଉଥିବା ଏକ ରିପୋର୍ଟ ମଧ୍ୟ ଦିଏ (TestGorilla).

କେଉଁ ଫଳାଫଳକୁ ଭଲ ବୋଲି ଧରାଯିବ, ତାହା ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ସ୍ଥିର କରନ୍ତି। ଅନେକ ନିଯୁକ୍ତିଦାତା ସ୍କୋର ସହ ଆପଣଙ୍କ କୋଡ୍‌କୁ ମଧ୍ୟ ଦେଖନ୍ତି।

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

ସାଧାରଣ ଭୁଲ

• ତାଲିକାକୁ ବଦଳାଉଥିବା methods ଏବଂ ନୂଆ ତାଲିକା ଫେରାଉଥିବା functions କୁ ଗୋଳମାଳ କରିବା। list.sort() ଏବଂ list.append() None ଫେରାଏ; sorted() ଏକ ନୂଆ ତାଲିକା ଫେରାଏ।
• Assignment କଲେ object ଗୁଡ଼ିକ ସେୟାର ହୁଏ ବୋଲି ଭୁଲିଯିବା। b = a କଲେ ତାଲିକା କିମ୍ବା dictionary ର copy ତିଆରି ହୁଏ ନାହିଁ। Copy ଦରକାର ହେଲେ a[:], list(a) କିମ୍ବା copy.deepcopy(a) ବ୍ୟବହାର କରନ୍ତୁ।
• Range ଏବଂ slice ରେ off-by-one ତ୍ରୁଟି। range(n) ରେ n ପୂର୍ବରୁ ଥମିଯାଏ, ଏବଂ s[1:3] ତିନିଟି ନୁହେଁ, ଦୁଇଟି item ନିଏ।
• ମନଗଢ଼ା ମୂଲ୍ୟରୁ search ଆରମ୍ଭ କରିବା। Maximum କୁ 0 ରୁ କିମ୍ବା minimum କୁ 1000 ରୁ ଆରମ୍ଭ କଲେ ଅସାଧାରଣ input ରେ ସମସ୍ୟା ହୁଏ। ପ୍ରଥମ item ରୁ, କିମ୍ବା float("-inf") ରୁ ଆରମ୍ଭ କରନ୍ତୁ।
• କେବଳ ଉଦାହରଣଟି ପରୀକ୍ଷା କରିବା। ଦେଖାଯାଉଥିବା ଉଦାହରଣ ସାଧାରଣତଃ ପାସ୍ ହୁଏ। Hidden test cases ଖାଲି input, ଗୋଟିଏ item, ଡୁପ୍ଲିକେଟ୍ ଏବଂ ବଡ଼ input ଯାଞ୍ଚ କରେ।
• ଗୋଟିଏ task ରେ ସମୟ ସରିଯିବା। ଅଟକିଗଲେ, କିଛି test cases ପାସ୍ କରୁଥିବା ଏକ ସରଳ version submit କରନ୍ତୁ, ଆଗକୁ ବଢ଼ନ୍ତୁ, ଏବଂ ସମୟ ଥିଲେ ପରେ ଫେରିଆସନ୍ତୁ।