Codility-ଶୈଳୀର coding test ପ୍ରାକ୍ଟିସ୍

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

କୌଣସି ଏକମାତ୍ର Codility test ନାହିଁ। Codility ଏକ platform: ପ୍ରତ୍ୟେକ employer ନିଜ test ପାଇଁ tasks, ଅନୁମତିପ୍ରାପ୍ତ languages ଏବଂ ସମୟସୀମା ବାଛନ୍ତି। ଆପଣଙ୍କ test ସମ୍ପର୍କରେ employerଙ୍କ ନିମନ୍ତ୍ରଣ ହିଁ ସବୁଠାରୁ ଭଲ ମାର୍ଗଦର୍ଶିକା।

Codility ଯାହା କହେ। Codility କହେ ଯେ ପ୍ରତ୍ୟେକ task ନିର୍ଦ୍ଧାରିତ ମାନଦଣ୍ଡ ଅନୁସାରେ ସ୍ୱୟଂଚାଳିତ ଭାବେ ସ୍କୋର କରାଯାଏ (Codility)। ପ୍ରୋଗ୍ରାମରମାନଙ୍କ ପାଇଁ ଏହାର ମାଗଣା lessons (Codility) task ର ଶୈଳୀ ଦେଖାଏ: ଏକ ଛୋଟ ସମସ୍ୟା, ଲେଖିବାକୁ ଥିବା ଏକ function ଏବଂ ନିର୍ଦ୍ଧାରିତ input ସୀମା। ଉଦାହରଣ ସ୍ୱରୂପ, ଏହାର BinaryGap lesson task ରେ 2,147,483,647 ପର୍ଯ୍ୟନ୍ତ input ପାଇଁ "ଏକ ଦକ୍ଷ algorithm" ଲେଖିବାକୁ କୁହାଯାଏ (Codility), ଏବଂ ଗୋଟିଏ lesson ର ନାମ Time Complexity (Codility)।

Codility tests ବିଷୟରେ ସାଧାରଣତଃ ଯାହା ଜଣାଯାଏ (ପ୍ରାର୍ଥୀ ଏବଂ ଗାଇଡ୍‌ଗୁଡ଼ିକ ଅନୁସାରେ, ଆମେ ଖୋଲିପାରିଥିବା Codility ପୃଷ୍ଠାରେ ନିଶ୍ଚିତ କରାଯାଇନାହିଁ):

• ଗୋଟିଏ timer ଭିତରେ କିଛି tasks ଥାଏ, ଯାହା ସାଧାରଣତଃ ସମ୍ପୂର୍ଣ୍ଣ test ପାଇଁ 30 minutes ରୁ 2 hours ମଧ୍ୟରେ ହୋଇଥାଏ।
• ଲୁକ୍କାୟିତ correctness tests: task ରେ ଦେଖାଯାଇଥିବା ଉଦାହରଣ ବ୍ୟତୀତ ଆପଣ ଦେଖିନଥିବା cases ଉପରେ ମଧ୍ୟ ଆପଣଙ୍କ code ଯାଞ୍ଚ ହୁଏ।
• ବଡ଼ inputs ଉପରେ performance ଆଲଗୋରିଥମ୍ ଆଧାରିତ tasks ପାଇଁ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ: ସଠିକ୍ କିନ୍ତୁ ଧୀର solution ରେ points କମିପାରେ।
• ସମୟସୀମା ମଧ୍ୟରେ ଆପଣ ନେଉଥିବା ସମୟ ସ୍କୋରର ଅଂଶ ନୁହେଁ।

