Java coding test ଅଭ୍ୟାସ

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

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

• HackerRank. HackerRank ଏହାର Java (Basic) skills testକୁ 6 questions in 1 hour ଭାବେ ତାଲିକାଭୁକ୍ତ କରିଛି। ଏଥିରେ classes ଭଳି ବିଷୟ ରହିଛି (HackerRank)। ଏହାର help centerରେ ନିଯୁକ୍ତିଦାତା testରେ ରଖିପାରୁଥିବା ପ୍ରଶ୍ନ ପ୍ରକାରଗୁଡ଼ିକ ତାଲିକାଭୁକ୍ତ ହୋଇଛି। ସେଥିରେ coding, multiple choice, database, back-end developer, code review ଓ subjective questions ରହିଛି। ନିଯୁକ୍ତିଦାତାମାନେ HackerRankର libraryରୁ ପ୍ରଶ୍ନ ଯୋଡ଼ିପାରିବେ କିମ୍ବା ନିଜେ ପ୍ରଶ୍ନ ଲେଖିପାରିବେ ବୋଲି ଏଥିରେ କୁହାଯାଇଛି (HackerRank Help)।
• TestGorilla. TestGorillaର Java coding tests ପୃଷ୍ଠାରେ କୁହାଯାଇଛି ଯେ ଏହାର ଅଧିକାଂଶ coding test 15 ରୁ 35 minutes ଲାଗେ। ଏଥିରେ entry-level algorithms test 15 minutesର ବୋଲି ତାଲିକାଭୁକ୍ତ ହୋଇଛି। ପ୍ରାର୍ଥୀମାନେ ସମସ୍ୟା ପଢ଼ନ୍ତି, ଭାଷା ତାଲିକାରୁ Java ବାଛନ୍ତି ଏବଂ online editorରେ ସମାଧାନ ଲେଖନ୍ତି ବୋଲି ମଧ୍ୟ କୁହାଯାଇଛି (TestGorilla)।

ନିଯୁକ୍ତିଦାତାଙ୍କ Java testରେ ସାଧାରଣତଃ ଥିବା ଅଂଶ:

• Coding tasks: online editorରେ ଏକ method ଲେଖନ୍ତୁ, sample inputs ଦେଇ ଏହା ଚଲାନ୍ତୁ, ତାପରେ ଏହାକୁ submit କରନ୍ତୁ। ଏହାକୁ ଆପଣ ଦେଖିନଥିବା ଅନ୍ୟ test cases ସହିତ ଯାଞ୍ଚ କରାଯାଇପାରେ।
• Multiple choice: types, classes, collections ଓ exceptions ଭଳି Java ଧାରଣା, ଏକ code snippet କ’ଣ print କରେ, ଏବଂ କେଉଁ code ଠିକ୍।
• Debugging କିମ୍ବା code review: ଅନ୍ୟ କେହି ଲେଖିଥିବା codeରେ ସମସ୍ୟା ଖୋଜି ଠିକ୍ କରିବା।
• କେବେ କେବେ ଅଧିକ କିଛି: SQL ପ୍ରଶ୍ନ, framework କିମ୍ବା back-end project, ଘରେ କରିବାକୁ ଦିଆଯାଇଥିବା assignment, କିମ୍ବା test ସମୟରେ webcam ଓ screen monitoring।

