Java/C2/while-loop/Oriya

From Script | Spoken-Tutorial
Jump to: navigation, search
Time Narration
00:02 Javaରେ While Loop ଉପରେ ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ କୁ ସ୍ୱାଗତ
00:06 ଏହି ଟ୍ୟୁଟୋରିଆଲରେ ଆମେ ଶିଖିବା:While Loop ବିଷୟରେ,ତାକୁ କିପରି ବ୍ୟବହାର କରିବେ
00:12 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଆମେ ବ୍ୟବହାର କରୁଛୁ Ubuntu 11.10, JDK 1.6 ଓ Eclipse 3.7
00:21 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଆପଣଙ୍କର, Javaରେ Relational Operators ଉପରେ ଜ୍ଞାନ ଥିବା ଦରକାର
00:26 ଯଦି ନୁହେଁ, ତେବେ ସମ୍ପର୍କିତ ଟ୍ୟୁଟୋରିଆଲ୍ସ ପାଇଁ ଦୟାକରି ଆମ ୱେବସାଇଟ୍ ଦେଖନ୍ତୁ http://spoken-tutorial.org
00:36 ଏହା ହେଉଛି ଗୋଟିଏ While Loopର Structure
00:39 ଏହାର ଦୁଇଟି ଭାଗ ଅଛି
00:41 ଗୋଟିଏ ହେଉଛି Loop Running Condition ଓ ଆଉ ଗୋଟିଏ ହେଉଛି Loop Variable
00:48 ଚାଲନ୍ତୁ, ଏବେ ଏକ ଉଦାହରଣ ଦେଖିବା. Eclipseକୁ ଯାଆନ୍ତୁ
00:55 ଏଠାରେ, ଆମ ପାଖରେ Eclipse IDE ଏବଂ ବାକି କୋଡ୍ ପାଇଁ ଆବଶ୍ୟକ Skeleton ଅଛି
01:00 ମୁଁ ଏକ WhileDemo Class କ୍ରିଏଟ୍ କରି ସେଥିରେ Main Method ଆଡ୍ କରିଛି
01:05 ଆମେ, While Loop ବ୍ୟବହାର କରି 1ରୁ 10 ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟା ପ୍ରିଣ୍ଟ କରିବା. ଟାଇପ୍ କରନ୍ତୁ: int n = 1;
01:15 ଏହି ଭେରିଏବଲ୍ n, ଆମର Loop Variable ହେବ
01:21 ଟାଇପ୍ କରନ୍ତୁ: while ପାରେନ୍ଥେସିସ୍ ରେ n less than or equal to 10 ଖୋଲା ଓ ବନ୍ଦ ବ୍ରେସେସ୍
01:33 ଏହି କଣ୍ଡିଶନ୍ କୁ Loop Running Condition କୁହାଯାଏ
01:37 ଏହାର ଅର୍ଥ, ଯେପର୍ଯ୍ୟନ୍ତ କଣ୍ଡିଶନ୍ True ଥିବ, ସେପର୍ଯ୍ୟନ୍ତ Loop Run କରିବ
01:42 ଆମ ମାମଲାରେ, ଯେପର୍ଯ୍ୟନ୍ତ nର ଭାଲ୍ୟୁ, 10ଠାରୁ କମ୍ କିମ୍ୱା ସମାନ ଥିବ, ସେପର୍ଯ୍ୟନ୍ତ ଏହା ରନ୍ କରିବ
01:47 ଆଉ ଏହା କେବଳ ସେତେବେଳେ ବନ୍ଦ ହେବ, ଯେତେବେଳେ nର ଭାଲ୍ୟୁ, 10ଠାରୁ ବଡ଼ ହୋଇଯିବ
01:53 Loop ଭିତରେ, ଆମେ nର ଭାଲ୍ୟୁ ପ୍ରିଣ୍ଟ କରିବା
01:58 System.out.println(n); ଓ ତା’ପରେ ଏହାକୁ n = n + 1;କୁ ବଢ଼ାନ୍ତୁ
02:12 ଏହିଭଳି, ପ୍ରଥମ 1 ପ୍ରିଣ୍ଟ ହେଲା ଓ ତା’ପରେ nର ଭାଲ୍ୟୁ 2 ହେଲା
02:18 ତା’ପରେ Loop Condition ଯାଞ୍ଚ କରାଗଲା
02:21 ଏହା True ହୋଇଥିବାରୁ, 2 ପ୍ରିଣ୍ଟ ହେଲା ଓ n, 3 ହେଲା
02:25 ଓ ଏହିପ୍ରକାରେ, 10 ପ୍ରିଣ୍ଟ ହେବା ପର୍ଯ୍ୟନ୍ତ Loop ଆଗକୁ ବଢ଼ିବ. ତା’ପରେ n, 11 ହୋଇଯିବ ଓ କଣ୍ଡିଶନ୍ True ହୋଇ ରହିବ ନାହିଁ ଓ Loop ବନ୍ଦ ହୋଇଯିବ
02:37 ଚାଲନ୍ତୁ, କୋଡ୍ କୁ କାର୍ଯ୍ୟରେ ଦେଖିବା
02:39 Save କରି Run କରନ୍ତୁ
02:47 ଆମେ ଦେଖିପାରୁଛେ ଯେ, ସଂଖ୍ୟା 1ରୁ 10 ପ୍ରିଣ୍ଟ ହୋଇଗଲା
02:52 ଏବେ ଆମେ, 50ରୁ 40 ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟା ପ୍ରିଣ୍ଟ କରିବା
02:58 ଆମେ 50ରୁ ଆରମ୍ଭ କରିବା. n = 1 କୁ n = 50ରେ ବଦଳାନ୍ତୁ
03:03 ଓ ଆମେ 40 ପର୍ଯ୍ୟନ୍ତ ଯିବା
03:05 ଅନ୍ୟ ଶବ୍ଦରେ, ଯେପର୍ଯ୍ୟନ୍ତ n, 40 ସହିତ ସମାନ କିମ୍ୱା ବଡ଼ ନହୋଇଛି. ତେଣୁ, କଣ୍ଡିଶନ୍ କୁ ବଦଳାଇ n greater than or equal to 40 କରନ୍ତୁ
03:16 ଆଉ ଯେହେତୁ ଆମେ ଏକ ବଡ଼ ସଂଖ୍ୟାରୁ ଛୋଟ ସଂଖ୍ୟାକୁ Loop କରୁଛେ, ତେଣୁ ଆମେ Loop Variableକୁ ହ୍ରାସ କରୁଛେ
03:22 n=n+1କୁ ବଦଳାଇ n=n-1 କରନ୍ତୁ
03:27 Save କରି Run କରନ୍ତୁ. ଆମେ ଦେଖିପାରୁଛେ ଯେ, ସଂଖ୍ୟା 50ରୁ 40 ପ୍ରିଣ୍ଟ ହୋଇଗଲା
03:42 ଏବେ ଆମେ, ପ୍ରଥମ 7ର 10 ମଲ୍ଟିପଲ୍ ପ୍ରିଣ୍ଟ କରିବା
03:48 ତାହା କରିବା ପାଇଁ ଆମେ, 7ରୁ ଆରମ୍ଭ କରିବା
03:50 ତେଣୁ, n = 50କୁ ବଦଳାଇ n = 7 କରନ୍ତୁ ଓ ତା’ପରେ ଆମେ 70ରେ ଶେଷ କରିବା
03:57 କଣ୍ଡିଶନ୍ କୁ ବଦଳାଇ n less than equal to 70 କରନ୍ତୁ
04:03 ଏହିଭଳି, ଆମେ ସୁନିଶ୍ଚିତ କରିବା ଯେ, Loop, 70ଠାରେ ବନ୍ଦ ହେବ
04:07 ମଲ୍ଟିପଲ୍ସ ପ୍ରାପ୍ତ କରିବା ପାଇଁ Loop Variableକୁ 7 ଦ୍ୱାରା ବୃଦ୍ଧି କରିବା
04:12 n=n-1କୁ ବଦଳାଇ n=n+7 କରନ୍ତୁ
04:18 ଏହିପରି, ପ୍ରଥମ 7 ପ୍ରିଣ୍ଟ ହେଲା ଓ ତା’ପରେ n, 14 ହେଲା ଓ 14 ପ୍ରିଣ୍ଟ ହେଲା ତଥା 70 ପର୍ଯ୍ୟନ୍ତ ଗଲା. Save କରି Run କରନ୍ତୁ
04:33 ଆମେ ଦେଖିପାରୁଛେ ଯେ, ପ୍ରଥମ 7ର 10 ମଲ୍ଟିପଲ୍ସ ପ୍ରିଣ୍ଟ ହୋଇଗଲା
04:43 ଗୋଟିଏ ସଂଖ୍ୟାର ଯୋଗ ପ୍ରାପ୍ତ କରିବାକୁ While Loopର ମଧ୍ୟ ବ୍ୟବହାର କରିପାରିବା
04:47 ଏହା କିପରି କରାଯାଏ, ଚାଲନ୍ତୁ ଦେଖିବା
04:49 ପ୍ରଥମେ Main Method କାଢ଼ିଦିଅନ୍ତୁ
04:54 int n equal to 13876. ଏହା ହେଉଛି ସଂଖ୍ୟା
05:02 ତା’ପରେ int dSum equal to 0. ଅଙ୍କ ପାଇଁ ସଂକେତ ହେଉଛି ଭେରିଏବଲ୍ dSum, ଯାହା ଅଙ୍କଗୁଡ଼ିକର ଯୋଗକୁ ରଖିବ
05:18 ଟାଇପ୍ କରନ୍ତୁ: while n ଗ୍ରେଟର୍ ଦ୍ୟାନ୍ 0 ଖୋଲା ବନ୍ଦ ପାରେନ୍ଥେସେସ୍
05:27 ଏହି କଣ୍ଡିଶନ୍ ବ୍ୟବହାର କରିବାର କାରଣ କିଛି ସମୟ ମଧ୍ୟରେ ସ୍ପଷ୍ଟ ହେବ
05:32 ଅଙ୍କର ଯୋଗ ପ୍ରାପ୍ତ କରିବା ପାଇଁ ଆମକୁ ପ୍ରଥମେ ଅଙ୍କ ପ୍ରାପ୍ତ କରିବାକୁ ହେବ
05:36 ତାହା କରିବା ପାଇଁ ଆମେ, Modulo Operator ବ୍ୟବହାର କରୁ
05:40 ଟାଇପ୍ କରନ୍ତୁ: dSum = dSum + (n % 10) ତେବେ, ଆମେ ୟୁନିଟ୍ ର ଅଙ୍କ ପାଇଲେ ଓ ତାକୁ dsum ସହ ଯୋଡ଼ିଦେଲେ
05:52 ତାହାପରେ ଆମେ, 10 ଦ୍ୱାରା ବିଭାଜିତ କରି ଅଙ୍କକୁ କାଢ଼ିଦେବା. n = n / 10
06:08 ତେଣୁ, ଯେତେବେଳେ Loop ପ୍ରଥମଥର ପାଇଁ Run କରେ, dSum 6 ହେବ ଓ n, 1387 ହୋଇଯିବ
06:15 ଆଉ ଯେତେବେଳେ Loop ଦ୍ୱିତୀୟଥର ପାଇଁ Run କରେ, dSum 7 ଓ 6 ହେବ, ଯାହା ହେଉଛି 13 ଓ n, 138 ହୋଇଯିବ
06:22 ଓ Loop ଆଗକୁ ବଢ଼ିବା ସହିତ ଅଙ୍କଗୁଡ଼ିକ nରୁ କାଢ଼ି ହୋଇଯିବ ଓ ଶେଷରେ
06:28 n ଶୂନ୍ ହୋଇଯିବ. ତାହାପରେ କଣ୍ଡିଶନ୍ n greater than 0, False ହୋଇଯିବ ଓ Loop ବନ୍ଦ ହୋଇଯିବ
06:36 ଏବେ ଏକ ପ୍ରିଣ୍ଟ ଷ୍ଟେଟମେଣ୍ଟ ଆଡ୍ କରିବା
06:42 System.out.println(dSum)
06:51 ଚାଲନ୍ତୁ କୋଡ୍ କୁ କାର୍ଯ୍ୟରେ ଦେଖିବା. Save କରି Run କରନ୍ତୁ
06:59 ଆମେ ଦେଖିପାରୁଛେ ଯେ, ଅଙ୍କଗୁଡ଼ିକର ଯୋଗ, ଯାହା ହେଉଛି 25, ପ୍ରିଣ୍ଟ ହୋଇଗଲା
07:06 ଏହିଭଳି, While Loopକୁ ବ୍ୟବହାର କରାଯାଇପାରେ, ଯାହା ହେଉଛି ପ୍ରୋଗ୍ରାମିଙ୍ଗ୍ ରେ ସବୁଠାରୁ ମୌଳିକ Constructs
07:16 ଏହା ଆମକୁ ଏହି ଟ୍ୟୁଟୋରିଆଲର ସମାପ୍ତିକୁ ଆଣେ
07:20 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ରେ ଆମେ ନିମ୍ନ ବିଷୟରେ ଶିଖିଲେ: While Loop ବିଷୟରେ, ତାକୁ କିପରି ବ୍ୟବହାର କରିବେ
07:26 ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ପାଇଁ ଏକ ଆସାଇନମେଣ୍ଟ. ନିମ୍ନ ସମସ୍ୟାର ସମାଧାନ କରନ୍ତୁ
07:29 ପ୍ରଦତ୍ତ ସଂଖ୍ୟାକୁ, While Loop ବ୍ୟବହାର କରି ପଛୁଆ ଗଣନା କରନ୍ତୁ. ଉଦାହରଣସ୍ୱରୂପ: 19435 => 53491
07:37 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ବିଷୟରେ ଅଧିକ ଜାଣିବା ପାଇଁ ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ ଭିଡିଓକୁ ଦେଖନ୍ତୁ. ଏହା ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟକୁ ସାରାଂଶିତ କରେ.
07:45 ଯଦି ଆପଣଙ୍କର ଭଲ ବ୍ୟାଣ୍ଡୱିଡଥ୍ ନାହିଁ, ଏହାକୁ ଡାଉନଲୋଡ୍ କରିଦେଖିପାରିବେ
07:50 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଟିମ୍: ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ସ ବ୍ୟବହାର କରି କର୍ମଶାଳାମାନ ଚଲାନ୍ତି, ଅନଲାଇନ୍ ଟେଷ୍ଟ ପାସ୍ କରୁଥିବା ବ୍ୟକ୍ତିମାନଙ୍କୁ ପ୍ରମାଣପତ୍ର ଦିଅନ୍ତି.
07:57 ଅଧିକ ବିବରଣୀ ପାଇଁ ଦୟାକରି, କଣ୍ଟାକ୍ଟ ଆଟ୍ ସ୍ପୋକନ୍ ହାଇଫେନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ଡଟ୍ ଓଆରଜି (contact@spoken-tutorial.org)କୁ ଲେଖନ୍ତୁ
08:03 ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ ପ୍ରୋଜେକ୍ଟ, ଟକ୍ ଟୁ ଏ ଟିଚର୍ ପ୍ରୋଜେକ୍ଟର ଏକ ଅଂଶ
08:07 ଏହା ଭାରତ ସରକାରଙ୍କ MHRDର ICT ମାଧ୍ୟମରେ ରାଷ୍ଟ୍ରୀୟ ସାକ୍ଷରତା ମିଶନ୍ ଦ୍ୱାରା ସମର୍ଥିତ
08:12 ଏହି ମିଶନ୍ ଉପରେ ଅଧିକ ବିବରଣୀ ନିମ୍ନ ଲିଙ୍କରେ ଉପଲବ୍ଧ:
08:17 ଆଇଆଇଟି ବମ୍ୱେ ତରଫରୁ ମୁଁ ପ୍ରଦୀପ ଚନ୍ଦ୍ର ମହାପାତ୍ର ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି. ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ ଧନ୍ୟବାଦ

Contributors and Content Editors

PoojaMoolya, Pradeep