ଆମ mocks ରେ କ'ଣ ରହିଛି। ପ୍ରତ୍ୟେକ ପୂର୍ଣ୍ଣ mock ରେ 90 minutes ମଧ୍ୟରେ ତିନୋଟି coding tasks ଥାଏ, ସହଜ task ରୁ କଠିନ task ପର୍ଯ୍ୟନ୍ତ। ଆପଣ Python, JavaScript, Java କିମ୍ବା C++ ରେ solution ଲେଖି ଚଲାଇପାରିବେ, ଏବଂ ଏହା ଲୁକ୍କାୟିତ test cases ଉପରେ ଯାଞ୍ଚ ହୁଏ। ଯେଉଁ ପ୍ରତ୍ୟେକ case ରେ ଏହା ସଫଳ ହୁଏ, ସେଥିପାଇଁ credit ମିଳେ। Laptop ବ୍ୟବହାର କରିବାକୁ ପରାମର୍ଶ ଦିଆଯାଏ। Submit କରିବା ପର୍ଯ୍ୟନ୍ତ ଆପଣ ପଛକୁ ଯାଇ solution ବଦଳାଇପାରିବେ।

ଆମ mocks କିପରି ଭିନ୍ନ। ସାଧାରଣତଃ ଜଣାଯାଏ ଯେ ପ୍ରକୃତ Codility tasks ରେ correctness ଏବଂ ଅନେକ tasks ପାଇଁ ବଡ଼ inputs ଉପରେ performance ଯାଞ୍ଚ ହୁଏ। ଆମ ଲୁକ୍କାୟିତ cases ଛୋଟ ଏବଂ correctness ଓ edge cases ଯାଞ୍ଚ କରେ, ତେଣୁ ଧୀର solution ପାଇଁ ସମୟ ସମାପ୍ତ ହୁଏନାହିଁ; ବଡ଼ input ପାଇଁ କେଉଁ complexity ଆବଶ୍ୟକ, ତାହା ପ୍ରତ୍ୟେକ task ର ବ୍ୟାଖ୍ୟାରେ କୁହାଯାଇଛି। 10ଟି ମାଗଣା questions ହେଉଛି correctness, complexity, edge cases ଏବଂ speed ଉପରେ multiple choice questions, ଅର୍ଥାତ୍ ସେହି ଯାଞ୍ଚଗୁଡ଼ିକରେ ସଫଳ ହେବା ପଛରେ ଥିବା ଚିନ୍ତାଧାରା।

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

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

1. କେଉଁ ସମାଧାନଟି ସଠିକ୍। କାମ: ଏକ list ରେ ଥିବା ଭିନ୍ନ ଭିନ୍ନ ମୂଲ୍ୟର ସଂଖ୍ୟା ଫେରାଇବା। ସମାଧାନ: len(set(A))। ଏହା ଖାଲି list ସମେତ ପ୍ରତ୍ୟେକ list ପାଇଁ ସଠିକ୍; ଖାଲି list ହେଲେ ଫଳାଫଳ 0। ଭୁଲର ସମ୍ଭାବନା: sorted list ସହ ନିଜେ loop ଲେଖି ପ୍ରଥମ କିମ୍ବା ଶେଷ item ଭୁଲିଯିବା। built-in ଦ୍ୱାରା କାମ ହେଉଥିଲେ, ଏହା edge case ଗୁଡ଼ିକୁ ଠିକ୍ ଭାବେ ସମ୍ଭାଳୁଛି କି ଯାଞ୍ଚ କରି ବ୍ୟବହାର କରନ୍ତୁ।

2. Time complexity। ଗୋଟିଏ ସମାଧାନ A ଉପରେ loop ଚଲାଏ ଏବଂ loop ଭିତରେ max(A[:i]) କୁ କଲ୍ କରେ। slice ଓ max ପ୍ରତ୍ୟେକେ ସର୍ବାଧିକ iଟି item ଯାଞ୍ଚ କରନ୍ତି, ତେଣୁ ମୋଟ କାମ ପ୍ରାୟ N squared କୁ 2 ରେ ଭାଗ କରିବା ଯୋଗ୍ୟ ପଦକ୍ଷେପ, ଅର୍ଥାତ୍ O(N squared)। ଏହା ବଦଳରେ ଚାଲୁ ସର୍ବାଧିକ ମୂଲ୍ୟ ରଖିଲେ O(N) ହୁଏ। ଭୁଲର ସମ୍ଭାବନା: ଗୋଟିଏ loop ଦେଖି ଏହାକୁ O(N) କହିଦେବା। ଏହା ଭିତରେ slice, sum, count ଏବଂ search ଅଛି କି ଦେଖନ୍ତୁ।