ଆମ mock testରେ କ’ଣ ରହିଛି। ଆମର full mock testରେ 60 minutesରେ 20ଟି ପ୍ରଶ୍ନ ଏବଂ ଚାରିଟି ବିଭାଗ ଅଛି: Java concepts (6), code କ’ଣ print କରେ (6), bug ଖୋଜିବା (5) ଏବଂ solution ତିଆରି କରିବା (3)। ସମସ୍ତ code Java 17ରେ ଅଛି। Submit କରିବା ପର୍ଯ୍ୟନ୍ତ ଆପଣ ପଛକୁ ଯାଇପାରିବେ, ଉତ୍ତର ବଦଳାଇପାରିବେ ଏବଂ ପ୍ରଶ୍ନଗୁଡ଼ିକୁ flag କରିପାରିବେ। ଆମ mock testରେ code ପଢ଼ିବା, ଏହା କିପରି ଚାଲେ ତାହା ଅନୁସରଣ କରିବା, debugging କରିବା ଓ code ବାଛିବାର ଅଭ୍ୟାସ ହୁଏ। ଆପଣ ଲେଖିଥିବା code ଏଥିରେ ଚଲେ ନାହିଁ। ଅନେକ ବାସ୍ତବ assessmentରେ ଲୁଚାଇ ରଖାଯାଇଥିବା test cases ଉପରେ ଚାଲୁଥିବା code ଲେଖିବାକୁ କୁହାଯାଏ। ଏହି ଅଭ୍ୟାସ ସେଥିପାଇଁ ଆବଶ୍ୟକ code ପଢ଼ିବା, ଅନୁସରଣ କରିବା ଓ debugging କୌଶଳ ଗଢ଼ିଥାଏ। ତେଣୁ ଏକ ପ୍ରକୃତ editorରେ ସମୟ ଧରି ଅଭ୍ୟାସ ମଧ୍ୟ କରନ୍ତୁ। ଆମ mock testରେ proctoring, plagiarism checks, video interviews, ଘରେ କରିବାକୁ ଦିଆଯାଇଥିବା କାମ ଓ project tasks, ଏବଂ ନିଯୁକ୍ତିଦାତାଙ୍କ ଯେକୌଣସି pass mark ନାହିଁ।

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

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

1. Java ଧାରଣା। int ଏବଂ Integer ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କ’ଣ? int ହେଉଛି ଏକ primitive value; Integer ହେଉଛି ତାହାକୁ ଧାରଣ କରୁଥିବା ଏକ object, ଯାହାର ମୂଲ୍ୟ null ହୋଇପାରେ। List ପରି collections ରେ Integer ରହେ ଏବଂ Java ଏହି ଦୁଇଟି ମଧ୍ୟରେ ସ୍ୱୟଂଚାଳିତ ଭାବେ ପରିବର୍ତ୍ତନ କରେ। ଫାନ୍ଦ: ଦୁଇଟି Integer object ତୁଳନା କରିବାକୁ == ବ୍ୟବହାର କରିବା। ଏହା ମୂଲ୍ୟ ସମାନ ଥିଲେ ମଧ୍ୟ reference ତୁଳନା କରେ, ତେଣୁ ଫଳ false ହୋଇପାରେ; equals ବ୍ୟବହାର କରନ୍ତୁ।

2. Code କ’ଣ ପ୍ରିଣ୍ଟ କରେ। System.out.println(1 + 2 + "3" + 4 + 5); ରେ 3345 ପ୍ରିଣ୍ଟ ହୁଏ। Java ବାମରୁ ଡାହାଣକୁ କାମ କରେ: 1 + 2 ର ଫଳ ସଂଖ୍ୟା 3, ତା’ପରେ "3" ଯୋଡ଼ିଲେ string "33" ହୁଏ, ଏବଂ ତା’ପରେ ପ୍ରତ୍ୟେକ + ଟେକ୍ସଟ୍‌କୁ ଯୋଡ଼େ। ଫାନ୍ଦ: ପ୍ରଥମେ ସମସ୍ତ ଗଣିତ କରିଦେବା। ଗୋଟିଏଥରରେ ଗୋଟିଏ operator ଅନୁସରଣ କରନ୍ତୁ ଏବଂ ପ୍ରତ୍ୟେକ ପଦକ୍ଷେପ ପରେ type କ’ଣ ହେଲା ଲେଖନ୍ତୁ।

3. Bug ଖୋଜିବା। ଏକ method ରେ if (status == "done") ରହିଛି, କିନ୍ତୁ status "done" ହେଲେ ମଧ୍ୟ ଏହା କେବେ match ହୁଏନାହିଁ। ଏହାକୁ "done".equals(status) କରିବା ହେଉଛି ସମାଧାନ। ଏହା ଅକ୍ଷରଗୁଡ଼ିକୁ ତୁଳନା କରେ ଏବଂ null status ଥିଲେ ମଧ୍ୟ ସମ୍ଭାଳିପାରେ। ଫାନ୍ଦ: ଅସ୍ୱାଭାବିକ ଦେଖାଯାଉଥିବା ପ୍ରଥମ ଲାଇନ୍‌ଟିକୁ ଠିକ୍ କରିବା। Code ମଧ୍ୟରେ ଏକ ଛୋଟ input ଅନୁସରଣ କରନ୍ତୁ ଏବଂ କେଉଁ ଲାଇନ୍‌ରେ ପ୍ରଥମେ ମୂଲ୍ୟ ଭୁଲ୍ ହେଉଛି ଖୋଜନ୍ତୁ।

