Java/C2/while-loop/Kannada

From Script | Spoken-Tutorial
Jump to: navigation, search
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