3. କେଉଁ input ରେ ଏହା ଭୁଲ୍ ହୁଏ। କାମ: A ରେ ନଥିବା ସବୁଠାରୁ ଛୋଟ ଧନାତ୍ମକ ପୂର୍ଣ୍ଣାଙ୍କ ଫେରାଇବା। ଗୋଟିଏ ସମାଧାନ max(A) + 1 ଫେରାଏ। A = [1, 2, 3] ଚେଷ୍ଟା କରନ୍ତୁ: ଏହା 4 ଫେରାଏ, ଯାହା ଠିକ୍। A = [1, 3] ଚେଷ୍ଟା କରନ୍ତୁ: ଏହା 4 ଫେରାଏ, କିନ୍ତୁ 2 ନାହିଁ, ତେଣୁ ଉତ୍ତର 2। A = [-3, -1] ଚେଷ୍ଟା କରନ୍ତୁ: ଏହା 0 ଫେରାଏ, କିନ୍ତୁ ଉତ୍ତର 1। ଭୁଲର ସମ୍ଭାବନା: ଗୋଟିଏ ସଠିକ୍ ଉଦାହରଣ ପରେ ଯାଞ୍ଚ ବନ୍ଦ କରିଦେବା। ଜାଣିଶୁଣି edge case ଗୁଡ଼ିକ ତାଲିକା କରନ୍ତୁ: ମଧ୍ୟରେ ଖାଲି ସ୍ଥାନ, ସବୁ ଋଣାତ୍ମକ, ଅନୁମତି ଥିଲେ ଖାଲି list, ଗୋଟିଏ item, ସବୁ ସମାନ ଏବଂ ଅନୁମତିପ୍ରାପ୍ତ ସବୁଠାରୁ ବଡ଼ ମୂଲ୍ୟ।

4. N 100,000 ପର୍ଯ୍ୟନ୍ତ ହେଲେ ଯଥେଷ୍ଟ ଦ୍ରୁତ। ଏକ ଆନୁମାନିକ ନିୟମ ଭାବେ, ସେହି ଆକାରରେ O(N) କିମ୍ବା O(N log N) ଲକ୍ଷ୍ୟ ରଖନ୍ତୁ। O(N squared) ର ଅର୍ଥ ପ୍ରାୟ 10 billion ପଦକ୍ଷେପ, ଯାହା ସାଧାରଣ time limit ଠାରୁ ବହୁତ ଅଧିକ। ଭୁଲର ସମ୍ଭାବନା: ଦଶଟି item ସହ ଯାଞ୍ଚ କରିବା, ଯେଉଁଠାରେ ପ୍ରତ୍ୟେକ ଉପାୟ ତୁରନ୍ତ କାମ କରୁଥିବା ପରି ଲାଗେ। N ବଢ଼ିବା ସହ କାମ କେତେ ବଢ଼େ, ଭାବନ୍ତୁ।

5. ସୀମାଗୁଡ଼ିକ ପଢ଼ିବା। ଯଦି ମୂଲ୍ୟ 1,000,000,000 ପର୍ଯ୍ୟନ୍ତ ହୋଇପାରେ ଏବଂ N 100,000, ତେବେ ଯୋଗଫଳ 100 trillion ପର୍ଯ୍ୟନ୍ତ ପହଞ୍ଚିପାରେ। Python ର integer ଏହା ସମ୍ଭାଳିପାରେ, କିନ୍ତୁ ସ୍ଥିର ଆକାରର integer ଥିବା ଭାଷାରେ overflow ହୋଇପାରେ। ଭୁଲର ସମ୍ଭାବନା: ମୂଲ୍ୟର ସୀମାକୁ ଅଣଦେଖା କରିବା। ଏହା overflow ହେବ କି ନାହିଁ ଏବଂ counting array ପରି କେଉଁ ଉପାୟ ସମ୍ଭବ, ସେ ବିଷୟରେ ସୂଚନା ଦିଏ।

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