4. ସମାଧାନ ତିଆରି କରିବା। ପ୍ରତ୍ୟେକ ଶବ୍ଦ କେତେଥର ଆସିଛି ଗଣନା କରିବାକୁ ପଡ଼ିବ। Loop ଭିତରେ counts.merge(word, 1, Integer::sum) ବ୍ୟବହାର କରୁଥିବା HashMap ରେ ପ୍ରତ୍ୟେକ ଶବ୍ଦ ପାଇଁ ଗୋଟିଏ ଲାଇନ୍‌ରେ ଏହା ହୋଇଯାଏ। ଫାନ୍ଦ: ସାଧାରଣ ପରିସ୍ଥିତିରେ କାମ କରେ, କିନ୍ତୁ ସୀମାନ୍ତ ପରିସ୍ଥିତିରେ ନୁହେଁ, ଏପରି ବିକଳ୍ପ ବାଛିବା। ଖାଲି array, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତି, ଋଣାତ୍ମକ ସଂଖ୍ୟା ଏବଂ null ସହ ପ୍ରତ୍ୟେକ ବିକଳ୍ପ ଯାଞ୍ଚ କରନ୍ତୁ।

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

1. ପ୍ରଥମେ ଆପଣଙ୍କ ଆମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ଆପଣ କେଉଁ ପ୍ଲାଟଫର୍ମ ବ୍ୟବହାର କରିବେ, କେତୋଟି task ଅଛି, ସମୟ ସୀମା କେତେ, editor ରେ Java ର କେଉଁ version ଚାଲିବ, ଏବଂ ପରୀକ୍ଷା ନିରୀକ୍ଷଣ ହେବ କି ନାହିଁ, ଜାଣନ୍ତୁ। ପରୀକ୍ଷାର ଢାଞ୍ଚା ଏତେ ଭିନ୍ନ ହୋଇପାରେ ଯେ ଅନୁମାନ କରିବା ଠିକ୍ ନୁହେଁ।
2. ପ୍ଲାଟଫର୍ମରେ ଅଭ୍ୟାସ କରିବା ପାଇଁ ବିଭାଗ ଥିଲେ ତାହା ବ୍ୟବହାର କରନ୍ତୁ। Editor, Run button, input କିପରି ପଢ଼ାଯାଏ ଏବଂ sample test case କିପରି ଦେଖାଯାଏ, ସେଥିରେ ଅଭ୍ୟସ୍ତ ହୁଅନ୍ତୁ, ଯାହାଦ୍ୱାରା ପରୀକ୍ଷା ଦିନ ସେହି screen ନୂଆ ଲାଗିବ ନାହିଁ। ଉଦାହରଣ ସ୍ୱରୂପ, HackerRank କହେ ଯେ ପ୍ରାର୍ଥୀମାନେ କାମ କରୁଥିବା ସମୟରେ Run ଉପରେ click କରି test case ଚଲାନ୍ତି (HackerRank Support)।
3. ହାତରେ code ଅନୁସରଣ କରନ୍ତୁ। ଛୋଟ code snippet ପାଇଁ, ପ୍ରତ୍ୟେକ line ପରେ ପ୍ରତ୍ୟେକ variable ର value ଏବଂ type ଲେଖନ୍ତୁ। Integer division, string ଯୋଡ଼ିବା ଏବଂ reference ରେ ଅଧିକାଂଶ ଅପ୍ରତ୍ୟାଶିତ ଭୁଲ ହୁଏ।
4. ଦୈନନ୍ଦିନ ବ୍ୟବହାରର tools ଜାଣନ୍ତୁ। Array, String ଏବଂ StringBuilder, ArrayList, HashMap, HashSet, Arrays.sort ଏବଂ Collections.sort, equals ଏବଂ hashCode, exception, ଏବଂ ମୌଳିକ class ଓ interface।
5. ଉତ୍ତର ଦାଖଲ ପୂର୍ବରୁ edge case ବିଷୟରେ ଭାବନ୍ତୁ। ଖାଲି array ଓ string, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତ value, ଋଣାତ୍ମକ ସଂଖ୍ୟା, null, ଏବଂ int ର ସୀମା ଅତିକ୍ରମ କରିବା ପର୍ଯ୍ୟନ୍ତ ବଡ଼ value। ଲୁକ୍କାୟିତ test case ଗୁଡ଼ିକ ପ୍ରାୟତଃ ଏହିସବୁକୁ ହିଁ ଯାଞ୍ଚ କରେ।
6. ସମୟ ଧରି code ଲେଖନ୍ତୁ। ଆମର mock test ଗୁଡ଼ିକ ପଢ଼ିବା ଓ debugging ର ଅଭ୍ୟାସ କରାଏ। ଚାପରେ code ଲେଖିବା, compile କରିବା ଓ ଚଲାଇବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ timer ଲଗାଇ ପ୍ରକୃତ editor ରେ କିଛି ଛୋଟ ସମସ୍ୟା ମଧ୍ୟ ସମାଧାନ କରନ୍ତୁ।
7. ପ୍ରକୃତ ପରୀକ୍ଷାର ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। ଆପଣଙ୍କ ପରୀକ୍ଷା HackerRank ର Java (Basic) ଉଦାହରଣ ପରି ହେଲେ, 1 ଘଣ୍ଟାରେ 6ଟି ପ୍ରଶ୍ନ ଅର୍ଥାତ୍ ପ୍ରତ୍ୟେକ ପ୍ରଶ୍ନ ପାଇଁ ପ୍ରାୟ 10 ମିନିଟ୍ (HackerRank)। ସମୟ ନିଜେ ଠିକ୍ ଭାବେ ବାଣ୍ଟିବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ ପୂରା timed mock test ଦିଅନ୍ତୁ।

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

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

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

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

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

