Java/C2/while-loop/Kannada

Time	Narration
00:02	ಜಾವ while loop ನ ಕುರಿತು ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಗೆ ಸ್ವಾಗತ.
00:06	ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು, while loop ನ ಕುರಿತು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಉಪಯೋಗಿಸುವುದು ಎನ್ನುವುದರ ಕುರಿತು ಕಲಿಯುತ್ತೇವೆ.
00:12	ಈ ಟ್ಯುಟೋರಿಯಲ್ ಗಾಗಿ Ubuntu 11.10, JDK 1.6 ಮತ್ತು Eclipse 3.7 ಗಳನ್ನು ಉಪಯೋಗಿಸಿದ್ದೇನೆ.
00:21	ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಜಾವಾದಲ್ಲಿ ರಿಲೇಶನಲ್ ಆಪರೇಟರ್ ಗಳ ಕುರಿತು ಜ್ಞಾನವನ್ನು ಹೊಂದಿರಬೇಕು.
00:26	ತಿಳಿದಿರದಿದ್ದಲ್ಲಿ ನಮ್ಮ ಈ ವೆಬ್ ಸೈಟ್ ಅನ್ನು ನೋಡಿ. [1]
00:36	ಇಲ್ಲಿ while loop ನ ವಿನ್ಯಾಸವಿದೆ.
00:39	ಇಲ್ಲಿ ಎರಡು ಭಾಗಗಳಿವೆ.
00:41	ಒಂದು loop running condition ಮತ್ತು ಎರಡನೆಯದು loop variable
00:48	ಈಗ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. Eclipse ಗೆ ಹೋಗೋಣ.
00:55	ಇಲ್ಲಿ eclipse IDE ಮತ್ತು ಉಳಿದ ಕೋಡ್ ಗಳಿಗೆ ಬೇಕಾದ ವಿನ್ಯಾಸವಿದೆ.
01:00	ನಾನು class WhileDemo ಅನ್ನು ರಚಿಸಿದ್ದೇನೆ ಮತ್ತು ಅದಕ್ಕೆ main method ಅನ್ನು ಸೇರಿಸಿದ್ದೇನೆ.
01:05	ಇಲ್ಲಿ ನಾವು 1 ರಿಂದ 10 ವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು while loop ಅನ್ನು ಉಪಯೋಗಿಸಿ ಪ್ರಿಂಟ್ ಮಾಡಬಹುದು. int n = 1; ಎಂದು ಟೈಪ್ ಮಾಡಿ.
01:15	ಈ ವೇರಿಯೇಬಲ್ 'n'ಅನ್ನು ನಮ್ಮ loop variable ಅನ್ನಾಗಿ ಮಾಡಿಕೊಳ್ಳೋಣ.
01:21	while ಎಂದು ಟೈಪ್ ಮಾಡಿ ಬ್ರ್ಯಾಕೆಟ್ ನಲ್ಲಿ n ಚಿಕ್ಕದು ಅಥವಾ ಸಮ 10 ಎಂದು ಟೈಪ್ ಮಾಡಿ, ಬ್ರ್ಯಾಕೆಟ್ ಅನ್ನು ಓಪನ್ ಮಾಡಿ ಮುಚ್ಚಿರಿ.
01:33	ಈ ಕಂಡಿಷನ್ ಅನ್ನು loop running condition ಎಂದು ಕರೆಯುತ್ತಾರೆ.
01:37	ಅಂದರೆ ಈ ಕಂಡಿಷನ್ ಟ್ರ್ಯೂ ಆಗಿರುವವರೆಗೂ ಲೂಪ್ ರನ್ ಆಗುತ್ತಿರುತ್ತದೆ.
01:42	ಈ ಉದಾಹರಣೆಯಲ್ಲಿ 'n' ಹತ್ತಕ್ಕಿಂತ ಚಿಕ್ಕದು ಅಥವಾ ಸಮವಾಗಿರುವವರೆಗೂ ಲೂಪ್ ರನ್ ಆಗುತ್ತದೆ.
01:47	ಮತ್ತು ಇದು 'n' ನ ಬೆಲೆಯು ಹತ್ತಕ್ಕಿಂತ ಹೆಚ್ಚಾದಾಗ ಲೂಪ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.
01:53	loop ನ ಒಳಗೆ ನಾವು 'n' ನ ಬೆಲೆಯನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತೇವೆ.
01:58	System.out.println(n); ಮತ್ತು ನಂತರ ನಾವು ಇದನ್ನು ಹೆಚ್ಚಿಸುತ್ತೇವೆ ಅಂದರೆ n = n + 1;
02:12	ಈ ರೀತಿಯಲ್ಲಿ ಮೊದಲು 1 ಪ್ರಿಂಟ್ ಆಗುತ್ತದೆ ಮತ್ತು ನಂತರ 'n' ನ ಬೆಲೆಯು 2 ಆಗುತ್ತದೆ.
02:18	ನಂತರ loop condition ಕಂಡಿಷನ್ ಪರೀಕ್ಷಿಸಲ್ಪಡುತ್ತದೆ.
02:21	ಅದು ಟ್ರ್ಯೂ ಆಗಿರುವುದರಿಂದ 2 ಪ್ರಿಂಟ್ ಆಗುತ್ತದೆ ಮತ್ತು n ನ ಬೆಲೆಯು 3 ಆಗುತ್ತದೆ.
02:25	ಮತ್ತು ಇದೇ ರೀತಿ ಮುಂದುವರಿಯುತ್ತದೆ. ಲೂಪ್ 10 ಪ್ರಿಂಟ್ ಆಗುವ ತನಕ ಮುಂದುವರಿಯುತ್ತದೆ. ಅದರ ನಂತರ 'n' ನ ಬೆಲೆಯು 11 ಆಗುತ್ತದೆ ಮತ್ತು ಕಂಡಿಷನ್ ಟ್ರ್ಯೂ ಆಗಿಲ್ಲದೇ ಇರುವುದರಿಂದ 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 ದೊಡ್ಡದು ಅಥವಾ ಸಮ 40 ಎಂದು ಬದಲಿಸಿ.
03:16	ನಾವು ಲೂಪ್ ಅನ್ನು ದೊಡ್ಡ ಸಂಖ್ಯೆಯಿಂದ ಚಿಕ್ಕ ಸಂಖ್ಯೆಗೆ ಇಳಿಸುವುದರಿಂದ, ಲೂಪ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತಾ ಬರಬೇಕು.
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 ಚಿಕ್ಕದು ಅಥವ ಸಮ 70 ಎಂದು ಬದಲಿಸಿ.
04:03	ಲೂಪ್ 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 ರ ಮೊದಲ ಹತ್ತು ಅಪವರ್ತನಗಳು ಪ್ರಿಂಟ್ ಆಗುತ್ತದೆ.
04:43	ನಾವು while loop ಅನ್ನು ಒಂದು ಸಂಖ್ಯೆಯ ಅಂಕೆಗಳ ಮೊತ್ತವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹ ಉಪಯೋಗಿಸಬಹುದು.
04:47	ಅದನ್ನು ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ನೋಡೋಣ.
04:49	ಮೊದಲು main method ಅನ್ನು ಖಾಲಿ ಮಾಡೋಣ.
04:54	int n ಸಮ 13876;. ಇದು ಸಂಖ್ಯೆ.
05:02	ನಂತರ int dSum ಸಮ 0. dsum ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸಂಖ್ಯೆಯ ಅಂಕೆಗಳ ಮೊತ್ತವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಲು ಉಪಯೋಗಿಸುತ್ತೇವೆ.
05:18	while n ದೊಡ್ಡದು 0 ಎಂದು ಟೈಪ್ ಮಾಡಿ, ಬ್ರ್ಯಾಕೆಟ್ ಅನ್ನು ತೆರೆಯಿರಿ.
05:27	ಈ ಕಂಡಿಶನ್ ಉಪಯೋಗಿಸಲು ಕಾರಣ ಸಧ್ಯದಲ್ಲೇ ತಿಳಿಯುತ್ತದೆ.
05:32	ಅಂಕೆಗಳ ಮೊತ್ತವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮೊದಲು ನಾವು ಅಂಕೆಗಳನ್ನು ಪಡೆಯಬೇಕು.
05:36	ಅದನ್ನು ಮಾಡಲು ನಾವು modulo operator ಅನ್ನು ಉಪಯೋಗಿಸುತ್ತೇವೆ.
05:40	dSum = dSum + (n % 10) ಎಂದು ಟೈಪ್ ಮಾಡಿ, ಇದರಿಂದ ಬಿಡಿ ಸ್ಥಾನದ ಅಂಕೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ನಾವು ಅದನ್ನು dsum ಗೆ ಸೇರಿಸುತ್ತೇವೆ.
05:52	ಅದರ ನಂತರ ನಾವು ಹತ್ತರಿಂದ ಭಾಗಿಸಿ ಆ ಅಂಕೆಯನ್ನು ಸಂಖ್ಯೆಯಿಂದ ತೆಗೆದು ಹಾಕುತ್ತೇವೆ. n = n / 10
06:08	ಹಾಗಾಗಿ ಮೊದಲ ಬಾರಿಗೆ ಲೂಪ್ ರನ್ ಆದಾಗ dSum ನ ಬೆಲೆಯು 6 ಆಗುತ್ತದೆ ಮತ್ತು 'n' ನ ಬೆಲೆಯು 1387 ಆಗುತ್ತದೆ.
06:15	ಮತ್ತು ಲೂಪ್ ಎರಡನೇ ಬಾರಿ ರನ್ ಆದಾಗ dSum ನ ಬೆಲೆಯು 7 ಮತ್ತು 6 ರ ಮೊತ್ತ ಅಂದರೆ 13 ಆಗುತ್ತದೆ ಮತ್ತು 'n' ನ ಬೆಲೆಯು 138 ಆಗುತ್ತದೆ.
06:22	ಮತ್ತು ಲೂಪ್ ಮುಂದುವರಿದಂತೆ ಅಂಕೆಗಳು n ನಿಂದ ಹೊರತೆಗೆಯಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ
06:28	n ನ ಬೆಲೆಯು ಸೊನ್ನೆ ಆಗುತ್ತದೆ. ಅದಾದ ನಂತರ 'n ದೊಡ್ಡದು 0' ಎಂಬ ಕಂಡಿಷನ್ ಫಾಲ್ಸ್ ಆಗುತ್ತದೆ ಮತ್ತು ಲೂಪ್ ಅಲ್ಲಿಗೆ ನಿಲ್ಲುತ್ತದೆ.
06:36	ಈಗ ನಾವು ಪ್ರಿಂಟ್ ಸ್ಟೇಟ್ ಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸೋಣ.
06:42	System.out.println(dSum)
06:51	ಈಗ ಈ ಕೋಡ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ನೋಡೋಣ. Save ಮಾಡಿ run ಮಾಡಿ.
06:59	ನಾವು ಇಲ್ಲಿ ಅಂಕೆಗಳ ಮೊತ್ತ 25 ಎಂದು ಪ್ರಿಂಟ್ ಆಗುವುದನ್ನು ನೋಡಬಹುದು.
07:06	ಈ ರೀತಿಯಲ್ಲಿ ಪ್ರೊಗ್ರಾಮ್ ಗಳಲ್ಲಿ ಬಹು ಮುಖ್ಯವಾದ constructs ಆದ while loop ಅನ್ನು ಉಪಯೋಗಿಸುತ್ತೇವೆ.
07:16	ನಾವು ಟ್ಯುಟೋರಿಯಲ್ ನ ಕೊನೆಯ ಹಂತವನ್ನು ತಲುಪಿದ್ದೇವೆ.
07:20	ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಾವು, while loop ನ ಕುರಿತು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಉಪಯೋಗಿಸುವುದು ಎನ್ನುವುದರ ಕುರಿತು ಕಲಿತಿದ್ದೇವೆ.
07:26	ಸ್ವಂತ ಅಭ್ಯಾಸಕ್ಕಾಗಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿ.
07:29	ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಕೊಟ್ಟಿದ್ದು ವೈಲ್ ಲೂಪ್ ಅನ್ನು ಉಪಯೋಗಿಸಿ ಅದರ ತಿರುಗಿಸಿದ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ. ಉದಾಹರಣೆಗೆ: 19435 => 53491
07:37	ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಕಲ್ಪದ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿಷಯವನ್ನು ತಿಳಿಯಲು ಈ ಕೆಳಗಿನ ಲಿಂಕ್ ನಲ್ಲಿರುವ ವಿಡಿಯೋಗಳನ್ನು ನೋಡಿ.ಇದು ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಕಲ್ಪದ ಕುರಿತು ತಿಳಿಸಿಕೊಡುತ್ತದೆ.
07:45	ನೀವು ಒಳ್ಳೆಯ ಬ್ಯಾಂಡ್ ವಿಡ್ತ್ ಹೊಂದಿಲ್ಲದಿದ್ದಲ್ಲಿ ಡೌನ್ ಲೋಡ್ ಮಾಡಿ ನೋಡಿಕೊಳ್ಳಬಹುದು.
07:50	ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ತಂಡವು :ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಗಳನ್ನು ಉಪಯೋಗಿಸಿ ಕಾರ್ಯಾಗಾರಗಳನ್ನು ಏರ್ಪಡಿಸುತ್ತದೆ. ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣರಾದವರಿಗೆ ಪ್ರಮಾಣಪತ್ರವನ್ನು ಕೊಡುತ್ತದೆ.
07:57	ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗೆ contact ಎಟ್ spoken ಹೈಫನ್ tutorial ಡಾಟ್ org. ಗೆ ಬರೆಯಿರಿ.
08:03	ಸ್ಪೋಕನ್ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರಕಲ್ಪವು ಟಾಕ್ ಟು ಎ ಟೀಚರ್ ನ ಒಂದು ಭಾಗವಾಗಿದೆ.
08:07	ಇದು ನ್ಯಾಷನಲ್ ಮಿಶನ್ ಆನ್ ಎಜುಕೇಶನ್ , ICT, MHRD,ಭಾರತ ಸರ್ಕಾರದಿಂದ ಪ್ರಮಾಣಿತವಾಗಿದೆ
08:12	ಇದರ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳು spoken ಹೈಫನ್ tutorial ಡಾಟ್ org ಸ್ಲ್ಯಾಶ್ NMEICT ಹೈಫನ್Intro ನಲ್ಲಿ ದೊರೆಯುತ್ತದೆ.
08:17	ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು TalentSprint ನಿಂದ ಪಡೆದುಕೊಳ್ಳಲಾಗಿದೆ. ಅನುವಾದ ಮತ್ತು ಧ್ವನಿ ವಿದ್ವಾನ್ ನವೀನ್ ಭಟ್ ಉಪ್ಪಿನ ಪಟ್ಟಣ. ಧನ್ಯವಾದಗಳು

Contributors and Content Editors

NaveenBhat, Sandhya.np14