1. ପ୍ରଥମେ ଆପଣଙ୍କ ନିମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ଟାସ୍କ ସଂଖ୍ୟା, ମୋଟ ସମୟ ଏବଂ ଅନୁମତିପ୍ରାପ୍ତ ଭାଷା ଲେଖି ରଖନ୍ତୁ। ଏହି ସବୁ ନିଯୁକ୍ତିଦାତା ନିର୍ଦ୍ଧାରଣ କରନ୍ତି, ତେଣୁ ଅନୁମାନ କରନ୍ତୁ ନାହିଁ।
2. ଆପଣ ଭଲ ଭାବେ ଜାଣିଥିବା ଗୋଟିଏ ଭାଷା ବ୍ୟବହାର କରନ୍ତୁ। ଏହାର lists, dictionaries, sets, sorting ଏବଂ string methods ଖୋଜି ନଦେଖି ଜାଣିଥାନ୍ତୁ।
3. କୋଡ୍ ଲେଖିବା ପୂର୍ବରୁ ସୀମାଗୁଡ଼ିକ ପଢ଼ନ୍ତୁ। ଟାସ୍କରେ ଦିଆଯାଇଥିବା inputର ଆକାର ଓ ମୂଲ୍ୟ ସୀମାରୁ ସମାଧାନ କେତେ ଦ୍ରୁତ ହେବା ଦରକାର ଏବଂ କେଉଁ edge cases ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ତାହା ଜଣାପଡ଼େ। Codilityର ନିଜସ୍ୱ lesson taskରେ ମଧ୍ୟ ଏହା ଦେଖାଯାଏ (Codility)।
4. ପ୍ରଥମେ ସଠିକ୍ କରନ୍ତୁ, ପରେ ଦ୍ରୁତ କରନ୍ତୁ। ପ୍ରଥମେ ଏକ ସରଳ ଓ ସଠିକ୍ ସଂସ୍କରଣ ଲେଖନ୍ତୁ। ଯଦି ଏହା O(N squared) ଏବଂ N 100,000 ପର୍ଯ୍ୟନ୍ତ ହୋଇପାରେ, ତେବେ running total, dictionary, set କିମ୍ବା sorting ବ୍ୟବହାର କରି କମାଇବାର ଉପାୟ ଖୋଜନ୍ତୁ।
5. ନିଜେ edge cases ପରୀକ୍ଷା କରନ୍ତୁ। ଟାସ୍କରେ ଥିବା ଉଦାହରଣଟି କେବଳ ଗୋଟିଏ କେସ୍। ଅନୁମତି ଥିଲେ ଖାଲି input, ଗୋଟିଏ item, ସବୁ ସମାନ ମୂଲ୍ୟ, ନେଗେଟିଭ୍ ମୂଲ୍ୟ, ସବୁଠାରୁ ଛୋଟ ଓ ବଡ଼ ମୂଲ୍ୟ, ଏବଂ ସର୍ବାଧିକ N ସହ ପରୀକ୍ଷା କରନ୍ତୁ।
6. ସାଧାରଣ patterns ଶିଖନ୍ତୁ। Prefix sums, sliding windows, dictionary ସହ ଗଣନା, two pointers, ପ୍ରଥମେ sorting ଏବଂ ସରଳ greedy choices - ଏଗୁଡ଼ିକ ଅନେକ ସଂକ୍ଷିପ୍ତ algorithm taskରେ କାମ ଦିଏ। ଏହି ଶୈଳୀ ଦେଖିବା ପାଇଁ Codilityର ମାଗଣା lessons ଏକ ଭଲ ସ୍ଥାନ (Codility)।
7. ସମୟ ସୀମା ମଧ୍ୟରେ ପୂରା ସମାଧାନ ଲେଖନ୍ତୁ। ଆମର ପୂର୍ଣ୍ଣ ମକ୍ ଟେଷ୍ଟ୍‌ରେ ଆପଣ ଲୁକ୍କାୟିତ କେସ୍‌ ସହ କୋଡ୍ ଲେଖି ଚଲାଇବେ। ନିଜେ ବାଛିଥିବା ଟାସ୍କରେ ମଧ୍ୟ ସେହିପରି କରନ୍ତୁ, ଯାହାଦ୍ୱାରା ସମୟ ମଧ୍ୟରେ ଲେଖିବା ସ୍ୱାଭାବିକ ଲାଗିବ।
8. ପ୍ରକୃତ ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। ପୂର୍ଣ୍ଣ timed mock ଦିଅନ୍ତୁ, ଯାହାଦ୍ୱାରା ପରୀକ୍ଷା ଦିନ ଗୋଟିଏ ଟାଇମର୍‌ରେ ତିନୋଟି ଟାସ୍କ କରିବା ସ୍ୱାଭାବିକ ଲାଗିବ।

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