ସାଧାରଣ ଭୁଲ

• == ସହିତ strings ତୁଳନା କରିବା। equals ବ୍ୟବହାର କରନ୍ତୁ, କିମ୍ବା value null ହୋଇପାରେ ଯଦି "text".equals(value) ବ୍ୟବହାର କରନ୍ତୁ।
• integer division ରୁ decimal ମିଳିବ ବୋଲି ଭାବିବା। 7 / 2 ର ଫଳ 3। 3.5 ଦରକାର ହେଲେ, ପ୍ରଥମେ ଗୋଟିଏ ପାର୍ଶ୍ୱକୁ double କରନ୍ତୁ।
• strings ପରିବର୍ତ୍ତନଶୀଳ ନୁହେଁ ବୋଲି ଭୁଲିଯିବା। s.trim() ଏବଂ s.toUpperCase() ନୂଆ strings ଫେରାଇଥାଏ; ଫଳାଫଳକୁ assign କରନ୍ତୁ।
• loops ରେ off-by-one ତ୍ରୁଟି। Index 0 ରୁ length - 1 ପର୍ଯ୍ୟନ୍ତ ଥାଏ, ତେଣୁ ସାଧାରଣ loop condition ହେଉଛି i < a.length।
• for-each loop ଭିତରେ list ବଦଳାଇବା। removeIf କିମ୍ବା ଏକ ସ୍ପଷ୍ଟ Iterator ଏବଂ ତାହାର remove method ବ୍ୟବହାର କରନ୍ତୁ।
• overflow କୁ ଅଣଦେଖା କରିବା। ବଡ଼ int ମୂଲ୍ୟଗୁଡ଼ିକର ଯୋଗଫଳ ଓ ଗୁଣଫଳ ନିରବରେ wrap around ହୋଇପାରେ। ମୂଲ୍ୟ ବଢ଼ିପାରେ ଯଦି long ବ୍ୟବହାର କରନ୍ତୁ।
• କେବଳ ଉଦାହରଣଟି ପରୀକ୍ଷା କରିବା। ଦେଖାଯାଉଥିବା ଉଦାହରଣ ସାଧାରଣତଃ ସଫଳ ହୁଏ। Hidden test cases ଖାଲି input, ଗୋଟିଏ item, ନକଲି ମୂଲ୍ୟ ଏବଂ ବଡ଼ input ଯାଞ୍ଚ କରେ।
• ଗୋଟିଏ task ରେ ସମୟ ସରିଯିବା। ଅଟକିଗଲେ, କିଛି test cases ପାସ୍ କରୁଥିବା ଏକ ସରଳ version submit କରନ୍ତୁ, ଆଗକୁ ବଢ଼ନ୍ତୁ, ଏବଂ ସମୟ ଥିଲେ ପରେ ଫେରିଆସନ୍ତୁ।