Java/C2/do-while/Oriya

From Script | Spoken-Tutorial
Revision as of 02:26, 4 October 2016 by Pradeep (Talk | contribs)

Jump to: navigation, search
Time Narration
00:01 Javaରେ Do While Loop ଉପରେ ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ କୁ ସ୍ୱାଗତ
00:06 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେ ଆମେ ଶିଖିବା,
  • Do While Loop ଓ
  • ତାକୁ କିପରି ବ୍ୟବହାର କରିବେ
00:12 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଆମେ ବ୍ୟବହାର କରୁଛୁ:
  • Ubuntu 11.10
  • JDK 1.6 ଓ
  • Eclipse 3.7
00:20 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଆପଣଙ୍କର, Javaରେ While Loop ଉପରେ ଜ୍ଞାନ ଥିବା ଦରକାର
00:25 ଯଦି ନାହିଁ, ତେବେ ସମ୍ପର୍କିତ ଟ୍ୟୁଟୋରିଆଲ୍ସ ପାଇଁ ଦୟାକରି ଆମ ୱେବସାଇଟ୍ ଦେଖନ୍ତୁ
00:32 ଏହା ହେଉଛି Do While Loop ପାଇଁ Structure
00:37 ଧ୍ୟାନଦିଅନ୍ତୁ ଯେ, ଏହା ଗୋଟିଏ While Loop ସହିତ ସମାନ
00:40 ଏହାର ଦୁଇଟି ଭାଗ ଅଛି
00:42 ପ୍ରଥମଟି ହେଉଛି Loop Running Condition. ଆଉ ଦ୍ୱିତୀୟଟି ହେଉଛି Loop Variable
00:51 କେବଳ ପାର୍ଥକ୍ୟ ହେଉଛି, କଣ୍ଡିଶନ୍ ଟି Do Block ପରେ ଲେଖାଯାଇଛି
00:58 ଆଉ ତେଣୁ, Do Block ଭିତରେ ଷ୍ଟେଟମେଣ୍ଟଗୁଡ଼ିକର ନିଷ୍ପାଦନ ପରେ କଣ୍ଡିଶନ୍ ଯାଞ୍ଚ ହେଲା
01:05 ଏବେ ଏକ ଉଦାହରଣ ଦେଖିବା
01:07 Eclipseକୁ ଯାଆନ୍ତୁ
01:11 ଏଠାରେ, ଆମ ପାଖରେ Eclipse IDE ଏବଂ ବାକି କୋଡ୍ ପାଇଁ ଆବଶ୍ୟକ Skeleton ଅଛି
01:17 ଆମେ DoWhileDemo କ୍ରିଏଟ୍ କରି ସେଥିରେ Main Method ଆଡ୍ କରିଛେ
01:22 ଆମେ, Do While Loop ବ୍ୟବହାର କରି 1ରୁ 10 ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟା ପ୍ରିଣ୍ଟ କରିବା.
01:27 ଟାଇପ୍ କରନ୍ତୁ:
01:29 int n equal to 1.
01:32 n, Loop Variable ହେବ
01:36 ତା’ପରେ ଟାଇପ୍ କରନ୍ତୁ: do
01:40 ଖୋଲା ଓ ବନ୍ଦ ବ୍ରେସେସ୍
01:44 ବ୍ରେସେସ୍ ଭିତରେ System.out.println(n);
01:55 ଆମେ, nର ଭାଲ୍ୟୁ ପ୍ରିଣ୍ଟ କରି ତାକୁ ବୃଦ୍ଧି କରିବା. n ଇକ୍ୱାଲ୍ ଟୁ n ପ୍ଲସ୍ 1;
02:05 ଆଉ ଆମେ ଏହାକୁ ସେପର୍ଯ୍ୟନ୍ତ କରିବା,
02:08 ଯେପର୍ଯ୍ୟନ୍ତ n, 10 ସହ ସମାନ କିମ୍ୱା କମ୍ ନହୋଇଛି
02:10 ତେଣୁ, ବ୍ରାକେଟ୍ ବାହାରେ ଟାଇପ୍ କରନ୍ତୁ: while ପାରାନ୍ଥେସେସ୍ ରେ (n less than or equal to 10)
02:20 ଆଉ, ଏକ ସେମିକଲନ୍ ବ୍ୟବହାର କରି Do While ବନ୍ଦ କରନ୍ତୁ
02:25 ଚାଲନ୍ତୁ କୋଡ୍ କୁ କାର୍ଯ୍ୟରେ ଦେଖିବା.
02:28 Save କରି Run କରନ୍ତୁ
02:37 ଆମେ ଦେଖିପାରୁଛେ ଯେ, ସଂଖ୍ୟା 1ରୁ 10 ପ୍ରିଣ୍ଟ ହୋଇଗଲା
02:42 ଏବେ ଜାଣିବା, କୋଡ୍ କିପରି ନିଷ୍ପାଦିତ ହୁଏ
02:47 ପ୍ରଥମେ, ଭାଲ୍ୟୁ 1 ପ୍ରିଣ୍ଟ ହେଲା ଓ ତା’ପରେ n, 2 ହୋଇଗଲା
02:52 ଓ ତା’ପରେ କଣ୍ଡିଶନ୍ ଯାଞ୍ଚ କରାଗଲା
02:55 ଏହା True ହୋଇଥିବାରୁ, ପୁଣି 2 ପ୍ରିଣ୍ଟ ହେଲା ଓ n, 3 ହେଲା
03:00 ଆଉ ଏହିପରି 10 ସଂଖ୍ୟା ପର୍ଯ୍ୟନ୍ତ ପ୍ରିଣ୍ଟ ହେବା ଜାରି ରୁହେ ଓ nର ଭାଲ୍ୟୁ 11 ହୁଏ
03:06 ଯେତେବେଳେ n = 11 ହୁଏ, କଣ୍ଡିଶନ୍ ଅସଫଳ ହୁଏ ଓ Loop ବନ୍ଦ ହୋଇଯାଏ
03:11 ଏବେ ଚାଲନ୍ତୁ, ହ୍ରାସିତ କ୍ରମରେ 50 ରୁ 40 ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟା ପ୍ରିଣ୍ଟ କରିବା
03:17 ଆମେ 50ରୁ ଆରମ୍ଭ କରିବା.
03:19 n = 1 କୁ n = 50ରେ ବଦଳାନ୍ତୁ
03:23 ଆଉ ଯେହେତୁ ଆମେ ଏକ ବଡ଼ ସଂଖ୍ୟାରୁ ଛୋଟ ସଂଖ୍ୟାକୁ Loop କରୁଛେ, ତେଣୁ ଆମେ Loop Variableକୁ ହ୍ରାସ କରୁଛେ
03:29 n=n+1କୁ ବଦଳାଇ n=n-1 କରନ୍ତୁ
03:34 ଯେପର୍ଯ୍ୟନ୍ତ n, 40 ସହିତ ସମାନ କିମ୍ୱା ବଡ଼ ନହୋଇଛି, ଆମେ ସେପର୍ଯ୍ୟନ୍ତ Loop କରିବା
03:40 କଣ୍ଡିଶନ୍ କୁ n >= 40କୁ ବଦଳାନ୍ତୁ
03:48 ଚାଲନ୍ତୁ, ଆଉଟପୁଟ୍ କୁ ଦେଖିବା
03:50 Save କରି Run କରନ୍ତୁ
03:57 ଆମେ ଦେଖିପାରୁଛେ ଯେ, ସଂଖ୍ୟା 50ରୁ 40 ପ୍ରିଣ୍ଟ ହୋଇଗଲା
04:02 ଚାଲନ୍ତୁ ଏବେ, Do While Loop ବ୍ୟବହାର କରି ଏକ ଭିନ୍ନ ଲଜିକ୍ ଦେଖିବା
04:10 ଦିଆଯାଇଥିବା ସଂଖ୍ୟାକୁ ଆମେ ଦେଖିବା ଯେ, ଏହା ଏକ ପୂର୍ଣ୍ଣ ବର୍ଗ କି ନୁହେଁ
04:15 ପ୍ରଥମେ Main Method କାଢ଼ିଦିଅନ୍ତୁ
04:19 ତା’ପରେ ଟାଇପ୍ କରନ୍ତୁ int n = 25
04:25 nରେ ଥିବା ଭାଲ୍ୟୁ ଏକ ପୂର୍ଣ୍ଣ ବର୍ଗ କି ନୁହେଁ, ଆମେ ଦେଖିବା
04:32 ତା’ପରେ ଟାଇପ୍ କରନ୍ତୁ int n = 0
04:37 ଯଦି ତାହା ପୂର୍ଣ୍ଣ ବର୍ଗ ହୋଇଥିବ, ତେବେ ବର୍ଗ ମୂଳ ଷ୍ଟୋର୍ କରିବା ପାଇଁ ଆମେ x ବ୍ୟବହାର କରିବା
04:44 ତା’ପରେ ଟାଇପ୍ କରନ୍ତୁ do
04:46 ଖୋଲା ଓ ବନ୍ଦ ବ୍ରେସେସ୍
04:49 ବ୍ରେସେସ୍ ଭିତରେ, x ଇକ୍ୱାଲ୍ ଟୁ x ପ୍ଲସ୍ 1
04:55 ଆଉ ବ୍ରେସେସ୍ ବାହାରେ
04:58 while ପାରାନ୍ଥେସେସ୍ ରେ x into x is less than n
05:06 ଆଉ, ଏକ ସେମିକଲନ୍ ବ୍ୟବହାର କରି Do While ବନ୍ଦ କରନ୍ତୁ
05:10 ଯେପର୍ଯ୍ୟନ୍ତ x into x is less than n ଥିବ, ଆମେ xର ଭାଲ୍ୟୁକୁ ବଢ଼ାଇ ଚାଲିଥିବା
05:16 ଯେତେବେଳେ Loop, ଏହି କଣ୍ଡିଶନ୍ ର ରିଭର୍ସକୁ ବନ୍ଦ କରିବ, ଏହା True ହେବ
05:22 ଯାହାର ଅର୍ଥ, ଅବା x into x, n ସହିତ ସମାନ ହେବ
05:26 କିମ୍ୱା nଠାରୁ ବଡ଼ ହେବ
05:28 ଯଦି x into x, n ସହ ସମାନ ହୁଏ, ସଂଖ୍ୟାଟି ପୂର୍ଣ୍ଣ ବର୍ଗ ହେବ
05:32 ଯଦି ତାହା n ସହ ସମାନ ନହୁଏ, ତେବେ ସଂଖ୍ୟାଟି ପୂର୍ଣ୍ଣ ବର୍ଗ ହେବନାହିଁ
05:37 ଶେଷରେ, ଆମେ କଣ୍ଡିଶନ୍ କୁ ପ୍ରିଣ୍ଟ କରିବା
05:47 System.out.println (x * x == n);
05:55 ଚାଲନ୍ତୁ କୋଡ୍ କୁ କାର୍ଯ୍ୟରେ ଦେଖିବା.
05:59 Save କରି Run କରନ୍ତୁ. ଆମେ ଦେଖିପାରୁଛେ ଯେ, ଆଉଟପୁଟ୍ True ଅଟେ
06:07 ଚାଲନ୍ତୁ, ଅନ୍ୟ ପୂର୍ଣ୍ଣ ବର୍ଗ ସହିତ ଦେଖିବା
06:10 n = 25 କୁ n = 49ରେ ବଦଳାନ୍ତୁ
06:15 Save କରି Run କରନ୍ତୁ
06:20 ଆମେ ପୁଣିଥରେ True ପାଇଲେ
06:23 ଏବେ, ଏପରି ଏକ ସଂଖ୍ୟା ଦେଖିବା, ଯାହା ଏକ ପୂର୍ଣ୍ଣ ବର୍ଗ ନୁହେଁ
06:26 49କୁ ବଦଳାଇ 23 କରନ୍ତୁ. Save କରି Run କରନ୍ତୁ
06:34 ଓ ଆମକୁ ଆଶାନୁରୂପ False ମିଳିଲା
06:37 ଚାଲନ୍ତୁ ଏବେ ଦେଖିବା, nର ଭାଲ୍ୟୁ 0 ହୋଇଥିଲେ କ’ଣ ହେଉଛି
06:42 n = 23 କୁ n = 0ରେ ବଦଳାନ୍ତୁ. ଯେହେତୁ 0 ଏକ ପ୍ରାକୃତିକ ସଂଖ୍ୟା ନୁହେଁ, ଆମେ ନିଶ୍ଚିତ ଏକ False ପାଇବା
06:52 ଏବେ କୋଡ୍ ରନ୍ କରନ୍ତୁ
06:54 Save କରି Run କରନ୍ତୁ
07:00 ଦେଖନ୍ତୁ, ଆମକୁ ଆଶାନୁରୂପ False ପ୍ରାପ୍ତ ହେଲା
07:05 ଏହାର କାରଣ ହେଉଛି, କଣ୍ଡିଶନ୍ ର ପୂର୍ବରୁ ହିଁ
07:08 x into x, n ଠାରୁ କମ୍ ବୋଲି ଯାଞ୍ଚ କରାଯାଇସାରିଛି, xର ଭାଲ୍ୟୁ ବୃଦ୍ଧି କରାଯାଇସାରିଛି ଓ ତାହା 1 ହୋଇସାରିଛି
07:16 Loop Condition ବିଫଳ ହେଲା ଓ Loop ଚାଲିଲା ନାହିଁ
07:20 ଏହିଭଳି, Do While Loop ବ୍ୟବହାର କରି ଆମେ ସୁନିଶ୍ଚିତ କରିପାରିବା ଯେ, 0କୁ ଏକ ପୂର୍ଣ୍ଣ ବର୍ଗ ଭାବରେ ବିଚାର କରାଯାଇପାରିବ ନାହିଁ
07:26 ଏହିପ୍ରକାରେ, ଅନେକ ସମସ୍ୟାର ସମାଧାନ ପାଇଁ Do While Loopର ବ୍ୟବହାର କରାଯାଏ
07:31 ବିଶେଷକରି, ଯେତେବେଳେ Loop ଅତିକମ୍ ରେ ଥରେ ନିଶ୍ଚିତ ଭାବେ ଚାଲିବା ଦରକାର
07:37 ଏହା ଆମକୁ ଏହି ଟ୍ୟୁଟୋରିଆଲର ସମାପ୍ତିକୁ ଆଣେ
07:40 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେ ଆମେ ନିମ୍ନଲିଖିତ ଶିଖିଲେ,
07:42 Do While Loop ଓ ତା’ର ବ୍ୟବହାର
07:46 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଏକ ଆସାଇନମେଣ୍ଟ. ନିମ୍ନ ସମସ୍ୟାର ସମାଧାନ କରନ୍ତୁ
07:50 ଏକ ପ୍ରଦତ୍ତ Binary ସଂଖ୍ୟାରୁ ତାହାର ଦଶମିକ ସମକକ୍ଷ ବାହାର କରନ୍ତୁ. ଉଦାହରଣସ୍ୱରୂପ: 11010 => 26
07:56 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ବିଷୟରେ ଅଧିକ ଜାଣିବା ପାଇଁ ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ ଭିଡିଓକୁ ଦେଖନ୍ତୁ.
08:01 ଏହା ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟକୁ ସାରାଂଶିତ କରେ. ଯଦି ଆପଣଙ୍କର ଭଲ ବ୍ୟାଣ୍ଡୱିଡଥ୍ ନାହିଁ, ଏହାକୁ ଡାଉନଲୋଡ୍ କରିଦେଖିପାରିବେ
08:06 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଟିମ୍
08:10 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ସ ବ୍ୟବହାର କରି କର୍ମଶାଳାମାନ ଚଲାନ୍ତି ତଥା ଅନଲାଇନ୍ ଟେଷ୍ଟ ପାସ୍ କରୁଥିବା ବ୍ୟକ୍ତିମାନଙ୍କୁ ପ୍ରମାଣପତ୍ର ଦିଅନ୍ତି
08:16 ଅଧିକ ବିବରଣୀ ପାଇଁ ଦୟାକରି, କଣ୍ଟାକ୍ଟ ଆଟ୍ ସ୍ପୋକନ୍ ହାଇଫେନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ଡଟ୍ ଓଆରଜି (contact@spoken-tutorial.org)କୁ ଲେଖନ୍ତୁ
08:22 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ ପ୍ରୋଜେକ୍ଟ, ଟକ୍ ଟୁ ଏ ଟିଚର୍ ପ୍ରୋଜେକ୍ଟର ଏକ ଅଂଶ ଏହା ଭାରତ ସରକାରଙ୍କ MHRDର ICT ମାଧ୍ୟମରେ ରାଷ୍ଟ୍ରୀୟ ସାକ୍ଷରତା ମିଶନ୍ ଦ୍ୱାରା ସମର୍ଥିତ
08:32 ଏହି ମିଶନ୍ ଉପରେ ଅଧିକ ବିବରଣୀ ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ:
08:36 ଆଇଆଇଟି ବମ୍ୱେ ତରଫରୁ ମୁଁ ପ୍ରଦୀପ ଚନ୍ଦ୍ର ମହାପାତ୍ର ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି. ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ ଧନ୍ୟବାଦ

Contributors and Content Editors

PoojaMoolya, Pradeep