ସ୍କୋରିଂ ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ନିଜେ ନିର୍ଦ୍ଧାରଣ କରନ୍ତି। Codility କହେ ଯେ ପ୍ରତ୍ୟେକ ଟାସ୍କର ମୂଲ୍ୟାଙ୍କନ ନିର୍ଦ୍ଧାରିତ ମାନଦଣ୍ଡ ଅନୁସାରେ ସ୍ୱୟଂଚାଳିତ ଭାବେ କରାଯାଏ (Codility), ଏବଂ କେଉଁ ଫଳାଫଳ ଯଥେଷ୍ଟ ଭଲ ତାହା ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ସ୍ଥିର କରନ୍ତି। ସମସ୍ତଙ୍କ ପାଇଁ ଏକ ସାଧାରଣ ପାସ୍ ମାର୍କ ନାହିଁ।

ସାଧାରଣତଃ ରିପୋର୍ଟ କରାଯାଏ ଯେ ଏହି ମାନଦଣ୍ଡଗୁଡ଼ିକ ଏଭଳି କାମ କରେ: ଗୋଟିଏ ଟାସ୍କର ସ୍କୋର ଲୁକ୍କାୟିତ ସଠିକତା ପରୀକ୍ଷା ଏବଂ ଅନେକ algorithmic ଟାସ୍କରେ ବଡ଼ input ଉପରେ କାର୍ଯ୍ୟଦକ୍ଷତା ପରୀକ୍ଷାରୁ ଆସେ। ଏଗୁଡ଼ିକୁ ମିଶାଇ ପ୍ରଥମେ ଟାସ୍କ ପାଇଁ, ତା'ପରେ ପରୀକ୍ଷା ପାଇଁ ଏକ ପ୍ରତିଶତ ହିସାବ କରାଯାଏ। ଛୋଟ input ପାଇଁ ଠିକ୍ ଥିବା କିନ୍ତୁ ବଡ଼ input ପାଇଁ ଅତ୍ୟଧିକ ଧୀର ସମାଧାନର କାର୍ଯ୍ୟଦକ୍ଷତା ପଏଣ୍ଟ କମିପାରେ, ଆଉ edge case ରେ ବିଫଳ ହେଉଥିବା ସମାଧାନର ସଠିକତା ସ୍କୋରର କିଛି ଅଂଶ କମିଯାଏ। ଏହି କାରଣରୁ ଆମର mock ଗୁଡ଼ିକର ପ୍ରଶ୍ନରେ "ଏହା ସଠିକ୍ କି?" ଏବଂ "ଏହା ଯଥେଷ୍ଟ ଦ୍ରୁତ କି?" ପୃଥକ ଭାବେ ପଚରାଯାଏ।

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

