Java/C2/do-while/Oriya

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