Java/C2/while-loop/Oriya
From Script | Spoken-Tutorial
| 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 | ଆଇଆଇଟି ବମ୍ୱେ ତରଫରୁ ମୁଁ ପ୍ରଦୀପ ଚନ୍ଦ୍ର ମହାପାତ୍ର ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି. ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ ଧନ୍ୟବାଦ |