ସାଧାରଣ ଭୁଲ

• ଉଦାହରଣ ଉପରେ ଭରସା କରିବା। କୌଣସି କାର୍ଯ୍ୟର ଉଦାହରଣ ହେଉଛି ଅନେକ ଲୁଚା ଥିବା କେସ୍‌ ମଧ୍ୟରୁ କେବଳ ଗୋଟିଏ। ଗୋଟିଏ ସମାଧାନ ଏହାକୁ ପାସ୍ କରିପାରେ, ତଥାପି ଅଧିକାଂଶ ସ୍କୋରରେ ବିଫଳ ହୋଇପାରେ।
• N କୁ ଅଣଦେଖା କରିବା। ସଠିକ୍ O(N squared) ସମାଧାନ ମଧ୍ୟ N = 100,000 ରେ କାର୍ଯ୍ୟଦକ୍ଷତା ଯାଞ୍ଚରେ ବିଫଳ ହୋଇପାରେ। ପ୍ରଥମେ ସୀମା ଯାଞ୍ଚ କରନ୍ତୁ।
• ଲୁପ୍ ଭିତରେ ଲୁଚିଥିବା କାମ। ଲୁପ୍ ଭିତରେ ଥିବା ଲିଷ୍ଟ୍‌ ଉପରେ slice, sum, count, index କିମ୍ବା "in" ବ୍ୟବହାର କଲେ ଖର୍ଚ୍ଚ ବଢ଼ିଯାଏ।
• ଶେଷ ଆଇଟମ୍ ଛାଡ଼ିଦେବା। ସୀମାରେ ଗୋଟିଏର ତଫାତ୍ ଥିବା ରେଞ୍ଜ୍ ଏବଂ ଲିଷ୍ଟ୍‌ର ଶେଷରେ ସରିଥିବା ରନ୍ ହେଉଛି ବିଫଳତାର ଏକ ପାରମ୍ପରିକ କାରଣ। ଶେଷ ପଦକ୍ଷେପକୁ ହାତରେ ଯାଞ୍ଚ କରନ୍ତୁ।
• ଭୁଲ୍ ଆରମ୍ଭିକ ମୂଲ୍ୟ। ସର୍ବାଧିକ ମୂଲ୍ୟକୁ 0 ରୁ, କିମ୍ବା ସର୍ବନିମ୍ନ ମୂଲ୍ୟକୁ ମନଗଢ଼ା ବଡ଼ ସଂଖ୍ୟାରୁ ଆରମ୍ଭ କଲେ, ନକାରାତ୍ମକ କିମ୍ବା ବହୁତ ବଡ଼ ମୂଲ୍ୟ ଥିବାବେଳେ ଭୁଲ୍ ହୁଏ। ପ୍ରଥମ ଆଇଟମ୍‌ରୁ ଆରମ୍ଭ କରନ୍ତୁ।
• କାର୍ଯ୍ୟ ଯେଉଁ କ୍ରମ ଉପରେ ନିର୍ଭର କରେ, ତାହା ବଦଳାଇବା। ସର୍ଟ କରିବା ଏକ ଉତ୍ତମ ଉପାୟ, କିନ୍ତୁ ଉତ୍ତର ଯଦି ସ୍ଥାନ କିମ୍ବା "first in the list" ଉପରେ ନିର୍ଭର କରେ, ତେବେ ନୁହେଁ।
• ଗୋଟିଏ କାର୍ଯ୍ୟରେ ସମସ୍ତ ସମୟ ବ୍ୟୟ କରିବା। ପ୍ରଥମେ ପ୍ରତ୍ୟେକ କାର୍ଯ୍ୟର ଏକ ସଠିକ୍ ସମାଧାନ ଦାଖଲ କରନ୍ତୁ, ତାପରେ ସମୟ ଥିଲେ ଗତି ବଢ଼ାନ୍ତୁ।