1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] ವಿಭಾಗ ಸಮಸ್ಯೆ 2 ಹೊಂದಿಸಿ: ಹ್ಯಾಕರ್ ಆವೃತ್ತಿ

2
00:00:02,670 --> 00:00:04,910
ರಾಬ್ ಬೌಡೆನ್, ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ

3
00:00:04,910 --> 00:00:07,410
ಈ CS50 ಹೊಂದಿದೆ. CS50.TV

4
00:00:07,410 --> 00:00:15,770
ಆದ್ದರಿಂದ, ನಾನು ರಾಬ್ ಆಗಿದ್ದೇನೆ. ನಾನು ಕಿರ್ಕ್ಲ್ಯಾಂಡ್ ಹಿರಿಯ ಆಗಿದ್ದೇನೆ. ಈ CS50 TFing ನನ್ನ ಮೂರನೇ ವರ್ಷ.

5
00:00:15,770 --> 00:00:22,220
ಇದು ನಾವು ಸಾಂಪ್ರದಾಯಿಕ-ಉಪನ್ಯಾಸ ಶೈಲಿಯ ವಿಭಾಗದಿಂದ ಬದಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಮೊದಲ ಬಾರಿಗೆ

6
00:00:22,220 --> 00:00:25,610
ಅಲ್ಲಿ ನೀವು ಹುಡುಗರಿಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು ಯಾವ ಉಪನ್ಯಾಸ ನಡೆದ ನಂತರ ಪರಿಶೀಲನೆಯ ನಾವು ರೀತಿಯ,

7
00:00:25,610 --> 00:00:32,250
ಈಗ ನಾವು ಸ್ಪೇಸಸ್ ಬಳಸುವ, ಒಂದು ಸಾಕಷ್ಟು ಹೆಚ್ಚಿನ ಸಮಸ್ಯೆ ಆಧಾರಿತ ಎಂದು, ಮತ್ತು -

8
00:00:32,250 --> 00:00:37,410
ಓಹ್, ಆದ್ದರಿಂದ ಕಲ್ಪನೆಯನ್ನು ನಾನು ಕಳುಹಿಸಿದ ಲಿಂಕ್ ಹೋಗಲು ಮತ್ತು ನಂತರ ನೀವು ನನ್ನ ಸ್ಪೇಸ್ ಇರುವಿರಿ.

9
00:00:37,410 --> 00:00:42,410
ಯಾರಾದರೂ ಒಂದು ಲ್ಯಾಪ್ಟಾಪ್ ಹೊಂದಿಲ್ಲ? ಸರಿ.

10
00:00:42,410 --> 00:00:47,050
ಆದ್ದರಿಂದ ನಾವು ಈ ಬಳಸುತ್ತಿರಬಹುದು ಎಂದು ನೀನು, ಮತ್ತು ನಾವು ಸಮಸ್ಯೆಗಳನ್ನು ಮಾಡುವಾಗ ಎಂದು ನೀನು ವಿಭಾಗದಲ್ಲಿ ಲೈವ್

11
00:00:47,050 --> 00:00:50,740
ಮತ್ತು ಅವುಗಳನ್ನು ಚರ್ಚಿಸುತ್ತಿದ್ದಾರೆ ಮತ್ತು ತಪ್ಪು ಎಂಬುದನ್ನು ಹುಡುಕುವ

12
00:00:50,740 --> 00:00:56,390
ಮತ್ತು ನಾನು ನಿಮ್ಮ ಕೋಡ್ ಕೆಲವು ಮೇಲೆಳೆದುಕೊಳ್ಳಲು ಇರಬಹುದು, ಮತ್ತು ನಾನು ನಿಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಚರ್ಚಿಸಿ ಇರಬಹುದು.

13
00:00:56,390 --> 00:01:02,140
ಆದ್ದರಿಂದ ಯಾರಾದರೂ ತೊಂದರೆ ಹೊಂದಿತ್ತು?

14
00:01:02,140 --> 00:01:07,000
ನೀವು ಬದಿಯಲ್ಲಿ ಚಾಟ್; ನಾವು ಕಾರಣ ನಾವು ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

15
00:01:07,000 --> 00:01:12,270
ಆ ವರ್ಗ ನಲ್ಲಿ ವೇಳೆ ಈಗ ಹಿಂದಿನ supersection ಹಾಗೆ, ಆ ಬಗ್ಗೆ ಏನು ಗೊತ್ತು.

16
00:01:12,270 --> 00:01:19,200
ಪಿ ಸೆಟ್ ಎಲ್ಲಾ ಈ ವಿಭಾಗಗಳನ್ನು ಇರುವಂತೆ ವಿಶೇಷವೇನು.

17
00:01:19,200 --> 00:01:22,550
ಪಿ ಸೆಟ್ 2 ಆದ್ದರಿಂದ, ನಿರ್ದಿಷ್ಟ, ನಾನು ಈಗಾಗಲೇ ಪಿ ಸೆಟ್ 1 ರಂದು ಇದು ಕಂಡಿತು ಊಹೆ.

18
00:01:22,550 --> 00:01:27,400
ಆದರೆ ನಾವು ಇಂದು ಹೋಗುವಾಗ ಎಂದು ನೀನು ಯಾವ ಪಿ ಸೆಟ್ 2 ನೋಡಬಹುದು.

19
00:01:27,400 --> 00:01:29,460
ಮತ್ತು ನೀವು ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದು ವಿಭಾಗ ನೋಡುತ್ತಾರೆ.

20
00:01:29,460 --> 00:01:37,530
ಆದ್ದರಿಂದ ಈ ಪಿ ಸೆಟ್ ಎಲ್ಲಾ ಇರುತ್ತದೆ; ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದು ವಿಭಾಗ ವಿಲ್ ಬಿ ದೇರ್.

21
00:01:37,530 --> 00:01:41,340
ಇದುವರೆಗೆ ನಾವು "ಈ ಅಭ್ಯಾಸ ಮಾಡಲು ಅವಕಾಶವನ್ನು ಪರಿಗಣಿಸಿ.", ಹೇಳುತ್ತಿದ್ದೆ

22
00:01:41,340 --> 00:01:44,940
ಈ ಪ್ರೋಗ್ರಾಂ ಸಲ್ಲಿಸಲು ಕೇಳಲಾಗುವುದಿಲ್ಲ.

23
00:01:44,940 --> 00:01:48,480
ಕಲ್ಪನೆಯನ್ನು ಈ ನೀವು ಸಮಸ್ಯೆ ಸೆಟ್ ಪ್ರಾರಂಭಿಸಲು ಸಹಾಯ ರೀತಿಯ ಭಾವಿಸಲಾಗಿದೆ ಮಾಡುತ್ತದೆ.

24
00:01:48,480 --> 00:01:53,220
ನಾನು ಹ್ಯಾಕರ್ ಆವೃತ್ತಿಯಲ್ಲಿ ಊಹೆ, ಅವುಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ಕೇವಲ ತಿಳಿಯಲು ಹೊಸ, ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಗಳನ್ನು ಆಗಿರಬೇಕು ಮಾಡಲಾಗುತ್ತದೆ.

25
00:01:53,220 --> 00:01:58,590
ಅವರು ಸಮಸ್ಯೆ ಸೆಟ್ ನೇರವಾಗಿ ಅನ್ವಯಿಸುವ ಇರಬಹುದು.

26
00:01:58,590 --> 00:02:01,810
ಮತ್ತು ಈಗ ನಾವು, ನೀವು ಅವುಗಳನ್ನು ಸಲ್ಲಿಸಲು ಹೊಂದಿರುವ, ಆದರೆ ಸಿದ್ಧಾಂತದಲ್ಲಿ ಇಲ್ಲ

27
00:02:01,810 --> 00:02:07,480
ನಂತರ ಸಮಸ್ಯೆ ಸೆಟ್, ನೀವು ಅವುಗಳನ್ನು ಸಲ್ಲಿಸಲು ಇರಬಹುದು, ಹಾಗಾಗಿ ನೀವು ಎರಡೂ ಭಾಗಕ್ಕೆ ಬರಬಹುದು

28
00:02:07,480 --> 00:02:10,380
ಅಥವಾ ಉತ್ತರಗಳನ್ನು ಪಡೆಯಲು ವಿಭಾಗ ವೀಕ್ಷಿಸಬಹುದು, ಅಥವಾ ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಅವುಗಳನ್ನು ಪಡೆಯುವುದು

29
00:02:10,380 --> 00:02:16,350
ನೀವು ನನ್ನ ಉಪಸ್ಥಿತಿ ಆನಂದಿಸಬಹುದು ಭಾವನೆ ಬಂದರೆ.

30
00:02:16,350 --> 00:02:21,010
ಆದ್ದರಿಂದ - ನಾನು ಈ ಮೊದಲ ಒಂದು ಎಂದು.

31
00:02:21,010 --> 00:02:29,280
ಓಹ್. ಸಹ, ಪ್ರಶ್ನೆಗಳನ್ನು ಈ ವಿಭಾಗಗಳ ಅಡಿಯಲ್ಲಿ ನಾವು ನೀವು ಕಿರು ಬಗ್ಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿ ಬಂದಿವೆ.

32
00:02:29,280 --> 00:02:33,440
ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಸಿದ್ಧಾಂತದಲ್ಲಿ, ನೀವು, ಭಾಗಕ್ಕೆ ಬರುವ ಮೊದಲು ಈ ವೀಕ್ಷಿಸಲು ಭಾವಿಸಲಾದ ನೀವು

33
00:02:33,440 --> 00:02:38,550
ನೀವು ವೇಳೆ ಆದರೆ ದಂಡ ಇಲ್ಲಿದೆ; ನಾವು ಹೇಗಾದರೂ ಅವುಗಳನ್ನು ಮೇಲೆ ಹೋಗುತ್ತೇನೆ.

34
00:02:38,550 --> 00:02:42,590
ಆದ್ದರಿಂದ ನಾವು ಈ ಮೂಲಕ ಆರಂಭಿಸಬಹುದು: "ಹೇಗೆ ಸ್ವಲ್ಪ ಕುಣಿಕೆಗಳು ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಭಿನ್ನವಾಗಿವೆ ಮಾಡುವುದಿಲ್ಲ?

35
00:02:42,590 --> 00:02:46,210
ಆಗ ಎರಡನೆಯ ಪ್ರಯೋಜನಕಾರಿಯಾಗುತ್ತದೆ? "

36
00:02:46,210 --> 00:02:49,390
ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಯಾವುದೇ ಹೊಂದಿವೆ -?

37
00:02:49,390 --> 00:02:52,730
[ವಿದ್ಯಾರ್ಥಿ] ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಯಾವಾಗಲೂ ಒಮ್ಮೆಯಾದರೂ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

38
00:02:52,730 --> 00:03:02,950
ಹೌದು. ಆದ್ದರಿಂದ ವ್ಯತ್ಯಾಸವಾಗಿದೆ. ಸ್ವಲ್ಪ ಲೂಪ್ - I'll ಇಲ್ಲಿ ಮೇಲೆ ಅದನ್ನು - ಲೂಪ್ ಮಾಡುವಾಗ, ನಾವು ಪರಿಸ್ಥಿತಿಯನ್ನು

39
00:03:02,950 --> 00:03:19,760
ಇಲ್ಲಿಯೇ, ಆದರೆ ಒಂದು ಮಾಡಬೇಡಿ ನಾವು ಇಲ್ಲಿ ಕೆಳಗಿಳಿಯಿರಿ ರವರೆಗೆ, ನೀವು ಒಂದು ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿಲ್ಲ.

40
00:03:19,760 --> 00:03:24,130
ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸುವ, ಮತ್ತು ಹಾಗೆಯೇ ಲೂಪ್ ಸೇರಿದಾಗ

41
00:03:24,130 --> 00:03:26,380
ಈ ಸ್ಥಿತಿಯನ್ನು ನಿಜವಾದ ವೇಳೆ ತಕ್ಷಣ ಪರಿಶೀಲಿಸುತ್ತದೆ.

42
00:03:26,380 --> 00:03:30,710
ಷರತ್ತಿನ ನಿಜವಲ್ಲ, ಅದು ಕೇವಲ ಸಂಪೂರ್ಣವಾಗಿ ಲೂಪ್ ಮೇಲೆ ತ್ಯಜಿಸುತ್ತದೆ.

43
00:03:30,710 --> 00:03:34,390
ಏನು-ಸಂದರ್ಭದಲ್ಲಿ ಲೂಪ್ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಇದೆ ಎಂದು, ಅದು "ಮಾಡಿ." ಸಮೀಪದಲ್ಲಿ

44
00:03:34,390 --> 00:03:37,920
ಏನೂ ಈ ಹಂತದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ, ಕೇವಲ ಪಾಲಿಸಲು ಮುಂದುವರೆಯುತ್ತದೆ.

45
00:03:37,920 --> 00:03:42,690
ನಂತರ ಪರಿಸ್ಥಿತಿ ನಿಜವಾದ ವೇಳೆ ಅದು "ಆದರೆ," ಬಡಿದಾಗ, ಅದು ಲೂಪ್ ಬ್ಯಾಕ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಮತ್ತೆ ಅದನ್ನು

46
00:03:42,690 --> 00:03:46,730
ಮತ್ತೆ ಮತ್ತೆ ಪರಿಸ್ಥಿತಿ ಕೇವಲ ಮೂಲಕ ಬರುತ್ತದೆ ನಂತರ ನಿಜವಾದ ಮತ್ತು ತನಕ.

47
00:03:46,730 --> 00:03:50,600
ಆದ್ದರಿಂದ, ಈ ವ್ಯತ್ಯಾಸವನ್ನು ಅತ್ಯಂತ ಆರಂಭದಿಂದಲೂ ಬಲ ನಿರ್ಲಕ್ಷಿಸಿ ಎಂದು, ಎಂದು.

48
00:03:50,600 --> 00:03:56,770
ಇದು ಅವಶ್ಯವಾಗಿ ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಿ ಮತ್ತು ಪರಿಸ್ಥಿತಿಯನ್ನು ಇನ್ನೂ ನಿಜವಾದ ವೇಳೆ ನಂತರ ಹೆಚ್ಚು ಬಾರಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

49
00:03:56,770 --> 00:04:03,720
ಆದ್ದರಿಂದಾಗಿ ಲೂಪ್ ಸಾರಿ ಮಾತ್ರ ಮಾಡಲು, ಅಥವಾ ಕಾಣಿಸುತ್ತದೆ - ಸಮಯದಲ್ಲಿ ಲೂಪ್ - ನಾವು ಅದನ್ನು ಅವಶ್ಯಕತೆ ಇರಬಹುದು,

50
00:04:03,720 --> 00:04:07,900
ಸ್ಥಿತಿಯನ್ನು ತಪ್ಪು ವೇಳೆ ತಕ್ಷಣ ನಾವು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ರಿಂದ, ನಾವು ಅದನ್ನು ಬಲ ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ.

51
00:04:07,900 --> 00:04:11,770
ಆದರೆ ಏನು-ಸಮಯದಲ್ಲಿ ಲೂಪ್, ನಾವು ಅಗತ್ಯವಾಗಿ, ಒಮ್ಮೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

52
00:04:11,770 --> 00:04:14,560
ಇದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಇದ್ದರೆ ನಂತರ, ನಾವು ಸ್ಥಿತಿಗೆ ಪಡೆದಾಗ, ನಾವು ಪರಿಶೀಲಿಸಿ.

53
00:04:14,560 --> 00:04:19,790
ಇದು ನಿಜ, ನಾವು ಮತ್ತೆ ಮಾಡುತ್ತೇನೆ ಇದು ತಪ್ಪು ಇದ್ದರೆ, ನಾವು ಹೋಗುವ ನಾವು ಮುಂದುವರಿಸುತ್ತೇವೆ.

54
00:04:19,790 --> 00:04:24,680
ಆದ್ದರಿಂದ ನಂತರದ ಪ್ರಯೋಜನಕಾರಿಯಾಗುತ್ತದೆ?

55
00:04:24,680 --> 00:04:31,190
ಹಾಗಾಗಿ, 4 ವರ್ಷಗಳ ಸಂಪೂರ್ಣ, 3 ವರ್ಷಗಳ, ಏನೇ ಆ ಹೇಳಬಹುದು

56
00:04:31,190 --> 00:04:38,780
ನಾನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು, ನಾನು 10 ಬಾರಿ ಅಡಿಯಲ್ಲಿ ನಂತಹ, ಈ ಬಳಸಿದ್ದಾರೆ.

57
00:04:38,780 --> 00:04:43,140
ನಾವು-ಸಂದರ್ಭದಲ್ಲಿ ಕುಣಿಕೆಗಳು ಪರಿಚಯಿಸುವ ಮಾಡಿದಾಗ ಮತ್ತು ಪ್ರಾಯಶಃ ಅವುಗಳಲ್ಲಿ 5 CS50 ಇವೆ.

58
00:04:43,140 --> 00:04:47,510
ಆದ್ದರಿಂದ ನೀವು ಕುಣಿಕೆಗಳು-ಹಾಗೆ ಮಾಡುವಾಗ ಬಳಸಲಾಗುತ್ತದೆ ಹೇಗೆ ಎದುರಿಸಬೇಕು?

59
00:04:47,510 --> 00:04:49,510
ಆಗ - ಯಾ?

60
00:04:49,510 --> 00:04:53,180
[ವಿದ್ಯಾರ್ಥಿ] ಯಾವಾಗ ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ಬಳಕೆದಾರ ಇನ್ಪುಟ್, ಅಥವಾ ಏನೋ ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ -

61
00:04:53,180 --> 00:04:59,700
ಹೌದು. ಹಾಗೆ-ಅದೇ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ದೊಡ್ಡ ಒಂದು ಕುಣಿಕೆಗಳು,.

62
00:04:59,700 --> 00:05:03,160
ಏಕೆ ಮೊದಲ ಒಂದೆರಡು ಸಮಸ್ಯೆ ಸೆಟ್ ಮೇಲೆ, ನೀವು, ಬಳಕೆದಾರ ಕೇಳಲು ಬಯಸುವ ಮಾಡಿದಾಗ, ಅವರ

63
00:05:03,160 --> 00:05:08,520
ಆ ಸಾಲನ್ನು ಪಡೆಯಲು ತನಕ "ಅಂತ ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ," ನೀವು ಮುಂದುವರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ.

64
00:05:08,520 --> 00:05:12,980
ಆದ್ದರಿಂದ ನೀವು ಅಗತ್ಯವಾಗಿ, ಒಮ್ಮೆಲೇ ಸ್ಟ್ರಿಂಗ್ ಕೇಳುವುದಿಲ್ಲ ಅಗತ್ಯವಿದೆ.

65
00:05:12,980 --> 00:05:16,950
ಆದರೆ ಕೆಟ್ಟ ಕೆಲಸಕ್ಕೆ ಉತ್ತರಿಸಲು ವೇಳೆ ನಂತರ, ನಂತರ ನೀವು ಲೂಪ್ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಮತ್ತೆ ಕೇಳಿ.

66
00:05:16,950 --> 00:05:20,810
ಆದರೆ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಬೇರೆ, ನಾನು ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ ಎದುರಿಸಬಹುದು ಎಂಬ ಅಪರೂಪದ ಇಲ್ಲಿದೆ

67
00:05:20,810 --> 00:05:27,170
ನಾನು "ಒಮ್ಮೆಲೇ" ಲೂಪ್ ಬಯಸುವ ಆದರೆ ಪ್ರಾಯಶಃ ಹೆಚ್ಚು ಅಲ್ಲಿ.

68
00:05:27,170 --> 00:05:33,370
ಪ್ರಶ್ನೆಗಳು ಅಥವಾ -? ಯಾರಾದರೂ ಒಂದು ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಎಲ್ಲಕ್ಕಿಂತ ಬಳಸಿದ್ದಾರೆ?

69
00:05:33,370 --> 00:05:36,780
ಸರಿ. ಮುಂದಿನ ಒಂದು ಆದ್ದರಿಂದ, "ವಾಟ್ ಗುರುತಿಸುವಿಕೆಯು ಅಘೋಷಿತ ಇಲ್ಲ

70
00:05:36,780 --> 00:05:43,310
ಖಣಿಲು ಅದಕ್ಕೆ outputted ವೇಳೆ ಸಾಮಾನ್ಯವಾಗಿ ಸೂಚಿಸುತ್ತದೆ? "

71
00:05:43,310 --> 00:05:47,380
ಆದ್ದರಿಂದ ಯಾವ ರೀತಿಯ ಕೋಡ್ ನಾನು ಪಡೆಯಲು ಬರೆಯಬಹುದಾದರೆ 'ಘೋಷಿಸಲ್ಪಡದ ಗುರುತು?'

72
00:05:47,380 --> 00:05:49,550
[ವಿದ್ಯಾರ್ಥಿ] ಆ X = 2?

73
00:05:49,550 --> 00:05:52,650
ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ, x = 2.

74
00:05:52,650 --> 00:06:04,830
ಈ ರನ್ ಮಾಡುತ್ತೇವೆ - ಓಹ್, ನಾನು ಕ್ಲಿಕ್ ಮಾಡಲಿಲ್ಲ. ಇಲ್ಲಿ ನಮಗೆ - ಸರಿ.

75
00:06:04,830 --> 00:06:07,100
"ಘೋಷಿಸಲ್ಪಡದ ಗುರುತಿಸುವಿಕೆಯು x ನ ಬಳಸಿ."

76
00:06:07,100 --> 00:06:11,610
ಆದ್ದರಿಂದ ಘೋಷಿಸಲ್ಪಡದ ಗುರುತಿಸುವಿಕೆ, ಒಂದು ವೇರಿಯೇಬಲ್ ನ.

77
00:06:11,610 --> 00:06:13,910
ಇದು ಆಗಾಗ್ಗೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಒಂದು ಗುರುತು ಕರೆಯುತ್ತೇವೆ.

78
00:06:13,910 --> 00:06:17,300
ಆದ್ದರಿಂದ ಇದು ವಾಸ್ತವವಾಗಿ ಒಂದು ವೇರಿಯೇಬಲ್ ನ ತಿಳಿದಿರುವ ಇರಬಹುದು; ಇದು ಯಾವ ಗೊತ್ತಿಲ್ಲ.

79
00:06:17,300 --> 00:06:19,380
ಆದ್ದರಿಂದ ಒಂದು ಗುರುತು ಇಲ್ಲಿದೆ.

80
00:06:19,380 --> 00:06:26,060
ಆದ್ದರಿಂದ ಅಘೋಷಿತ ಇದೆ? ಹೌದು.

81
00:06:26,060 --> 00:06:32,190
ಆದ್ದರಿಂದ ಪರಿಭಾಷೆ, ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಣೆಯ ಸ್ಪಷ್ಟ ಎಂದು

82
00:06:32,190 --> 00:06:37,360
ನೀವು "ಇಂಟ್ X," ಅಥವಾ "ಸ್ಟ್ರಿಂಗ್ ವೈ," ಏನೇ ಹೇಳಿ ಆಗ.

83
00:06:37,360 --> 00:06:41,910
ಚರಾಂಶದ ಆರಂಭಕ್ಕೆ, ಅಥವಾ ವೇರಿಯಬಲ್ ಹಂಚಿಕೆಗೆ,

84
00:06:41,910 --> 00:06:44,510
ನೀವು ಹೇಳುವ ಪ್ರಕಟಿಸಿದಾಗ "X = 2." ಆಗಿದೆ

85
00:06:44,510 --> 00:06:52,950
ಆದ್ದರಿಂದ ಪ್ರತ್ಯೇಕ ಹಂತಗಳಲ್ಲಿ ಈ ಮಾಡಬಹುದು, ಇಂಟ್ X, X = 2, ಮತ್ತು ರವರೆಗೆ - ನಾವು ಇಲ್ಲಿ ವಿಷಯವನ್ನು ಒಂದು ಗುಂಪೇ ಹೊಂದಬಹುದು -

86
00:06:52,950 --> 00:07:00,350
ಈ ಲೈನ್ ನಡೆಯುತ್ತದೆ ರವರೆಗೆ ಆದರೆ, X ಇನ್ನೂ ಆರಂಭಗೊಳ್ಳದ ಇದೆ, ಆದರೆ ಇದು ಎನ್ನಲಾಗಿದೆ.

87
00:07:00,350 --> 00:07:06,760
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ 1 ಲೈನ್ ಇದನ್ನು ಮಾಡಬಹುದು, ಮತ್ತು ಈಗ ನಾವು ಘೋಷಿಸುವ ಮತ್ತು ಆರಂಭಿಸುವಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ.

88
00:07:06,760 --> 00:07:10,730
ಪ್ರಶ್ನೆಗಳು?

89
00:07:10,730 --> 00:07:18,390
ಮತ್ತು ಅಂತಿಮವಾಗಿ, "ವೈ ಸೀಸರ್ ಸೈಫರ್ ಅತ್ಯಂತ ಸುರಕ್ಷಿತ ಅಲ್ಲ?"

90
00:07:18,390 --> 00:07:23,830
ಆದ್ದರಿಂದ ಮೊದಲ, ಯಾರಾದರೂ ಸೀಸರ್ ಸೈಫರ್ ಯಾವುದೆಂದು ಹೇಳುವುದು ಬಯಸುವಿರಾ?

91
00:07:23,830 --> 00:07:28,100
[ವಿದ್ಯಾರ್ಥಿ] ಸೀಸರ್ ಸೈಫರ್ ನೀವು ಮ್ಯಾಪ್ ಅಂದರೆ, ನೀವು, ಪ್ರತಿಯೊಂದು ಅಕ್ಷರ ಪಲ್ಲಟ

92
00:07:28,100 --> 00:07:34,420
ಅಕ್ಷರಗಳ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಮೇಲೆ ಹೋಗಿ, ಮತ್ತು ಮೇಲೆ ಮತ್ತೆ, ಮತ್ತು ಇದು ಅತ್ಯಂತ ಸುರಕ್ಷಿತ ಏಕೆಂದರೆ

93
00:07:34,420 --> 00:07:42,260
ಅಲ್ಲಿ ಕೇವಲ 26 ಸಂಭಾವ್ಯ ಆಯ್ಕೆಗಳನ್ನು ಮತ್ತು ಅದು ಸಿಗುತ್ತದೆ ರವರೆಗೆ ನೀವು ಆ ಪ್ರತಿಯೊಂದು 1 ಪ್ರಯತ್ನಿಸಬೇಕು.

94
00:07:42,260 --> 00:07:45,470
ಓಹ್. ಆದ್ದರಿಂದ, ನಾನು ಮತ್ತೆ ಮಾಡಬೇಕು?

95
00:07:45,470 --> 00:07:51,600
ಸೀಸರ್ ಸೈಫರ್ it's - ನನ್ನ ಪ್ರಕಾರ, ನೀವು ನೀವು ಸಮಸ್ಯೆಗಳನ್ನು ಇದು ವ್ಯವಹರಿಸುತ್ತದೆ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ -

96
00:07:51,600 --> 00:07:56,110
ಅಥವಾ ನಾನು ಹ್ಯಾಕರ್ ಆವೃತ್ತಿಯಲ್ಲಿ ಅಲ್ಲ ಎಂದು ಸಮಸ್ಯೆ ಸೆಟ್ ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿ ಊಹೆ.

97
00:07:56,110 --> 00:08:01,550
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಆವೃತ್ತಿಯಲ್ಲಿ, ನೀವು "ಹಲೋ, ವರ್ಲ್ಡ್", ಒಂದು ಸಂದೇಶ

98
00:08:01,550 --> 00:08:08,410
ಮತ್ತು ನೀವು 6 ಒಂದು ಸಂಖ್ಯೆಯ, ಮತ್ತು ಆ ಸಂದೇಶವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಪಾತ್ರ

99
00:08:08,410 --> 00:08:11,310
ನೀವು ವರ್ಣಮಾಲೆಯ 6 ಸ್ಥಾನಗಳು ಅದನ್ನು ತಿರುಗಿಸಿ.

100
00:08:11,310 --> 00:08:16,560
ಆದ್ದರಿಂದ 'H' ಹಲೋ ಗ-I-J-K-L-M-N ಆಯಿತು.

101
00:08:16,560 --> 00:08:19,600
ಆದ್ದರಿಂದ ಮೊದಲ ಅಕ್ಷರ N ಎಂದು. ನಾವು ಇ ಅದೇ ವಿಷಯವನ್ನು.

102
00:08:19,600 --> 00:08:23,530
ನಾವು ಹೊಂದಿದ್ದರೆ, ಇಷ್ಟ, z ಅಥವಾ ಏನೋ, ಆಗ ಸುಮಾರು ಮತ್ತೆ ಕಟ್ಟಲು 'ಒಂದು.'

103
00:08:23,530 --> 00:08:29,280
ಆದರೆ ಪ್ರತಿ ಪಾತ್ರದ ವರ್ಣಮಾಲೆಯ 6 ಅಕ್ಷರಗಳು ನಂತರ cycled ಪಡೆಯುತ್ತದೆ, ಮತ್ತು ಇದು ಅತ್ಯಂತ ಸುರಕ್ಷಿತ ಅಲ್ಲ

104
00:08:29,280 --> 00:08:35,440
ನೀವು ಒಂದು ಅಕ್ಷರದ ಕಟ್ಟಲು ಹೇಗೆ ಅನೇಕ ಮಾರ್ಗಗಳನ್ನು ಮಾತ್ರ 26 ಸಾಧ್ಯತೆಗಳು ಇವೆ ರಿಂದ.

105
00:08:35,440 --> 00:08:42,919
ಆದ್ದರಿಂದ ನೀವು, ದೀರ್ಘ ಸಾಕಷ್ಟು ಸಂದೇಶ, ಸಂಭಾವ್ಯವಾಗಿ, ಎಲ್ಲಾ 26 ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮಾಡಬಹುದು

106
00:08:42,919 --> 00:08:46,860
ಆ ಸಾಧ್ಯತೆ 26 ವಸ್ತುಗಳ ಕೇವಲ 1, ಸ್ಪಷ್ಟವಾಗಿವೆ ಎಂದು ಹೋಗುತ್ತದೆ

107
00:08:46,860 --> 00:08:50,300
ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ಮೂಲ ಸಂದೇಶ ಎಂದು ಹೋಗುತ್ತದೆ.

108
00:08:50,300 --> 00:08:56,240
ಆದ್ದರಿಂದ ಇದು ಏನು ಗೂಢಲಿಪೀಕರಿಸಲಾಗುತ್ತದೆ ಒಂದು ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ಅಲ್ಲ.

109
00:08:56,240 --> 00:08:59,070
ಆ ಕಿರು ಸಂಬಂಧವಿಲ್ಲದ, "ಒಂದು ಕಾರ್ಯವೇನು?"

110
00:08:59,070 --> 00:09:03,370
ಆದ್ದರಿಂದ ಒಂದು ಕಾರ್ಯವೇನು? ಹೌದು.

111
00:09:03,370 --> 00:09:11,640
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಮೂಲಕ ಹೋಗಿ ಮತ್ತು ನಂತರ ಯಾವುದೇ ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಕರೆ ಮಾಡಬಹುದು ಎಂದು ಕೋಡ್ ಒಂದು ಪ್ರತ್ಯೇಕ ತುಂಡು ಅನಿಸುತ್ತದೆ.

112
00:09:11,640 --> 00:09:18,160
ಹೌದು. ಸಹ ಮುಂದಿನ ಒಂದು ಉತ್ತರಿಸುವ ಮೂಲಕ ಅಥವಾ ಪುನರಾವರ್ತಿತ - ನಾನು ಕೂಡ ಮುಂದಿನ ಉತ್ತರಿಸುವ ಮೂಲಕ ಉತ್ತರಿಸುತ್ತೇವೆ.

113
00:09:18,160 --> 00:09:22,410
ನೀವು ಮತ್ತೊಮ್ಮೆ ಕೇವಲ ಕೋಡ್ ನಕಲಿಸುವುದು ಮತ್ತು ಅಂಟಿಸುವುದು ಬದಲಿಗೆ ಕ್ರಿಯೆಗಳ ಬಳಸಿ ಮಾಡಬಹುದು.

114
00:09:22,410 --> 00:09:27,200
ಕೇವಲ ಆ ಕೋಡ್ ತೆಗೆದುಕೊಳ್ಳಲು ಒಂದು fuction ಹಾಕಿದರೆ, ಮತ್ತು ನಂತರ ನೀವು ಕೇವಲ ಕ್ರಿಯೆಯ ಕರೆಯಬಹುದು

115
00:09:27,200 --> 00:09:29,870
ಎಲ್ಲೆಲ್ಲಿ ನೀವು ನಕಲು ಮತ್ತು ಅಂಟಿಸಲು ಮಾಡಲಾಗಿದೆ.

116
00:09:29,870 --> 00:09:33,350
ಆದ್ದರಿಂದ ಕಾರ್ಯಗಳು ಉಪಯುಕ್ತ.

117
00:09:33,350 --> 00:09:35,860
ಈಗ ನಾವು ನಿಜವಾದ ಸಮಸ್ಯೆಗಳನ್ನು ಮಾಡುತ್ತೇನೆ.

118
00:09:35,860 --> 00:09:46,490
ಮೊದಲ ಒಂದು. ಮೊದಲ ಒಂದು ಕಲ್ಪನೆ, ಅದನ್ನು ಲೆಕ್ಕಿಸದೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ರವಾನಿಸಲು, ಮತ್ತು -

119
00:09:46,490 --> 00:09:52,060
ಅಥವಾ ಎಲ್ಲಾ ಸಣ್ಣ ಹೇಳುತ್ತದೆ? ಎಲ್ಲಾ ಸಣ್ಣ ಏನೂ ಬರೆದಿಲ್ಲ.

120
00:09:52,060 --> 00:09:57,730
ಆದ್ದರಿಂದ ಸಂದೇಶ ಏನು, ಮತ್ತು - ಯಾವುದೇ ಓಹ್. ಅದು.

121
00:09:57,730 --> 00:10:01,610
"ಸರಳತೆ, ನೀವು ಕಲ್ಪಿಸಿಕೊಳ್ಳಬಹುದು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಚಿಕ್ಕ ಅಕ್ಷರಗಳನ್ನು ಮತ್ತು ಸ್ಥಳಗಳನ್ನು ಮಾತ್ರ ಎಂದು."

122
00:10:01,610 --> 00:10:08,180
ನಾವು ಕೇವಲ ಸಣ್ಣ ಅಕ್ಷರಗಳ ಒಂದು ಸಂದೇಶವನ್ನು ರವಾನಿಸಲು ಮತ್ತು ನಂತರ ನಾವು ಪರ್ಯಾಯ

123
00:10:08,180 --> 00:10:15,450
ಕ್ಯಾಪಿಟಲ್ ಮತ್ತು ಲೋಯರ್ಕೇಸ್ ನಡುವೆ - ನಾವು ಸ್ಟ್ರಿಂಗ್ ಪರ್ಯಾಯ, ಬಂಡವಾಳ ಮತ್ತು ಲೋವರ್ ಕೇಸ್ ಎಂದು ಬದಲಾಯಿಸಿ.

124
00:10:15,450 --> 00:10:22,920
ಆದ್ದರಿಂದ ಮೊದಲು ನಾವು, ನೀವು ಸಮಸ್ಯೆಯನ್ನು ಧುಮುಕುವುದಿಲ್ಲ ಎರಡನೇ ನೀಡಿ

125
00:10:22,920 --> 00:10:32,420
ನಾವು ಮಾಡಬೇಕಾದ್ದು ಮೊದಲ ವಿಷಯ ಏನು?

126
00:10:32,420 --> 00:10:36,900
ಓಹ್, ಏನು ನಾನು ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುತ್ತಾರೆ? ಒಹ್, ನಾನು ಇಲ್ಲಿ ಇಮೇಲ್ ಕ್ಲಿಕ್.

127
00:10:36,900 --> 00:10:42,870
ನಾವು ಮಾಡಬೇಕಾದ್ದು ಮೊದಲ ವಿಷಯ - ನಾನು ತಪ್ಪು ಒಂದು ನೋಡಿ ನಾನು?

128
00:10:42,870 --> 00:10:49,320
ಈ ಒಂದು ಭಾಗವಾಗಿದೆ?

129
00:10:49,320 --> 00:10:51,320
ಇಲ್ಲ, ಆ ಆದರೂ, ಅಲ್ಲಿ ಇನ್ನೂ.

130
00:10:51,320 --> 00:10:55,160
ಸರಿ, ಇನ್ನೂ ಇಲ್ಲಿ.

131
00:10:55,160 --> 00:11:03,160
ಈಗ ನಾವು ಊಹಿಸಲಾಗುವುದಿಲ್ಲ -? ಹೌದು. ಇಲ್ಲಿ ನಾವು ಕೇವಲ ಸಣ್ಣ ಮತ್ತು ಖಾಲಿ ಎಂದು ಊಹಿಸಲಾಗುವುದಿಲ್ಲ.

132
00:11:03,160 --> 00:11:07,770
ಈಗ ನಾವು ಅಕ್ಷರಗಳನ್ನು ನಾವು ಅವುಗಳನ್ನು ಬಯಸುತ್ತೇನೆ ಯಾವುದೇ ಎಂದು ವಾಸ್ತವವಾಗಿ ವ್ಯವಹರಿಸಬೇಕು.

133
00:11:07,770 --> 00:11:11,910
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಬಯಸುವ ಮೊದಲ ವಿಷಯ ಕೇವಲ ಸಂದೇಶ ಇದೆ.

134
00:11:11,910 --> 00:11:19,790
ನಾವು ಸರಿ, ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು ಸ್ಟ್ರಿಂಗ್ ರು = GetString ಅಗತ್ಯವಿದೆ.

135
00:11:19,790 --> 00:11:24,890
ಈಗ ಈ ಸಮಸ್ಯೆ, ಅದನ್ನು ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ಒಂದೆರಡು ಇವೆ.

136
00:11:24,890 --> 00:11:29,840
ಆದರೆ ನಾವು ಇಲ್ಲಿ bitwise ನಿರ್ವಾಹಕರು ಬಳಸಲು ಬಯಸುವ ಹೋಗುವ.

137
00:11:29,840 --> 00:11:35,280
ಅಲ್ಲಿ ಎರಡೂ supersection ನಲ್ಲಿ ಇರಲಿಲ್ಲ ಜನರಿಗೆ,

138
00:11:35,280 --> 00:11:37,480
ಅಥವಾ ಏನಾದರೂ, ಮತ್ತು bitwise ನಿರ್ವಾಹಕರು ಏನು ಗೊತ್ತಿಲ್ಲ?

139
00:11:37,480 --> 00:11:41,710
ಅಥವಾ ಅವರು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ASCII ಸಂಬಂಧಿಸಿದೆ ಹೇಗೆ?

140
00:11:41,710 --> 00:11:45,650
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು supersection ನಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ನಾನು bitwise ನಿರ್ವಾಹಕರು ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಲು.

141
00:11:45,650 --> 00:11:49,560
ಸರಿ. ಆದ್ದರಿಂದ ನಾನು ಅವರಿಗೆ ಮೂಲಭೂತ ಮೇಲೆ ಹೋಗಲು ಹೊಂದಿಲ್ಲ, ಆದರೆ ನಾನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ

142
00:11:49,560 --> 00:11:51,830
ನಾವು ಇಲ್ಲಿ ಬಳಸಲು ಬಯಸುವ ಹೋಗಿ ಏನನ್ನು.

143
00:11:51,830 --> 00:11:59,680
ಆದ್ದರಿಂದ 'ಎ': ರಾಜಧಾನಿ ಒಂದು ಬೈನರಿ ಪ್ರಾತಿನಿಧ್ಯ, ಸಂಖ್ಯೆ 65 ಆಗಿದೆ.

144
00:11:59,680 --> 00:12:07,560
ನಾನು ನೋಡಲು ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ - 41 01000001 ಏರಲಿದೆ.

145
00:12:07,560 --> 00:12:14,170
ಆದ್ದರಿಂದ ದಶಮಾಂಶ 65 ಆಗಿರಬೇಕು; ಆದ್ದರಿಂದ ಈ ಪಾತ್ರವನ್ನು ರಾಜಧಾನಿ ಎ ಬೈನರಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

146
00:12:14,170 --> 00:12:19,440
ಈಗ, ಪಾತ್ರದ ಬೈನರಿ ಪ್ರಾತಿನಿಧ್ಯ 'ಒಂದು' ಸಣ್ಣ

147
00:12:19,440 --> 00:12:33,350
ಬಹುತೇಕ ಅದೇ ವಿಷಯ ಎಂದು ಹೋಗುತ್ತದೆ. 6 ಹೌದು, - ಎಂದು. ಈ ಹಕ್ಕು.

148
00:12:33,350 --> 00:12:37,670
ಆದ್ದರಿಂದ ಬೈನರಿ ರಾಜಧಾನಿ ಎ, ಅವಳಿ ಸಣ್ಣ 'ಒಂದು.'

149
00:12:37,670 --> 00:12:43,940
ಆದ್ದರಿಂದ ಗಮನಕ್ಕೆ ಒಂದು ಮತ್ತು 'ಒಂದು' ಈ ಏಕೈಕ ಭಾಗ. ನಡುವಿನ ವ್ಯತ್ಯಾಸ

150
00:12:43,940 --> 00:12:49,440
ಮತ್ತು ಈ ಬಿಟ್ 32, ಸಂಖ್ಯೆ 32 ಪ್ರತಿನಿಧಿಸುವ ಬಿಟ್ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ.

151
00:12:49,440 --> 00:12:53,910
ಎ 65 ಏಕೆಂದರೆ ಇದರಿಂದಾಗಿ ಮಾಡುತ್ತದೆ; 'ಒಂದು' 97 ಆಗಿದೆ.

152
00:12:53,910 --> 00:12:56,610
ಇವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನೆಂದರೆ 32.

153
00:12:56,610 --> 00:13:03,770
ಈಗ ನಾವು ತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಒಂದು ಮಾಡಲು 'ಒಂದು' ಮತಾಂತರ ಮಾಡಬಹುದು ತಿಳಿದಿದೆ

154
00:13:03,770 --> 00:13:09,710
ಮತ್ತು bitwise, ಇದು ORing - ಒಂದು 1 ತೋರುತ್ತಿದೆ ಎಂದು.

155
00:13:09,710 --> 00:13:20,900
ಈ 00100000 ಒಂದು bitwise ಅಥವಾ, ಆಗಿದೆ, ಮತ್ತು ನಮಗೆ ನೀಡುತ್ತೇನೆ 'ಒಂದು.'

156
00:13:20,900 --> 00:13:26,850
ಮತ್ತು ನಾವು bitwise ANDing ಎ ಗೆ 'ಒಂದು' ನಿಂದ ಪಡೆಯಬಹುದು

157
00:13:26,850 --> 00:13:33,700
ಆ ಸ್ಥಾನದಲ್ಲಿ, 11111 ರಲ್ಲಿ 11, 0.

158
00:13:33,700 --> 00:13:43,840
, ಆದರೆ ಈ ಮಾಲಿಕ ಬಿಟ್ ಔಟ್ ರದ್ದು; ಆದ್ದರಿಂದ ಈ ನಂತರ 'ಒಂದು' ಎಂದು ನಿಖರವಾಗಿ ನಮಗೆ ನೀಡುತ್ತದೆ

159
00:13:43,840 --> 00:13:50,070
ಆದ್ದರಿಂದ ನಾವು 01000001 ಸಾಧ್ಯವಿದೆ; ನಾನು ಎಣಿಕೆ ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

160
00:13:50,070 --> 00:13:56,750
ಆದರೆ bitwise ORing ಈ ತಂತ್ರವನ್ನು, ಲೋವರ್ಕೇಸ್ ರಾಜಧಾನಿಗೆ ಪಡೆಯಲು

161
00:13:56,750 --> 00:14:02,080
ಮತ್ತು bitwise ಸಣ್ಣ ಬಂಡವಾಳ ಪಡೆಯಲು ANDing ಎ ವಿಶೇಷ ಅಲ್ಲ

162
00:14:02,080 --> 00:14:06,510
ಅಕ್ಷರಗಳ ಎಲ್ಲಾ Vs ಕೆ ಕೆ, ಝಡ್ Vs z,

163
00:14:06,510 --> 00:14:10,080
ಎಲ್ಲಾ ಈ ಏಕ ಬಿಟ್ ಮೂಲಕ ಭಿನ್ನವಾಗಿರುತ್ತವೆ ಹೋಗುವ.

164
00:14:10,080 --> 00:14:16,290
ಆದ್ದರಿಂದ ನೀವು ಯಾವುದೇ ಬಂಡವಾಳ ಪತ್ರ ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ ಯಾವುದೇ ಸಣ್ಣಕ್ಷರವು ಬದಲಾಯಿಸಲು ಈ ಬಳಸಬಹುದು.

165
00:14:16,290 --> 00:14:26,670
ಸರಿ. ಈ ಪಡೆಯುವ ಆದ್ದರಿಂದ ಸುಲಭದ ದಾರಿ - ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಹೊಂದುವ

166
00:14:26,670 --> 00:14:32,170
ಯಾವುದೇ 1011111 ಔಟ್ ಬರೆಯಲು - ಈ ಸಂಖ್ಯೆ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಸುಲಭ ರೀತಿಯಲ್ಲಿ, ಮತ್ತು ಈ ಒಂದು ಅಲ್ಲ

167
00:14:32,170 --> 00:14:39,710
ನಾನು supersection ಸುಮಾರು ಹೋದರು, ಆದರೆ tilde (~) ಮತ್ತೊಂದು bitwise ಆಯೋಜಕರು ಹೊಂದಿದೆ.

168
00:14:39,710 --> 00:14:42,520
ಏನು ~~~V ಇದು ಬಿಟ್ ಪ್ರಾತಿನಿಧ್ಯ ನೋಡುವುದು ಆಗಿದೆ.

169
00:14:42,520 --> 00:14:45,630
ನ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ನೋಡೋಣ.

170
00:14:45,630 --> 00:14:53,130
ಈ ಕೆಲವು ಅವಳಿ ಸಂಖ್ಯೆ, ಮತ್ತು ~ ಹೊಂದಿದೆ ಏನು ಕೇವಲ ಬಿಟ್ಸ್ ಎಲ್ಲಾ ತಿರುಗಿಸುವಿಕೆ.

171
00:14:53,130 --> 00:15:00,630
ಆದ್ದರಿಂದ ಈ ಈಗ 0, ಈ, ಈಗ, 010100 ಒಂದು 1 0 ಆಗಿದೆ, ಒಂದು 1 ಆಗಿತ್ತು.

172
00:15:00,630 --> 00:15:08,320
ಇದರಿಂದ ಎಲ್ಲ ~ ಮಾಡುತ್ತದೆ. ಆ ತೊಡೆದುಹಾಕಲು - ಆದ್ದರಿಂದ 32 ಸಂಖ್ಯೆಗೆ ಹೋಗುತ್ತದೆ -

173
00:15:08,320 --> 00:15:23,320
ಆದ್ದರಿಂದ 32 ಸಂಖ್ಯೆ 00100000 ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಆದ್ದರಿಂದ ಇದರ ~~~V ಏರಲಿದೆ

174
00:15:23,320 --> 00:15:29,980
ನಾನು 'ಒಂದು' ANDed ಇಲ್ಲಿ ಈ ಸಂಖ್ಯೆಯನ್ನು.

175
00:15:29,980 --> 00:15:35,600
ಎಲ್ಲರೂ ನೋಡಿ ಡಸ್? ನೀವು ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಬಯಸಿದಾಗ ನಂತಹ, ಬಹಳ ಸಾಮಾನ್ಯ

176
00:15:35,600 --> 00:15:40,740
ನಾವು ನೀವು ಬಯಸುವ ನಾವು, ನೋಡಿದ ಎಂದು ನಂತರ ವಿಷಯಗಳಿಗೆ -

177
00:15:40,740 --> 00:15:44,710
ಅಥವಾ ನಾವು 1 ಹೊರತುಪಡಿಸಿ ಎಲ್ಲವೂ, ಪ್ರತಿಯೊಂದು ಬಿಟ್ ಸೆಟ್ ಬಯಸುವ

178
00:15:44,710 --> 00:15:47,910
ನಾವು ಸೆಟ್ ಬಯಸುವುದಿಲ್ಲ ಎಂದು ಬಿಟ್ ಆಫ್ ~~~V ಮಾಡಲು ಒಲವು.

179
00:15:47,910 --> 00:15:53,090
ನಾವು 32 ಬಿಟ್ ಸೆಟ್ ಬಯಸುವುದಿಲ್ಲ, ನಾವು 32 ~~~V ಆದ್ದರಿಂದ.

180
00:15:53,090 --> 00:15:57,790
ಸರಿ. ನಾವು ಇಲ್ಲಿ ಆ ಎಲ್ಲಾ ಬಳಸಬಹುದು.

181
00:15:57,790 --> 00:16:03,000
ಸರಿ, ಆದ್ದರಿಂದ ನೀವು ಮಾಡದಿದ್ದರೆ, ನಾವು ನಿಧಾನವಾಗಿ ಒಟ್ಟಾರೆ ನಡೆಯಲು ಹಾಗಿಲ್ಲ ದಂಡ ಇಲ್ಲಿದೆ

182
00:16:03,000 --> 00:16:11,870
ಅಥವಾ, ಈ ಸುಲಭ ಜಯ - ಈ ಮೂಲಕ. ಈ ಮೂಲಕ ವಲ್ಕ್.

183
00:16:11,870 --> 00:16:20,790
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ಏನಾದರೂ ಆ ಸಾಲಿನಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಮೇಲೆ ಲೂಪ್ ಬಯಸುವ ಮತ್ತು ಹಾಗೆ.

184
00:16:20,790 --> 00:16:26,710
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಒಂದು ವಾಕ್ಯವನ್ನು ಮೇಲೆ ಲೂಪ್ ಏನು? ನಾವು ಏನನ್ನು ಬಳಸಬೇಕು?

185
00:16:26,710 --> 00:16:30,980
ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಏನು ಪ್ರಯೋಜನ ಇಲ್ಲ. ಹೌದು.

186
00:16:30,980 --> 00:16:42,940
ಆದ್ದರಿಂದ ನನ್ನ iterator ಹೊಂದಿವೆ, ಮತ್ತು ಅವರು ಹೇಳುತ್ತಾರೆ, ಆದರೆ ಹೇಗೆ ನಾನು ಸಾಲಿನಲ್ಲಿ ಎಷ್ಟು ಪಾತ್ರಗಳು ತಿಳಿಯುವುದು?

187
00:16:42,940 --> 00:16:47,030
Strlen (ರು), ನಂತರ ನಾನು + +.

188
00:16:47,030 --> 00:16:49,860
ಹಾಗಾಗಿ ನಾನು ಇಲ್ಲಿ ಮಾಡಿದ ವಸ್ತುಗಳ ಮಾಡುವ ಅತ್ಯುತ್ತಮ ಮಾರ್ಗವಲ್ಲ.

189
00:16:49,860 --> 00:16:51,860
ಏಕೆ ಯಾರಿಗಾದರೂ ತಿಳಿದಿದೆಯೇ?

190
00:16:51,860 --> 00:16:55,290
ನೀವು ಸ್ಟ್ರಿಂಗ್ ಪ್ರತಿಯೊಂದು ಸಮಯ ಭಾಷೆಯನ್ನು ಪರೀಕ್ಷಿಸುವ ಇರುವ ಕಾರಣ.

191
00:16:55,290 --> 00:17:06,859
ನಾವು strlen ಚಲಿಸಬೇಕೆಂದಿರುವ ಹೋಗುವ ಹಾಗೆ, ನಾನು ಇಲ್ಲಿ ಹೇಳಬಹುದು, ಇಂಟ್ ಉದ್ದ = strlen (ರು),

192
00:17:06,859 --> 00:17:11,900
ತದನಂತರ ನಾನು <ಉದ್ದ, ಮತ್ತು ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಮೊದಲು ಅದನ್ನು ನೋಡಿಯೇ ಇಲ್ಲ ಇಲ್ಲ,

193
00:17:11,900 --> 00:17:20,410
ನಾನು ಸಹ ಮಾಡಬಲ್ಲರು ಇಂಟ್ ನಾನು = 0, ಉದ್ದ = strlen (ರು).

194
00:17:20,410 --> 00:17:25,010
ಆದ್ದರಿಂದ ಈಗ ರಿಂದ ನಾನು ಸ್ಕೋಪ್ ನಿರ್ಬಂಧಿಸಲಾಗುತ್ತದೆ ನಾವು, ಸ್ವಲ್ಪ ಯೋಗ್ಯವಾಗಿದೆ

195
00:17:25,010 --> 00:17:29,150
ವೇರಿಯಬಲ್ ಉದ್ದ ಬದಲಾಗಿ ಲೂಪ್ 'ಗೆ' ಈ ಮೊದಲು ಘೋಷಿಸಿದ ಗೆ

196
00:17:29,150 --> 00:17:34,990
ಮತ್ತು ಇದು ಯಾವಾಗಲೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಮತ್ತು ಕೆಟ್ಟ ಎಂಬುದನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಕ್ಯಾಚ್ ಎಂದು

197
00:17:34,990 --> 00:17:39,410
ಅಥವಾ ಏಕೆ ಮೂಲ it's, ಕೆಟ್ಟ - ಲೂಪ್ ಫಾರ್ ಆರಂಭವಾಗುವುದು.

198
00:17:39,410 --> 00:17:43,380
ನಾನು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ನಾನು ರು ಉದ್ದವು <ಇದೆ?

199
00:17:43,380 --> 00:17:46,790
ಆದ್ದರಿಂದ ರು ಉದ್ದ, ಸಂಪೂರ್ಣ ಸಮಯದಲ್ಲಿ "ಹಲೋ" ಕೆಲಸ ಅವಕಾಶ.

200
00:17:46,790 --> 00:17:49,670
ರು ಆದ್ದರಿಂದ ಉದ್ದ, H-e-L-L-O. ಉದ್ದ 5 ಆಗಿದೆ.

201
00:17:49,670 --> 00:17:57,580
ಆದ್ದರಿಂದ ನಾನು = 0, ಉದ್ದ 5, ಆದ್ದರಿಂದ ನಾನು <5 ಅಲ್ಲ, ಲೂಪ್ ಮುಂದುವರೆಯುತ್ತದೆ ಆದ್ದರಿಂದ.

202
00:17:57,580 --> 00:18:02,750
ನಂತರ ನಾವು ಮತ್ತೆ ಹೋಗಿ. ನಾವು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ನಾನು ನಿನ್ನ ಉದ್ದ <ಇದೆ?

203
00:18:02,750 --> 00:18:08,390
ಆದ್ದರಿಂದ ನ ನಿನ್ನ ಉದ್ದ ಪರೀಕ್ಷಿಸೋಣ. ಎಚ್ ಇ ಎಲ್ L-O. ನಾನು <5 ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಮತ್ತೆ ಮುಂದುವರಿಸಲು; ಆ 5 ದ.

204
00:18:08,390 --> 00:18:13,330
ಆದ್ದರಿಂದ ನಾವು, ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ಗಾಗಿ, ನಾವು ನಿನ್ನ ಎಣಿಸುತ್ತಿದ್ದಾರೆ, ಲೆಕ್ಕ ಮಾಡಲಾಗುತ್ತದೆ

205
00:18:13,330 --> 00:18:17,380
ಯಾವಾಗಲೂ 5 ಎಂದು ವಿಶೇಷವೇನು; ಅದನ್ನು ಬದಲಾಯಿಸಲು ಹೋಗುವ ಎಂದಿಗೂ ಆಲೋಚನೆ.

206
00:18:17,380 --> 00:18:22,530
ಆದ್ದರಿಂದ ನಾವು ಮುಂದೆ ಅಪ್ 5 ನೆನಪಿಡಿ, ಈಗ ಎಲ್ಲವನ್ನೂ ಉತ್ತಮ.

207
00:18:22,530 --> 00:18:24,990
ಆದ್ದರಿಂದ ಇಡೀ ಸಾಲನ್ನು ಮೇಲೆ iterating.

208
00:18:24,990 --> 00:18:31,470
ನಾವು ಸ್ಟ್ರಿಂಗ್ ಪ್ರತಿಯೊಂದು ಪಾತ್ರಕ್ಕೆ ಏನು ಮಾಡಬೇಕೆಂದು ಬಯಸುವಿರಿ?

209
00:18:31,470 --> 00:18:38,510
[ವಿದ್ಯಾರ್ಥಿ ಮಾತನಾಡುವ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

210
00:18:38,510 --> 00:18:47,000
ಹೌದು. ಅಕ್ಷರ ಅಲ್ಲದ ವರ್ಣಮಾಲೆಯ ವೇಳೆ ಆದ್ದರಿಂದ, ನಾವು ಕೇವಲ ಅದನ್ನು ಬಿಟ್ಟು ಬಯಸುವ.

211
00:18:47,000 --> 00:18:52,300
ನಾವು ಮಾತ್ರ ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಕಾಳಜಿ ಏಕೆಂದರೆ; ನಾವು ಹಲವಾರು ಲಾಭ ಸಾಧ್ಯವಿಲ್ಲ.

212
00:18:52,300 --> 00:19:10,850
ಆದ್ದರಿಂದ ನಾವು ಹೇಗೆ ಮಾಡಬಹುದು? ನಾವು ಏನನ್ನಾದರೂ ಬಯಸಿದರೆ ನಮ್ಮ ಸ್ಥಿತಿಯಲ್ಲಿ ಆದ್ದರಿಂದ, ಆದ್ದರಿಂದ - ಇದು ವರ್ಣಮಾಲೆಯ ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ.

213
00:19:10,850 --> 00:19:14,060
ಆದ್ದರಿಂದ ನಾವು ಈ ಪರಿಶೀಲಿಸಿ?

214
00:19:14,060 --> 00:19:18,720
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಕೇವಲ ಕಾರ್ಯವನ್ನು ಉಪಯೋಗಿಸಬಹುದು ಆಲ್ಫಾ ಹೊಂದಿದೆ.

215
00:19:18,720 --> 00:19:23,160
ಈ ಎರಡೂ, ಅಥವಾ ಯಾವುದೇ ಸೇರಿಸಲಾಗಿದೆ ಎಂದು ನಂತಹ char.h ಅಥವಾ ಏನಾದರೂ ಒಳಗೊಂಡಿದೆ?

216
00:19:23,160 --> 00:19:32,710
ಆದ್ದರಿಂದ ನಾವು ರು [I] ಹೊಂದಿರುತ್ತಾರೆ, - ಆಲ್ಫಾ ಕಾರ್ಯ, ಮತ್ತು ಸ್ಪಷ್ಟ ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ ಲೆಟ್ಸ್

217
00:19:32,710 --> 00:19:40,460
ಆ ರು ಎಂಟನೇ ಪಾತ್ರ, ಸ್ಟ್ರಿಂಗ್ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ

218
00:19:40,460 --> 00:19:43,180
ರು ಎಂಟನೇ ಪಾತ್ರದ ಹಾಗೆ.

219
00:19:43,180 --> 00:19:49,280
ಇದು ಬಂಡವಾಳ ಪತ್ರ ವೇಳೆ ಈಗ, ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ವ್ಯಾಪ್ತಿಯ ಎಂದು ಹೊಂದಿದೆ ತಿಳಿದಿದೆ.

220
00:19:49,280 --> 00:19:54,370
ಮತ್ತು ವ್ಯಾಪ್ತಿ ಏನು?

221
00:19:54,370 --> 00:20:07,860
ಹೌದು. ಹಾಗಿದ್ದರೆ ರು [I] ≥ 65, ಮತ್ತು ಗಳು [I] ≤ 90, ನಾನು ಬದಲಿಗೆ ಏನು ಮಾಡಬೇಕು?

222
00:20:07,860 --> 00:20:18,470
ಹೌದು. ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಸಹ ಇದುವರೆಗೆ ಏನು ಆಫ್ ASCII ಮೌಲ್ಯಗಳನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಮಾಡಬಾರದು.

223
00:20:18,470 --> 00:20:25,640
ಸಂಖ್ಯೆಗಳು 65, 90, 97 ಮತ್ತು 102, ಅಥವಾ ಯಾವುದೇ ಇದು ನಗರದ ನೆವರ್.

224
00:20:25,640 --> 00:20:32,470
ನೀವು ಅಗತ್ಯವಿಲ್ಲ - 112 - ನೀವು ಎಲ್ಲಾ ಸಮಯದಲ್ಲಿ ಆ ತಿಳಿಯಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಅದೂ ತಪ್ಪು ಇಲ್ಲಿದೆ.

225
00:20:32,470 --> 00:20:41,940
ಕೇವಲ ಏಕ ಉದ್ಧರಣ ಪಾತ್ರಗಳು, ಏಕ ಉದ್ಧರಣ ಸ್ಥಿರಾಂಕಗಳು ಬಳಸಿ. ಆದ್ದರಿಂದ 'ಎ' ಮತ್ತು ಕಡಿಮೆ 90 'ಝಡ್' ಆಗಿದೆ

226
00:20:41,940 --> 00:20:47,930
ಮತ್ತು ಈ ಗಮನಾರ್ಹವಾಗಿ ಉತ್ತಮ - ನಾನು ಝೆಡ್ 90 ಎಂದು ನನ್ನ ತಲೆಯ ಮೇಲಿನ ಆಫ್ ತಿಳಿಯಲು ಅಸಾಧ್ಯ.

227
00:20:47,930 --> 00:20:52,690
ನಾನು 'Z' ರಾಜಧಾನಿ ಝಡ್ ಎಂದು ನನ್ನ ತಲೆಯ ಮೇಲಿನ ಆಫ್ ಗೊತ್ತು

228
00:20:52,690 --> 00:21:02,100
ಆದ್ದರಿಂದ ಎಲ್ಲಿಯವರೆಗೆ ಈ ಬಂಡವಾಳ ಝಡ್, ಅಥವಾ ನಾವು ರಾಜಧಾನಿ ನಷ್ಟಿರುತ್ತದೆ ಎಂದು, ಸಣ್ಣ ಪರಿಶೀಲಿಸಿ ಮಾಡಬಹುದು

229
00:21:02,100 --> 00:21:17,010
ಅಥವಾ ವ್ಯಾಪ್ತಿಯ ರ ವೇಳೆ ≥ 'ಒಂದು' ಮತ್ತು ≤ z.

230
00:21:17,010 --> 00:21:19,010
ಆದ್ದರಿಂದ ನಮ್ಮ ಸ್ಥಿತಿಯು.

231
00:21:19,010 --> 00:21:22,520
ಈ ವಿಷಯಗಳನ್ನು ಪುಟ್ ಅಲ್ಲಿ ಸಂಬಂಧಿಸಿದ ಶೈಲಿಯು ಬದಲಾಗುತ್ತದೆ.

232
00:21:22,520 --> 00:21:29,520
ನಾನು ಈ ರೀತಿ ಮಾಡುತ್ತೇನೆ.

233
00:21:29,520 --> 00:21:31,520
ಈಗ, ನಾವು ಏನು ಮಾಡಬೇಕೆಂದು ಬಯಸುವಿರಿ?

234
00:21:31,520 --> 00:21:39,530
ಈ ಪತ್ರ, ಒಂದು ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರ ಒಂದು ಪಾತ್ರ ಗೊತ್ತಿಲ್ಲ.

235
00:21:39,530 --> 00:21:46,270
ಆದ್ದರಿಂದ ನಾವು ಈ ಈಗ ಬಂಡವಾಳ ಪತ್ರ ಅಥವಾ ಸಣ್ಣಕ್ಷರವು ಇಲ್ಲವೇ ಎಂಬುದರ ನಡುವೆ ಪರ್ಯಾಯವಾಗಿ ಅಗತ್ಯವಿದೆ.

236
00:21:46,270 --> 00:21:48,820
ಹೇಗೆ ನಾವು ಅದು ಬಯಸುವ ಒಂದು ಟ್ರ್ಯಾಕ್ ಇಲ್ಲ?

237
00:21:48,820 --> 00:21:55,520
[ವಿದ್ಯಾರ್ಥಿ ಧ್ವನಿಗಳು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

238
00:21:55,520 --> 00:21:59,150
ಆದ್ದರಿಂದ ಹೌದು, ಆದರೆ ನನಗೆ ಪರೀಕ್ಷಿಸೋಣ.

239
00:21:59,150 --> 00:22:04,910
ಮಾಡ್ಯೂಲ್ 0-2 ಹೇಳಲಾಗುತ್ತದೆ, ಎಸೆಯಲ್ಪಡುವ ಸಲಹೆ, ಮತ್ತು ನಾನು ಒಪ್ಪುತ್ತೇನೆ.

240
00:22:04,910 --> 00:22:11,780
ಸೂಚನೆ ಹೊರತುಪಡಿಸಿ ಹಾಗೆ, ಎಂದು - ಇದು? ಹೌದು.

241
00:22:11,780 --> 00:22:18,270
ಅದು ಬಿಟ್ಟು ಒಂದು, ಆದರೆ ನಾವು ಐ ಘಟಕ 2, ಅಥವಾ ನಂತರ ನಾನು ಮಾಡ್ 2,

242
00:22:18,270 --> 00:22:22,950
ಇ ರಾಜಧಾನಿ ಮತ್ತು 'ಒಂದು' ಸಣ್ಣ ನೀವು ಗಮನಿಸಿದಿರಾ? ಆದರೆ ಅವುಗಳನ್ನು ಬೇರ್ಪಡಿಸುವ ಒಂದು ಜಾಗ ಇಲ್ಲ?

243
00:22:22,950 --> 00:22:27,150
ಆದ್ದರಿಂದ ಅವರು ಅದೇ ಅಳತೆಯ 2 ಎಂದು ನೀನು, ಆದರೆ ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ಆರ್.

244
00:22:27,150 --> 00:22:29,150
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

245
00:22:29,150 --> 00:22:34,690
ಹೌದು. ನಾವು ಕೇವಲ ಒಂದು ಎಣಿಕೆ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು.

246
00:22:34,690 --> 00:22:38,730
ನಾವು ಬಯಸಿದರೆ ನಾವು ಇಲ್ಲಿ ಆ ಇಲ್ಲ; ಒಂದು ಸಣ್ಣ ಒಡ್ಡೊಡ್ಡಾದ ಸಿಗುತ್ತವೆ

247
00:22:38,730 --> 00:22:41,300
ಲೂಪ್ ಘೋಷಣೆಗಳು ಸ್ಥಾನ; ನಾನು ಇಲ್ಲಿ ಅವಕಾಶ ಮಾಡುತ್ತೇವೆ.

248
00:22:41,300 --> 00:22:48,840
ಆದ್ದರಿಂದ ಇಂಟ್ ಎಣಿಕೆ = 0 ಆರಂಭಗೊಂಡು.

249
00:22:48,840 --> 00:22:54,070
ಆದ್ದರಿಂದ ಈಗ, ನಾವು ಹೊಂದಿದ್ದ ನಾವು ಎಷ್ಟು ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಎಣಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ.

250
00:22:54,070 --> 00:22:59,550
ನಾವು ಅನಿವಾರ್ಯವಾಗಿ ಮತ್ತೊಂದು ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರ ಕಂಡುಬಂದಿಲ್ಲ + + ರಿಂದ ಎಣಿಸಲು ನೀನು.

251
00:22:59,550 --> 00:23:09,130
ಆದರೆ, ಈಗ ನೀವು ಎಣಿಕೆ ಮಾಡ್ 2 ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು.

252
00:23:09,130 --> 00:23:12,590
ಆದ್ದರಿಂದ ಯಾವ ಎಣಿಕೆ ಮಾಡ್ 2 ವೇಳೆ? ಓಹ್. ನಾನು ಈಗ == 0 ಮಾಡುತ್ತೇನೆ.

253
00:23:12,590 --> 00:23:21,740
ನಾವು ಆ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ. ಹಾಗಾಗಿ ನಂತರ ಎಣಿಕೆ ಮಾಡ್ 2 == 0 ವೇಳೆ?

254
00:23:21,740 --> 00:23:27,830
[ವಿದ್ಯಾರ್ಥಿಗಳ ಉತ್ತರ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

255
00:23:27,830 --> 00:23:32,750
ಆದ್ದರಿಂದ ನಾವು ದೊಡ್ಡಕ್ಷರ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಬಯಸುವ.

256
00:23:32,750 --> 00:23:37,520
2 ಪ್ರಕರಣಗಳು; ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಲೋವರ್ ಕೇಸ್ 2 ಪ್ರಕರಣಗಳು ಇವೆ.

257
00:23:37,520 --> 00:23:40,990
ನಾವು ಸಣ್ಣ ಮಾಡುತ್ತೇವೆ ಆದ್ದರಿಂದ ನಾವು ಅಪ್ಪರ್ಕೇಸ್ ಅಗತ್ಯವಿದೆ.

258
00:23:40,990 --> 00:23:43,710
ಇದು ದೊಡ್ಡಕ್ಷರ ದ ನಾವು ಏನೂ ಮಾಡಬೇಕಿಲ್ಲ.

259
00:23:43,710 --> 00:23:50,760
ಆದರೆ, ಒಂದು ಮಾರ್ಗವಿಲ್ಲ - shouldn't ಹಿಮ್ಮೊಗ ಎಂದು -

260
00:23:50,760 --> 00:23:54,800
ನಾವು ಅದನ್ನು ದೊಡ್ಡಕ್ಷರ ಅಥವಾ ಸಣ್ಣ ಇಲ್ಲಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕು ಎಂದು?

261
00:23:54,800 --> 00:24:02,240
ನಾವು ಯಾವಾಗಲೂ ನಾವು ಯಾವಾಗಲೂ ದೊಡ್ಡಕ್ಷರ ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಏನು ಮಾಡಬಹುದು?

262
00:24:02,240 --> 00:24:07,830
ನಾವು ಸಣ್ಣ 'a' ಏನು ಗಮನಿಸಿ; ನಾವು ಅಪ್ಪರ್ಕೇಸ್ ಈ ಅದೇ ನಿಖರ ವಸ್ತು ಏನು ವೇಳೆ?

263
00:24:07,830 --> 00:24:11,900
ಬದಲಾವಣೆ ಅಪ್ಪರ್ಕೇಸ್ ಡಸ್, ಅಥವಾ ಮೌಲ್ಯ ಬದಲಾಗಬಹುದು?

264
00:24:11,900 --> 00:24:23,100
ಹೌದು. ಹಾಗೆ ~ 32 ANDed ಯಾವುದೇ ಬಂಡವಾಳ ಪತ್ರ bitwise ಅದೇ ದೊಡ್ಡಕ್ಷರ ಪಾತ್ರ ಎಂದು ಹೋಗುತ್ತದೆ

265
00:24:23,100 --> 00:24:29,220
ಏಕೆಂದರೆ ಯಾವುದೇ ದೊಡ್ಡಕ್ಷರ ಪಾತ್ರಕ್ಕೆ 32 ನೇ ಬಿಟ್ ಹೊಂದಿಸಿಲ್ಲ.

266
00:24:29,220 --> 00:24:40,920
ನಾವು ರು [ನಾನು], ನಾವು ಸಣ್ಣ ಅಥವಾ ದೊಡ್ಡಕ್ಷರ ಆಗಲು ಬಯಸುವ ಅಕ್ಷರ ತರಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ.

267
00:24:40,920 --> 00:24:46,890
ಇದು ಸಣ್ಣ, ಆದ್ದರಿಂದ ಒಂದು ವೇಳೆ, ಇದು ದೊಡ್ಡಕ್ಷರ ಎಂದು, ಇದು ಇನ್ನೂ ದೊಡ್ಡಕ್ಷರ, ಮತ್ತು ಅಷ್ಟೇ, ಈಗ ದೊಡ್ಡಕ್ಷರ ಹೊಂದಿದೆ.

268
00:24:46,890 --> 00:24:54,290
ನಾನು supersection ಹೀಗೆ ಹೇಳಿದ್ದಾರೆ: ನೀವು ಬಯಸಿದರೆ ನೀವು 32 ಬಳಸಬಹುದು, ಆದರೆ ನಾನು 'ಒಂದು' ಮಾಡುವುದರಿಂದ ಆದ್ಯತೆ ಒಲವು - ಎ,

269
00:24:54,290 --> 00:25:01,150
ಬದಲಿಗೆ ಕೇವಲ ಸರಳ 32, ಏಕೆಂದರೆ ಅದು ಯಾವುದೇ ಇತರ ಬಿಟ್ ಮಾಡಬಹುದು.

270
00:25:01,150 --> 00:25:03,610
32 ಬಿಟ್ ನಂತರ, ಈ ಯಾವುದೇ ಇರಬಹುದು, ಅಥವಾ ನಾವು ಸಾಕಷ್ಟು ಅಗತ್ಯವಿಲ್ಲ

271
00:25:03,610 --> 00:25:05,840
ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಪ್ರತಿನಿಧಿಸಲು ಸಂಖ್ಯೆಗಳು.

272
00:25:05,840 --> 00:25:09,110
ನೀವು 32 ಬಿಟ್ ಪಡೆಯಲು ಆದ್ದರಿಂದ, ಇದು 64 ಬಿಟ್, ಇದಕ್ಕೆ 128 ಬಿಟ್ ಆಗಿರಬಹುದು.

273
00:25:09,110 --> 00:25:13,990
ಆ ಬಿಟ್ಗಳು ಯಾವುದೇ ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಲೋವರ್ ಕೇಸ್ ನಡುವೆ ಭಿನ್ನವಾಗಿಸಿದೆ ಬಿಟ್ ಆಗಿರಬಹುದು.

274
00:25:13,990 --> 00:25:18,350
ನಾನು 32 ಬಿಟ್ ಎಂದು ತಿಳಿಯುವ ಅವಶ್ಯಕತೆ ಇರುವುದಿಲ್ಲ.

275
00:25:18,350 --> 00:25:27,130
ನಾನು ಈ 'ಒಂದು' ಬಳಸಬಹುದು - ಒಂದು ಎರಡು ನಡುವೆ ಭಿನ್ನವಾಗಿದೆ ಬಿಟ್ ಪಡೆಯಲು

276
00:25:27,130 --> 00:25:33,000
32 ಎಂಬ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ಅವಲಂಬಿಸಬೇಕಾಗಿತ್ತು ಅಗತ್ಯವಿಲ್ಲದೇ.

277
00:25:33,000 --> 00:25:38,770
ಆದ್ದರಿಂದ ಈಗ, ಬೇರೆ ಬೆಸ ಎಣಿಕೆ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ?

278
00:25:38,770 --> 00:25:43,920
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರಗಳನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

279
00:25:43,920 --> 00:25:45,920
[ವಿದ್ಯಾರ್ಥಿ] ಎಂದು ಯಾವುದು?

280
00:25:45,920 --> 00:25:49,850
ನಾನು 1 ಎರಡನೇ ಮಾಡುತ್ತಾನೆ.

281
00:25:49,850 --> 00:25:55,690
ಈಗ ನಾನು ನೀವು - ನಾನು, ಅಕ್ಷರ ಈಗ ಸಣ್ಣ ಹೊಂದಿದೆ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ

282
00:25:55,690 --> 00:26:04,140
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಅಥವಾ 32, ಮತ್ತು 32 ಅರ್ಥ 'ಒಂದು' - ಎ

283
00:26:04,140 --> 00:26:06,510
ಆದರೆ ಹಿಂದಿನ ಒಂದು ಅದೇ ತಾರ್ಕಿಕ ಮೂಲಕ ಸೂಚನೆ, ಆ ವೇಳೆ

284
00:26:06,510 --> 00:26:11,670
ಅಕ್ಷರದ ನಂತರ 32 ಮೂಲಕ ಅದನ್ನು ಲೋವರ್ಕೇಸ್ ಇಡುತ್ತದೆ ORing, ಈಗಾಗಲೇ ಸಣ್ಣ ಆಗಿತ್ತು.

285
00:26:11,670 --> 00:26:16,220
ಇದು ಮೂಲ ಪಾತ್ರ ಬದಲಾಗಿಲ್ಲ.

286
00:26:16,220 --> 00:26:19,910
ಆದರೆ ಈಗ ನಾನು, ಇದು ಸಣ್ಣ ವೇಳೆ, ಕೇವಲ ಅದರ ಬಗ್ಗೆ ಮರೆತು ", ಹೇಳುವ ತಪ್ಪಿಸಲು ಹೊಂದಿಲ್ಲ

287
00:26:19,910 --> 00:26:23,650
ಇದು ದೊಡ್ಡಕ್ಷರ ಇದ್ದರೆ, ನಂತರ ಅದನ್ನು ಬದಲಾಯಿಸಿ. "

288
00:26:23,650 --> 00:26:26,900
ಇದು ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಇದನ್ನು ಮಾಡಲು ಇಲ್ಲಿದೆ.

289
00:26:26,900 --> 00:26:33,190
[ವಿದ್ಯಾರ್ಥಿ] ಇದು 32 ಇಲ್ಲದಿದ್ದರೆ ಸಣ್ಣ ಕೆಲಸದಿಂದ ದೊಡ್ಡಕ್ಷರ ಕಳೆಯುವ ಆ ತಂತ್ರ ವುಡ್?

290
00:26:33,190 --> 00:26:35,330
ಇದು ಇದ್ದರೆ, 34 ಅಥವಾ ಏನನ್ನಾದರೂ ಇಷ್ಟ?

291
00:26:35,330 --> 00:26:41,840
ಆದ್ದರಿಂದ, ನೀವು 2 ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಎಂದು ತಿಳಿದುಕೊಳ್ಳಬೇಕು -? >> 1 ಬಿಟ್.

292
00:26:41,840 --> 00:26:49,840
ಇದು ಎಲ್ಲಿಯವರೆಗೆ ಈ ಸ್ಥಾನವನ್ನು ಕೆಳಗೆ ಬಿಟ್ಗಳು ಎಲ್ಲಾ ಒಂದೇ ಎಂದು, ಹೆಚ್ಚು 1 ಬಿಟ್ ಆಗಿರಬಹುದು.

293
00:26:49,840 --> 00:26:58,500
26 ಅಕ್ಷರಗಳು ಇವೆ, ಅಥವಾ - ನಾವು ಕನಿಷ್ಠ 26 ಪಾತ್ರಗಳು ಅಗತ್ಯವಿದೆ.

294
00:26:58,500 --> 00:27:04,590
ನಾವು ವ್ಯತ್ಯಾಸ ಪ್ರತಿನಿಧಿಸಲು ಕನಿಷ್ಠ 26 ಸಂಖ್ಯೆಗಳು ಅಗತ್ಯವಿದೆ -

295
00:27:04,590 --> 00:27:07,650
ಎ ಮತ್ತು 'ಒಂದು' ಕನಿಷ್ಠ 26 ಆಗಿರುತ್ತದೆ, ನಡುವಿನ ವ್ಯತ್ಯಾಸ

296
00:27:07,650 --> 00:27:10,760
ಅಥವಾ ಬೇರೆ ನಾವು ಎಲ್ಲಾ ರಾಜಧಾನಿ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರೂಪಿಸಲಾಗಿದೆ ಮಾಡಿರಲಿಲ್ಲ.

297
00:27:10,760 --> 00:27:18,630
ಆ, ಎ, ನಾವು 1 ಆರಂಭವಾಗುತ್ತವೆ, ಅದು ಈ ಬಿಟ್ಗಳು ಎಲ್ಲಾ ಬಳಸಲು ವಿಶೇಷವೇನು ಅರ್ಥ

298
00:27:18,630 --> 00:27:23,900
ಝಡ್ ಮೂಲಕ ಎಲ್ಲವನ್ನೂ ಪ್ರತಿನಿಧಿಸಲು ಈ ಮೊದಲ 5 ಬಿಟ್ಗಳು, ಎಲ್ಲಾ

299
00:27:23,900 --> 00:27:32,170
ಹೀಗಾಗಿ ಮುಂದಿನ ಬಿಟ್, ಅಥವಾ ಈ ಬಿಟ್ ನ, ಮುಂದಿನ ಒಂದು ಬಿಟ್ ಮತ್ತು ನಡುವೆ ವ್ಯತ್ಯಾಸ ಆಯ್ಕೆ ಎಂದು ಒಂದು 'ಒಂದು.'

300
00:27:32,170 --> 00:27:40,930
ಸಹ ಏಕೆ ಎಂದು, ASCII ಕೋಷ್ಟಕದಲ್ಲಿ, ಸಣ್ಣಕ್ಷರಗಳೆರಡರಲ್ಲೂ ಬಂಡವಾಳವನ್ನು ಅಕ್ಷರಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ 5 ಸಂಕೇತಗಳು ಇವೆ.

301
00:27:40,930 --> 00:27:49,050
ಆ ಚಿಹ್ನೆಗಳು, ಅವುಗಳ ನಡುವಿನ ಭಿನ್ನತೆಯನ್ನು 32 ತೆರೆದಿಡುತ್ತದೆ ಹೆಚ್ಚುವರಿ 5 ಕಾರಣ.

302
00:27:49,050 --> 00:27:51,840
[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ASCII ರೀತಿಯಲ್ಲಿ ವಿನ್ಯಾಸ ಮಾಡಿದ ಕಾರಣ ನಾವು ಅದನ್ನು ಸಾಧ್ಯವಾಯಿತು.

303
00:27:51,840 --> 00:27:57,280
ಹೌದು. ಆದರೆ ASCII - ವ್ಯತ್ಯಾಸವೆಂದರೆ ಈ ಬಿಟ್ಗಳು ಎರಡೂ ಆಗಿರಬಹುದು.

304
00:27:57,280 --> 00:28:12,040
ಎ 10000001 ಮತ್ತು 'ಒಂದು' 11100001 ಎಂದು, ಹಾಗೆ - ನಾನು ಏನೇ, ಮರೆಯಬೇಡಿ.

305
00:28:12,040 --> 00:28:18,100
ಎ - ಈ ವೇಳೆ ಆದರೆ, ನಾವು ಇನ್ನೂ 'ಒಂದು' ಬಳಸಬಹುದಿತ್ತು

306
00:28:18,100 --> 00:28:22,650
ಅದು ಈಗ ಮತ್ತು 'ಒಂದು' ಇನ್ನೂ ಈ 2 ಬಿಟ್ಗಳು ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಇಲ್ಲಿದೆ.

307
00:28:22,650 --> 00:28:32,240
ನಾನು 48 ಬರೆಯದ ಭಾವಿಸುತ್ತೇನೆ. ಇದು 32 + 64? ನಾನು ಎಂದು?

308
00:28:32,240 --> 00:28:40,160
ಪ್ರತಿಯೊಂದು ಅಕ್ಷರ, ಇಷ್ಟ, z ಮತ್ತು z K, K, ಇದು ಇನ್ನೂ 2 ಬಿಟ್ಗಳು ಎಂದು

309
00:28:40,160 --> 00:28:45,160
ಅವರು ಈಗಲೂ ಆ 2 ಬಿಟ್ಗಳು ಹೊರತುಪಡಿಸಿ ಸೆಟ್ ಅದೇ ನಿಖರ ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

310
00:28:45,160 --> 00:28:48,870
ಆದ್ದರಿಂದ ಎಲ್ಲಿಯವರೆಗೆ ನಾವು ASCII ಅಥವಾ ಕೆಲವು ಇತರ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ, ಯಾವಾಗಲೂ ನಿಜ ಎಂದು,

311
00:28:48,870 --> 00:28:53,050
ಸುದೀರ್ಘ ಪ್ರತಿ ಪಾತ್ರಕ್ಕೆ ವಿಭಿನ್ನ ಎಂದು ಬಿಟ್ಗಳು ಒಂದು ಸೆಟ್ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ಇಲ್ಲ ಎಂದು,

312
00:28:53,050 --> 00:28:55,050
ನಂತರ ಉತ್ತಮ ಕೆಲಸ.

313
00:28:55,050 --> 00:29:06,110
ಇದು ನಾವು ಬಹುಶಃ ಬಳಸುವ ಮೊದಲ ಒಂದು ಏಕೆಂದರೆ 32 ಸ್ಥಾಪಿಸಲಾದ ಜಸ್ಟ್. ಕೂಲ್ >>.

314
00:29:06,110 --> 00:29:14,520
ನಾನು, ಬ್ಲಾಕ್ ಒಂದೇ ಲೈನ್ ವೇಳೆ ನೀವು ನೋಡಿಯೇ ಇಲ್ಲ ಸಂದರ್ಭದಲ್ಲಿ ಆದ್ಯತೆ ಒಲವು

315
00:29:14,520 --> 00:29:24,280
ನೀವು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ; ಆದ್ದರಿಂದ ನಾನು ಈ ರೀತಿ ಆದ್ಯತೆ ಒಲವು.

316
00:29:24,280 --> 00:29:34,010
ಹಾಗೆಯೇ, ನಾವು ರು [I] + = 1 ಹದ್ದುಬಸ್ತಿನಲ್ಲಿಡಲು ಹೇಗೆ ಗೊತ್ತು?

317
00:29:34,010 --> 00:29:41,090
ನೀವು ಮಾಡಬಹುದು ರು [I] bitwise ಮತ್ತು = 32.

318
00:29:41,090 --> 00:29:46,400
ಮತ್ತು bitwise OR = 32.

319
00:29:46,400 --> 00:29:51,490
ಸಹ, ಮಾಡ್ 2 == 0 ಎಣಿಕೆ.

320
00:29:51,490 --> 00:30:00,900
ಆದ್ದರಿಂದ ನೆನಪಿಡಿ - ನಾನು ಬರೆಯಲು ಆಗುವುದಿಲ್ಲ - ಯಾವುದೇ ಶೂನ್ಯೇತರ ಮೌಲ್ಯವನ್ನು ನಿಜ, ಮತ್ತು 0 ತಪ್ಪಾಗಿದೆ.

321
00:30:00,900 --> 00:30:07,880
ಆದ್ದರಿಂದ "ಎಣಿಕೆ ಮಾಡ್ 2 ವೇಳೆ == 0" ಎಂದು ಅದೇ "ಮೋಡ್ 2 ಲೆಕ್ಕ ಅಲ್ಲ."

322
00:30:07,880 --> 00:30:11,580
ನಾನು ಬಹುಶಃ ಕೇವಲ ಲೈನ್ಸ್ ತಿರುಗಿಸಿ ವೇಳೆ ಎಣಿಕೆ ಮಾಡ್ 2 ", ಹೇಳಿರಬಹುದು

323
00:30:11,580 --> 00:30:15,350
ಅಥವಾ 1, ಬೇರೆ ಮತ್ತು 1 ಅಲ್ಲ "ಆದ್ದರಿಂದ ನಾನು ಅವಶ್ಯಕತೆ ಇಲ್ಲ" ಮಾಡಬೇಕು. "

324
00:30:15,350 --> 00:30:18,650
ಆದರೆ ಈ ರೀತಿಯಲ್ಲಿಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

325
00:30:18,650 --> 00:30:25,660
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಬೇರೆ ಏನು ಮಾಡಬಹುದು?

326
00:30:25,660 --> 00:30:29,060
ನೀವು ಬಯಸಿದರೆ ತ್ರಯಾತ್ಮಕ ಅವರನ್ನು ಒಂದುಗೂಡಿಸಲು ಸಾಧ್ಯವಾಯಿತು, ಆದರೆ ಕೇವಲ ವಿಷಯಗಳನ್ನು ಮೆಸ್ಸಿಯರ್ ಮಾಡಲು ಬಯಸುವ

327
00:30:29,060 --> 00:30:33,770
ಮತ್ತು ಓದಲು ಬಹುಶಃ ಹೆಚ್ಚು ಕಷ್ಟ, ಆದ್ದರಿಂದ ನಾವು ಹಾಗೆ ಕಾಣಿಸುತ್ತದೆ.

328
00:30:33,770 --> 00:30:37,330
ಯಾರಾದರೂ ಯಾವುದೇ ಸಲಹೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ?

329
00:30:37,330 --> 00:30:41,580
ಎಲ್ಲಾ ಸಮಸ್ಯೆಯನ್ನು ಕೇಳಿದರು ಎಂದು? ಹೌದು.

330
00:30:41,580 --> 00:30:51,070
ಆದ್ದರಿಂದ ಈ ಖಾಲಿ ಸಾಲುಗಳು ತೊಡೆದುಹಾಕಲು, ಈಗ ನಾವು ಎಫ್,% ರು ಮುದ್ರಿಸಲು ವಿಲ್ ತಂತಿಗಳ ಒಂದು ಎಂದು,

331
00:30:51,070 --> 00:30:56,620
ನಾವು, ರು F ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

332
00:30:56,620 --> 00:30:59,330
ಈಗ ಚಲಾಯಿಸಲು ಅವಕಾಶ. ನಾನು ತಪ್ಪು ಏನು ಮಾಡಿದಿರಿ?

333
00:30:59,330 --> 00:31:03,200
ಆ "ಒಂದು \ ಇಲ್ಲಿದೆ; ನಾನು N ಬಯಸುವ.

334
00:31:03,200 --> 00:31:07,840
ಸರಿ. ಈಗ ನಾವು ರನ್ ಮಾಡುತ್ತೇವೆ. ಬಹುಶಃ ನನಗೆ ಕೋಪ ಬರುತ್ತದೆ.

335
00:31:07,840 --> 00:31:11,250
Strlen string.h ರಲ್ಲಿ ಆಗಿದೆ.

336
00:31:11,250 --> 00:31:14,290
ಈ ಖಣಿಲು ಬಗ್ಗೆ ಸಂತೋಷವನ್ನು ವಿಷಯ ಆದ್ದರಿಂದ ಅದು, ಇದು ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತದೆ

337
00:31:14,290 --> 00:31:19,140
ಬದಲಿಗೆ ಕೇವಲ, ಹೇಳುತ್ತದೆ ಜಿಸಿಸಿಯ "ಹೇ, ನೀವು ಏನೋ ಮರೆತು, ನಾನು ಏನು ಗೊತ್ತಿಲ್ಲ."

338
00:31:19,140 --> 00:31:29,220
ಆದರೆ ಈ ನನ್ನ ತಿಳಿಸುವರು, "ನೀವು string.h ಸೇರಿಸಲು ಅರ್ಥ."

339
00:31:29,220 --> 00:31:32,130
ಆದ್ದರಿಂದ ನಾನು ಏನು ಕೇಳುತ್ತದೆ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಏನು ಹೇಳುತ್ತಿಲ್ಲ ನ.

340
00:31:32,130 --> 00:31:42,540
ಆದರೆ ತಮ್ಮ ಉದಾಹರಣೆಗೆ ಮಾಡುತ್ತೇನೆ, "4 ಆಡ್ ಧನ್ಯವಾದಗಳು".

341
00:31:42,540 --> 00:31:47,880
ಅದು ಸರಿ ಎಂದು ತೋರುತ್ತದೆ. ಹುರ್ರೇ.

342
00:31:47,880 --> 00:31:52,370
ನಿಮ್ಮ ಮುಖ್ಯ ಮರಳಿದ, ನಾನು ಸುಮಾರು ಅದನ್ನು ಎಂದಿಗೂ.

343
00:31:52,370 --> 00:31:57,110
ಇದು ಐಚ್ಛಿಕ ಇಲ್ಲಿದೆ. ಮತ್ತು ಮುಖ್ಯ ಇದು ಐಚ್ಛಿಕ ಇದು ಮಾತ್ರ ಕಾರ್ಯ.

344
00:31:57,110 --> 00:32:07,140
ನೀವು ಮುಖ್ಯ ಏನು ಹಿಂತಿರುಗಿ ಹೋದರೆ, ನೀವು 0 ಮರಳಬೇಕಾಗಿತ್ತು ಊಹಿಸಲಾಗಿದೆ ನ.

345
00:32:07,140 --> 00:32:13,070
ಪ್ರಶ್ನೆಗಳು?

346
00:32:13,070 --> 00:32:20,980
ಸರಿ. ಈಗ ಎರಡನೇ ಸಮಸ್ಯೆ.

347
00:32:20,980 --> 00:32:24,810
"ಸಾಗಿಸುವುದರಿಂದ 2 ಅಸ್ಥಿರ 'ಮೌಲ್ಯಗಳನ್ನು ವಿನಿಮಯ ಆ ವಾರದಲ್ಲಿ 2 ಎರಡನೇ ಉಪನ್ಯಾಸ ನೆನಪಿರಲಿ

348
00:32:24,810 --> 00:32:30,780
ಒಂದು ಕ್ರಿಯೆ (ಸ್ವಾಪ್ ಎಂದು ಸಹ) ಆ 2 ಅಸ್ಥಿರ ನಿಖರವಾಗಿ ಕನಿಷ್ಠ ಯಾವುದೇ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ 'ಪಾಯಿಂಟರ್ಸ್.' "

349
00:32:30,780 --> 00:32:37,020
ನಾವು ಅವರಿಗೆ ಸಿಗುತ್ತದೆ ರವರೆಗೆ ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ನಿರ್ಲಕ್ಷಿಸಿ.

350
00:32:37,020 --> 00:32:40,070
ನಾವು 2 ಅಸ್ಥಿರ ವಿನಿಮಯ ಬಯಸುವ; ನಾವು ಮಾಡಲು ಕ್ರಿಯೆ ಬಳಸಿ ಇಲ್ಲ.

351
00:32:40,070 --> 00:32:43,410
ನಾವು ಇನ್ನೂ ಹೇಳುತ್ತದೆ ನಂತಹ ಪ್ರಮುಖ ಅದನ್ನು ಮಾಡಲು ನೀನು.

352
00:32:43,410 --> 00:32:48,360
ಆದರೆ ಆ 2 ಅಸ್ಥಿರ ಬಳಸಲು, ನಾವು ಒಂದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಬಳಸಲು ಇಷ್ಟವಿಲ್ಲ.

353
00:32:48,360 --> 00:32:50,770
ಇದನ್ನು ಮಾಡಲು 2 ಮಾರ್ಗಗಳಿವೆ.

354
00:32:50,770 --> 00:32:56,310
ನಿಮ್ಮ ಸಾಂಪ್ರದಾಯಿಕ ಬೈನರಿ ನಿರ್ವಾಹಕರು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಬಹುದು.

355
00:32:56,310 --> 00:33:00,180
ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಅದನ್ನು ಮಾಡುವ ಒಂದು ತ್ವರಿತ ಮತ್ತು ಕೊಳಕು ರೀತಿಯಲ್ಲಿ ತಿಳಿದಿದೆಯೇ?

356
00:33:00,180 --> 00:33:07,650
ನಿಜವಾಗಿ ಚಿಂತನೆಯ ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ನಾನು ಹೊಂದಿದ್ದರೆ -

357
00:33:07,650 --> 00:33:12,130
ಅವರು ಕೇಳಿ ಹಾಗೆ ನಾನು ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿಸಲು ಮಾಡುತ್ತೇವೆ. ನಾನು 2 ಅಸ್ಥಿರ ಹಾಗಾಗಿ, ಒಂದು, ಇದು ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕ

358
00:33:12,130 --> 00:33:17,800
ಅವರು ನನಗೆ ನೀಡಿ, ಮತ್ತು ನಾನು ನೀಡಿದ ನಾನು ಮತ್ತೊಂದು ಪೂರ್ಣಾಂಕ ಇದು ಮೊತ್ತ ವೇರಿಯಬಲ್ ಬಿ, ಆ.

359
00:33:17,800 --> 00:33:22,700
ಈ 2 ಅಸ್ಥಿರ ಹಾಗಾಗಿ, ಈಗ ನಾನು ಅದನ್ನು ಸ್ವ್ಯಾಪ್ ಬಯಸುವ.

360
00:33:22,700 --> 00:33:31,550
ಸಾಂಪ್ರದಾಯಿಕ, ನಿಮ್ಮ ಸಾಮಾನ್ಯ ಬೈನರಿ ನಿರ್ವಾಹಕರು ಬಳಸುವ, ನನ್ನ ಪ್ರಕಾರ, + ಹಾಗೆ, -, ÷.

361
00:33:31,550 --> 00:33:36,630
ಅವಳಿ ಮೇಲೆ ವರ್ತಿಸುವ bitwise ನಿರ್ವಾಹಕರು ಮಾಡಿರುವುದಿಲ್ಲ.

362
00:33:36,630 --> 00:33:39,600
, + ÷, ಮತ್ತು ಎಲ್ಲಾ - ಆದ್ದರಿಂದ ಬಳಸಿ.

363
00:33:39,600 --> 00:33:52,980
ನಾವು ಏನಾದರೂ ಮಾಡುವುದರಿಂದ ಸ್ವ್ಯಾಪ್ ಎಷ್ಟೊಂದು = a + b, ಮತ್ತು ಬಿ = ಒಂದು - ಬೌ, ಒಂದು = ಒಂದು - ಬೌ.

364
00:33:52,980 --> 00:34:04,260
ಆದ್ದರಿಂದ, ವಿವೇಕ ಪರಿಶೀಲಿಸಿ, ಮತ್ತು ನಾವು ಏಕೆ ಎಂದು ಕೃತಿಗಳು ನೋಡುತ್ತಾರೆ.

365
00:34:04,260 --> 00:34:13,320
ಲೆಟ್ಸ್ ಹೇಳಲು ಒಂದು = 7, ಬೌ = 3, ನಂತರ ಬೌ 10 ಏರಲಿದೆ ಒಂದು +.

366
00:34:13,320 --> 00:34:18,820
ನಾವು ಈಗ = 10 ಹೊಂದಿಸುವಾಗ ನೀವು ಮತ್ತು ನಾವು ಬೌ = ಒಂದು ಮಾಡುತ್ತಿರುವುದು - ಬೌ.

367
00:34:18,820 --> 00:34:30,250
ನಾವು ಮಾಡುತ್ತಿರುವುದು ಬೌ = ಒಂದು - ಬೌ, 7 ಎಂದು ಹೋಗುವ ಇದು, ಮತ್ತು ಬಿ = ಒಂದು - ಬೌ ಮತ್ತೆ,

368
00:34:30,250 --> 00:34:38,650
ಅಥವಾ = ಒಂದು - ಬೌ. 7 3 ಇದು - 10 ಎಂದು ಹೋಗುವ ಇದು.

369
00:34:38,650 --> 00:34:44,850
ಈಗ, ಸರಿಯಾಗಿ, 'ಒಂದು' ಬಿ 3, 7, ಮತ್ತು ಈಗ ಬೌ 7 ಮತ್ತು 'ಒಂದು' 3.

370
00:34:44,850 --> 00:34:48,679
ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಅರ್ಥವಿಲ್ಲ; 'ಒಂದು' 2 ಸಂಖ್ಯೆಗಳ ಸಂಯೋಜನೆಯಾಗಿದೆ.

371
00:34:48,679 --> 00:34:53,000
ಈ ಹಂತದಲ್ಲಿ, 'ಒಂದು' ಸಂಯೋಜನೆ, ಮತ್ತು ನಂತರ ನಾವು ಮೂಲ ಬೌ ಔಟ್ ಕಳೆದಾಗ ನೀವು

372
00:34:53,000 --> 00:34:56,860
ನಂತರ ನಾವು ಮೂಲ ಆಗಿತ್ತು ಏನೆಂದು ಕಳೆದಾಗ ನೀವು 'ಒಂದು.'

373
00:34:56,860 --> 00:35:01,150
ಆದರೆ ಈ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

374
00:35:01,150 --> 00:35:08,880
ಈ ನೋಡಲು, ಅವರ ವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಗಣಿಸೋಣ; ಆದ್ದರಿಂದ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ 32 ಬಿಟ್ಗಳು ಮಾಹಿತಿ ಪೂರ್ಣಾಂಕಗಳ ಭಾವಿಸುತ್ತೇನೆ.

375
00:35:08,880 --> 00:35:13,050
ಏಕೈಕ 4 ಬಿಟ್ಗಳು ರೀತಿಯಲ್ಲಿ ಆ ಕೆಲಸ ಮಾಡೋಣ.

376
00:35:13,050 --> 00:35:15,450
ಆಶಾದಾಯಕವಾಗಿ ನಾನು ಈಗ ಒಂದು ಉತ್ತಮ ಉದಾಹರಣೆ ಮಂದಿ.

377
00:35:15,450 --> 00:35:18,680
ಆದ್ದರಿಂದ, ನಾನು ತಿಳಿದಿರುವ, ಈ ಸುಲಭ ಎಂದು.

378
00:35:18,680 --> 00:35:26,720
ಲೆಟ್ಸ್ ನಮ್ಮ 2 ಸಂಖ್ಯೆಗಳು 1111, ಮತ್ತು 1111 ಹೇಳುವರು; ಇದೀಗ ಅವಳಿ ಮಾಡುತ್ತೇವೆ ಆದ್ದರಿಂದ.

379
00:35:26,720 --> 00:35:34,630
ನಿಜವಾದ ದಶಮಾಂಶಗಳು ರಲ್ಲಿ, ನೀವು ಆ ರೀತಿ ಯೋಚಿಸುವುದು ಬಯಸಿದರೆ, ಒಂದು = 15 ಮತ್ತು ಬಿ = 15.

380
00:35:34,630 --> 00:35:37,630
ಮತ್ತು ನಾವು ಅವರನ್ನು ಸ್ವ್ಯಾಪ್ ನಂತರ ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು - ಅವರು, ಅದೇ ಸಂಖ್ಯೆಗಳು ಎಂದು ಇಲ್ಲ

381
00:35:37,630 --> 00:35:41,140
ಆದರೆ ನಾನು ಈ ರೀತಿ ಮಾಡಿದರು.

382
00:35:41,140 --> 00:35:47,100
ಲೆಟ್ಸ್ ಅದೇ ಸಂಖ್ಯೆಗಳನ್ನು ಅವುಗಳನ್ನು ಮಾಡಲು. 1111 ಮತ್ತು 0001 ಏನು ನೋಡೋಣ.

383
00:35:47,100 --> 00:35:51,860
ಆದ್ದರಿಂದ ಒಂದು = 15 ಮತ್ತು ಬಿ = 1.

384
00:35:51,860 --> 00:35:57,670
ನಾವು ಅವುಗಳನ್ನು ಸ್ವ್ಯಾಪ್ ನಂತರ, ನಾವು 'ಒಂದು' 1 ಎಂದು ಮತ್ತು ಬಿ 15 ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು.

385
00:35:57,670 --> 00:36:01,780
ಆದ್ದರಿಂದ ನಮ್ಮ ಮೊದಲ ಹಂತದ ಒಂದು = a + b.

386
00:36:01,780 --> 00:36:08,770
0001 ಎಂಬುದು ನಮ್ಮ ಸಂಖ್ಯೆಗಳು ಕೇವಲ 4 ಬಿಟ್ಗಳು ವಿಶಾಲ, ಆದ್ದರಿಂದ 'ಒಂದು,' 1111, ಇದು + b,

387
00:36:08,770 --> 00:36:16,780
10000 ಅಷ್ಟೇ ಆಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತಿದೆ ಹೋಗುವ, ಆದರೆ ಕೇವಲ 4 ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

388
00:36:16,780 --> 00:36:22,540
ಈಗ ಒಂದು = 0.

389
00:36:22,540 --> 00:36:34,080
ಬೌ - - ವಾಸ್ತವವಾಗಿ, ಈ ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ ಕೆಲಸ ಮತ್ತು ಈಗ ನಾವು ಬೌ = ಒಂದು ಸೆಟ್ ಬಯಸುವ.

390
00:36:34,080 --> 00:36:39,630
ಒಂದು = ಒಂದು - ಬೌ - ಈ ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ ಕೆಲಸ ಎಂದು ನೋಡೋಣ.

391
00:36:39,630 --> 00:36:53,720
ಆದ್ದರಿಂದ ಬೌ = 0 - ನಂತರ ಇನ್ನೂ 15 ಅದು 1, ಮತ್ತು ಒಂದು = ಒಂದು - ಬೌ, ಇದು 1 ಎಂದು.

392
00:36:53,720 --> 00:36:56,210
ಬಹುಶಃ ಈ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

393
00:36:56,210 --> 00:36:59,020
ಇದು ಸಾಮಾನ್ಯ ಬಳಸಿಕೊಂಡು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ ಒಂದು ಕಾರಣಗಳಿವೆ ಹಾಗೆ ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

394
00:36:59,020 --> 00:37:06,400
ಸರಿ, ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ ಬೈನರಿ ಕಾರ್ಯಾಚರಣೆಗಳು ಕೆಲಸ ಎಂಬುದನ್ನು ಊಹೆ ಕೆಲಸ,

395
00:37:06,400 --> 00:37:15,040
ಮತ್ತು ನಾನು ನೋಡುತ್ತೇವೆ - ನಾನು ನಿಜವಾದ ವೇಳೆ ನೋಡಲು Google ಕಾಣಿಸುತ್ತದೆ.

396
00:37:15,040 --> 00:37:23,490
ನಾವು bitwise ನಿರ್ವಾಹಕರು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಬಯಸುವ, ಮತ್ತು ಇಲ್ಲಿ ಸುಳಿವು XOR ಹೊಂದಿದೆ.

397
00:37:23,490 --> 00:37:28,780
ಆದ್ದರಿಂದ, ನೀವು ಇನ್ನೂ ನೋಡಿಲ್ಲ ವೇಳೆ XOR (^) ಪರಿಚಯಿಸುತ್ತಿದೆ.

398
00:37:28,780 --> 00:37:34,610
ಮತ್ತೆ,, ಎ bitwise ಆಯೋಜಕರು ಇದು ಬಿಟ್ ಮತ್ತು it's ಅದಕ್ಕೆ ಬಿಟ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದ್ದರಿಂದ -

399
00:37:34,610 --> 00:37:39,910
ನೀವು ಬಿಟ್ಗಳು 0 ಮತ್ತು 1 ಹೊಂದಿದ್ದರೆ, ಈ 1 ಆಗಿರುತ್ತದೆ.

400
00:37:39,910 --> 00:37:45,230
ನೀವು ಬಿಟ್ಗಳು 1 ಮತ್ತು 0 ಇದ್ದರೆ, ಇದು 1 ಆಗಬಹುದು, ನೀವು, 0 ಇರುವಿರಿ ಬಿಟ್ಗಳು 0 ಮತ್ತು 0 ಹೊಂದಿವೆ

401
00:37:45,230 --> 00:37:47,640
ಮತ್ತು ನೀವು ಬಿಟ್ಗಳು 1 ಮತ್ತು 1 ಹೊಂದಿದ್ದರೆ ಅದು 0 ಇರುವಿರಿ.

402
00:37:47,640 --> 00:37:56,180
ಆದ್ದರಿಂದ ಹಾಗೆ ಅಥವಾ. ಬಿಟ್ಗಳು ಎರಡೂ ನಿಜವಾದ, ಅದು 1, ಆದರೆ OR ಭಿನ್ನವಾಗಿ, ಇದು ನಿಜವಾದ ಎಂದು ಎರಡೂ ಬಿಟ್ಗಳು ಇರುವಂತಿಲ್ಲ.

403
00:37:56,180 --> 00:37:59,320
ಅಥವ 1 ಎಂದು, XOR ಈ 0 ಹೊಂದಿರುತ್ತದೆ.

404
00:37:59,320 --> 00:38:02,250
ನಾವು ಇಲ್ಲಿ XOR ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು.

405
00:38:02,250 --> 00:38:09,960
ಒಂದು ನಿಮಿಷ ಇದು ಬಗ್ಗೆ ಥಿಂಕ್; ನಾನು Google ಪಡೆಯಲಿದ್ದೇನೆ.

406
00:38:09,960 --> 00:38:16,230
ಅಲ್ಲದೆ, ನೀವು ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ; ನಾನು XOR ಸ್ವಾಪ್ ಅಲ್ಗಾರಿದಮ್ ಪುಟ ಪ್ರಸ್ತುತ ಆಗಿದ್ದೇನೆ.

407
00:38:16,230 --> 00:38:21,340
ನಾನು can't ಏಕೆ ಆಶಾದಾಯಕವಾಗಿ ಈ ವಿವರಿಸುತ್ತದೆ -

408
00:38:21,340 --> 00:38:34,190
ಈ ನಿಖರವಾಗಿ ನಾವು ಆ ಕ್ರಮಾವಳಿ.

409
00:38:34,190 --> 00:38:37,330
ನಾನು ಇನ್ನೂ ಏಕೆ ಕಾಣುವುದಿಲ್ಲ - ನಾನು ಒಂದು ಕೆಟ್ಟ ಉದಾಹರಣೆ ಆಯ್ಕೆ ಹೊಂದಿರಬೇಕು,

410
00:38:37,330 --> 00:38:44,940
ಆದರೆ 'ಒಂದು' ಈಗ 'ಒಂದು' 0, 5 ಬಿಟ್ಗಳ ಪಡೆದ ನಂತರ, 0 ಆಗಲು ಸಂಭವಿಸಿದ ಅಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ,

411
00:38:44,940 --> 00:38:48,730
ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಏನು "ಪೂರ್ಣಾಂಕ ಓವರ್."

412
00:38:48,730 --> 00:38:54,370
ವಿಕಿಪೀಡಿಯ ಪ್ರಕಾರ, "XOR ಸ್ವಾಪ್ ಭಿನ್ನವಾಗಿ, ಈ ವ್ಯತ್ಯಾಸವು ಕೆಲವು ವಿಧಾನಗಳನ್ನು ಬಳಸುವ ಅಗತ್ಯವಿದೆ

413
00:38:54,370 --> 00:38:59,780
x + y ಒಂದು ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ ಕಾರಣವಾಗಬಹುದು ಎಂಬುದನ್ನು ಖಾತರಿ ಮಾಡಲು. "

414
00:38:59,780 --> 00:39:08,350
ಈ ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ, ಆದರೆ ನಾನು ಏನೋ ಮಾಡಿದರು; ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ.

415
00:39:08,350 --> 00:39:10,520
ನಾನು ಖಚಿತವಿಲ್ಲ. ನಾನು ಇನ್ನೊಂದು ಒಂದು ಬರಲು ಪ್ರಯತ್ನಿಸಿ ಮಾಡುತ್ತೇವೆ.

416
00:39:10,520 --> 00:39:13,640
ನೀವು ಒಂದು ಸಂಖ್ಯೆಯ ಹಾಕಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಸಂದರ್ಭದಲ್ಲಿ [ವಿದ್ಯಾರ್ಥಿ] ವೆಲ್, ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ ಅಲ್ಲ

417
00:39:13,640 --> 00:39:16,640
ನೀವು ಹಂಚಿಕೆ ಮಾಡಿದ್ದಾರೆ ಬಿಟ್ಗಳು ಪ್ರಮಾಣವನ್ನು ದೊಡ್ಡದಾಗಿದೆ?

418
00:39:16,640 --> 00:39:23,730
ಹೌದು. ನಾವು 4 ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. That's - ನಾವು 4 ಬಿಟ್ಗಳು ಹೊಂದಿತ್ತು, ನಾವು ನಂತರ ಇದನ್ನು 1 ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿ, ಆದ್ದರಿಂದ ನಾವು 5 ಬಿಟ್ಗಳು ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು.

419
00:39:23,730 --> 00:39:26,690
ಆದರೆ ಐದನೇ ಬಿಟ್ ಕೇವಲ ಹೌದು, ಕತ್ತರಿಸಿ ಮುಟ್ಟುತ್ತದೆ.

420
00:39:26,690 --> 00:39:28,970
ಇದು ವಾಸ್ತವವಾಗಿ ಅಧಿಕಬಲ -

421
00:39:28,970 --> 00:39:33,010
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ದೋಷ ದೂರ ಅಥವಾ ಆ ಮಾಡುತ್ತದೆ ಡಸ್ - ಒಂದು ದೋಷ ಎಸೆಯುತ್ತಾರೆ?

422
00:39:33,010 --> 00:39:40,720
ನಂ ಆದ್ದರಿಂದ ಯಾವುದೇ ದೋಷ ಇಲ್ಲ. ನೀವು ಅಸೆಂಬ್ಲಿ ಮಟ್ಟಕ್ಕೆ ಪಡೆದಾಗ, ವಿಶೇಷ ಬಿಟ್

423
00:39:40,720 --> 00:39:47,020
ಎಲ್ಲೋ ಒಂದು ಉಕ್ಕಿ ಅವರು ಹೇಳಿದರು, ಆದರೆ ಸಿ ನಿಮ್ಮ ರೀತಿಯ ಕೇವಲ ವ್ಯವಹರಿಸುವುದಿಲ್ಲ ಹೊಂದಿಸಲಾಗಿದೆ.

424
00:39:47,020 --> 00:39:55,160
ನೀವು ಸಿ ವಿಶೇಷ ಜೋಡಣಾ ಸೂಚನೆಗಳನ್ನು ಬಳಸಿ ನೀವು ವಾಸ್ತವವಾಗಿ ನಿಭಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

425
00:39:55,160 --> 00:39:58,110
ನ XOR ಸ್ವಾಪ್ ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡೋಣ.

426
00:39:58,110 --> 00:40:02,220
ಮತ್ತು ನಾನು ವಿಕಿಪೀಡಿಯಾ ಲೇಖನದಲ್ಲಿ ಹೇಳುವ ಮಾಡಲಾಗಿದೆ ಸಂಶಯವಿಲ್ಲ -

427
00:40:02,220 --> 00:40:07,310
ಆದ್ದರಿಂದ ಇದು ಮಾಡ್ಯುಲರ್ ಅಂಕಗಣಿತ ಬೆಳೆದರು, ಆದ್ದರಿಂದ ನಾನು ಮಾಡ್ಯುಲರ್ ಅಂಕಗಣಿತ ಮಾಡುವುದರಿಂದ, ಸಿದ್ಧಾಂತದಲ್ಲಿ, ನಾನು ಭಾವಿಸುತ್ತೇನೆ

428
00:40:07,310 --> 00:40:11,160
1 ಮತ್ತೆ 15 - ನಾನು 0 ಎಂದು ಹೇಳಿದರು.

429
00:40:11,160 --> 00:40:15,410
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಅಧಿಕಬಲ - 1 = 15 - 0 ಮಾಡುವ ಒಂದು ಸಾಮಾನ್ಯ ಪ್ರೊಸೆಸರ್ ಮೇಲೆ.

430
00:40:15,410 --> 00:40:20,430
ನಾವು 0 ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ರಿಂದ, ನಾವು 1 ಕಳೆಯಿರಿ, ಆದ್ದರಿಂದ ಅದು ಕೇವಲ ಸುಮಾರು 1111 ಹಿಂದಕ್ಕೆ ಸುತ್ತಿ.

431
00:40:20,430 --> 00:40:28,930
ಆದ್ದರಿಂದ ಈ ಅಲ್ಗಾರಿದಮ್ ವಾಸ್ತವವಾಗಿ ಕೆಲಸ, ಒಂದು + b ಒಂದು ಇರಬಹುದು - ಬೌ, ಬೌ - ಒಂದು; ಚೆನ್ನಾಗಿರುತ್ತದೆ ಎಂದು.

432
00:40:28,930 --> 00:40:34,030
ಆದರೆ ಹಾಗೆ ಮಾಡಬೇಡಿ ಕೆಲವು ಸಂಸ್ಕಾರಕಗಳು, ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಆ ನಿರ್ದಿಷ್ಟ ಬಿಡಿಗಳ ಉತ್ತಮವಾದ ನೆರವೇರಿಸಲಾಯಿತು.

433
00:40:34,030 --> 00:40:39,880
XOR ಸ್ವಾಪ್ ಯಾವುದೇ ಪ್ರೊಸೆಸರ್ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ. ಸರಿ.

434
00:40:39,880 --> 00:40:42,280
ಕಲ್ಪನೆಯನ್ನು ಆದರೂ, ಒಂದೇ ಆಗಿರಬೇಕು ಎಂದು ಆಗಿದೆ.

435
00:40:42,280 --> 00:40:50,120
ಅಲ್ಲಿ ನಾವು, ಹೇಗಾದರೂ ಅಸ್ಥಿರಗಳ 1 ಆಗಿ ಎರಡೂ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು XOR ಬಳಸುತ್ತಿರುವಿರಿ

436
00:40:50,120 --> 00:40:54,120
ತದನಂತರ ಮತ್ತೆ ಮಾಲಿಕ ಅಸ್ಥಿರಗಳ ಮಾಹಿತಿಯನ್ನು ಎಳೆಯಿರಿ.

437
00:40:54,120 --> 00:41:04,330
ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಕಲ್ಪನೆಗಳನ್ನು / ಉತ್ತರವನ್ನು ಹೊಂದಿದೆ?

438
00:41:04,330 --> 00:41:14,540
[ವಿದ್ಯಾರ್ಥಿ ಉತ್ತರವನ್ನು, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

439
00:41:14,540 --> 00:41:22,220
ಆದ್ದರಿಂದ ಈ ಕೆಲಸ ಮಾಡಬೇಕು, ಮತ್ತು, XOR ಪರಿವರ್ತನೀಯ ಹೊಂದಿದೆ.

440
00:41:22,220 --> 00:41:27,620
ಯಾವ ಕ್ರಮದಲ್ಲಿ ಈ 2 ಸಂಖ್ಯೆಗಳು ಅಪ್ ಇಲ್ಲಿ ಎಂದು ಸಂಭವಿಸಿ

441
00:41:27,620 --> 00:41:30,100
ಈ ಪರಿಣಾಮವಾಗಿ ಒಂದೇ ಎಂದು ಹೋಗುತ್ತದೆ.

442
00:41:30,100 --> 00:41:35,800
ಆದ್ದರಿಂದ ಒಂದು ^ ಬೌ ಹೊಂದಿದೆ ಬೌ ^ ಒಂದು.

443
00:41:35,800 --> 00:41:51,860
ನೀವು ಈ ಲಿಖಿತ ವೀಕ್ಷಿಸಬಹುದು ಒಂದು ^ = ಬೌ, ಬೌ ^ = ಒಂದು, ಒಂದು ^ = ಬೌ ಮತ್ತೆ.

444
00:41:51,860 --> 00:42:00,200
ಈ ಹಕ್ಕು, ಮತ್ತು ಈ ಕೃತಿಗಳು, ಬಿಟ್ಸ್ ನಗರದ ಎಂಬುದನ್ನು.

445
00:42:00,200 --> 00:42:10,400
ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯಲ್ಲಿ ಬಳಸಿಕೊಂಡು, 11001 ಮತ್ತು 01100 ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ.

446
00:42:10,400 --> 00:42:12,790
ಆದ್ದರಿಂದ ಈ 'ಒಂದು' ಆಗಿದೆ; ಈ ಬೌ ಹೊಂದಿದೆ.

447
00:42:12,790 --> 00:42:15,540
ಆದ್ದರಿಂದ ಒಂದು ^ = ಬೌ.

448
00:42:15,540 --> 00:42:22,380
ಈ 2 ವಸ್ತುಗಳ XOR ಗೆ 'ಒಂದು' = ಸಿದ್ಧಪಡಿಸುತ್ತಿರುವಂತೆ ನೀನು.

449
00:42:22,380 --> 00:42:32,920
1 ಆದ್ದರಿಂದ ^ 0 1; 1 ^ 1 0; 0 ^ 1 1, ಮತ್ತು 0 ^ 0 0; 1 ^ 0 1.

450
00:42:32,920 --> 00:42:37,380
ನೀವು ದಶಮಾಂಶ ಸಂಖ್ಯೆ ನೋಡಿದರೆ ಆದ್ದರಿಂದ 'ಒಂದು', ಇದು ವಿಶೇಷವೇನು -

451
00:42:37,380 --> 00:42:41,160
ನೀವು ', ಒಂದು' ಹೆಚ್ಚು ಮೂಲ 'ಒಂದು' ಮತ್ತು ಹೊಸ ನಡುವಿನ ಸಂಬಂಧದ ನೋಡಲು ಹೋಗುತ್ತಿಲ್ಲ

452
00:42:41,160 --> 00:42:45,600
ಆದರೆ ಬಿಟ್ಗಳು ನೋಡಿ, 'ಒಂದು' ಮಾಹಿತಿಯನ್ನು ಒಂದು ರಂಧ್ರದ ತರಹ ಈಗ

453
00:42:45,600 --> 00:42:49,970
ಮೂಲ 'ಒಂದು' ಮತ್ತು ಮೂಲ ಬೌ ಎರಡೂ.

454
00:42:49,970 --> 00:42:57,930
ನಾವು ಬೌ ^ ಒಂದು, ನಾವು ಮೂಲ ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಿ 'ಒಂದು.' ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ

455
00:42:57,930 --> 00:43:08,910
ನಾವು ತೆಗೆದುಕೊಂಡು ಮೂಲ 'ಒಂದು' ^ ಹೊಸ 'ಒಂದು,' ನಾವು ಮೂಲ ಬೌ ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ನೋಡಿ.

456
00:43:08,910 --> 00:43:18,380
ಆದ್ದರಿಂದ (ಒಂದು ^ ಬಿ) ^ ಬೌ = ಮೂಲ 'ಒಂದು.'

457
00:43:18,380 --> 00:43:27,910
ಮತ್ತು (ಒಂದು ^ ಬಿ) ^ ಒಂದು = ಮೂಲ ಬೌ.

458
00:43:27,910 --> 00:43:37,010
ಇಲ್ಲ - ಈ ಏನು XOR ಆಗಿದೆ ನೋಡಿದ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಯಾವಾಗಲೂ 0 ಆಗಿದೆ.

459
00:43:37,010 --> 00:43:45,020
1101 ಆದ್ದರಿಂದ ^ 1101, ಎಲ್ಲಾ ಬಿಟ್ಗಳು ಅದೇ ಮುಂದುವರೆಸುತ್ತೇವೆ.

460
00:43:45,020 --> 00:43:47,920
ಆದ್ದರಿಂದ 1 0 ಮತ್ತು 1 ಎಂದು ಅಲ್ಲಿ ಒಂದು ಪ್ರಕರಣದಲ್ಲಿ ಇರುವಂತೆ ಹೋಗುವ ಎಂದಿಗೂ.

461
00:43:47,920 --> 00:43:51,080
ಈ 0000 ಆಗಿದೆ.

462
00:43:51,080 --> 00:43:57,240
ಈ ಅದೇ. (ಒಂದು ^ ಬಿ) ^ ಬೌ ನಂತಹ ಒಂದು ^ (ಬೌ ^ ಬಿ).

463
00:43:57,240 --> 00:44:03,680
(ಬೌ ^ ಬಿ) 0 ಎಂದು ಹೋಗುತ್ತದೆ; ಎಲ್ಲಾ ಬಿಟ್ಗಳು 0 ಕಾರಣ ಒಂದು ^ 0 ಕೇವಲ ', ಒಂದು' ಎಂದು ಹೋಗುತ್ತದೆ.

464
00:44:03,680 --> 00:44:08,050
ಆದ್ದರಿಂದ 'ಒಂದು' ಮೂಲತಃ 1 ಆಗಿತ್ತು ಅಲ್ಲಿ ಮುಂದುವರೆಸುತ್ತೇವೆ ಎಂದು ಮಾತ್ರ - ಬಿಡಿಗಳ ಹೊಂದಿತ್ತು.

465
00:44:08,050 --> 00:44:12,070
ಇಲ್ಲಿ ಒಂದೇ ಕಲ್ಪನೆ; ನಾನು ಇದು ಪರಿವರ್ತನೀಯ ಪ್ರೆಟ್ಟಿ ಸಂದೇಹವಿಲ್ಲ.

466
00:44:12,070 --> 00:44:17,590
ಹೌದು. ನಾನು ಪರಿವರ್ತನೀಯ ಎಂದು ಮೊದಲು ಹೇಳಲು ಹೋಗಲಿಲ್ಲ.

467
00:44:17,590 --> 00:44:24,680
^ 'ಒಂದು,' ಮತ್ತು ಸಹವರ್ತನೀಯ, ಆದ್ದರಿಂದ ಈಗ (ಬೌ ^ ಒಂದು) ^ ಒಂದು.

468
00:44:24,680 --> 00:44:28,970
ಮತ್ತು ನಾವು ಮಾಡಬಹುದು ಬೌ ^ (ಒಂದು ^ ಒಂದು).

469
00:44:28,970 --> 00:44:31,540
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾವು ಮೂಲ ಬೌ ಪಡೆಯಿರಿ.

470
00:44:31,540 --> 00:44:37,120
ಆದ್ದರಿಂದ 'ಒಂದು' ಈಗ ಒಟ್ಟಿಗೆ 'ಒಂದು' ಮತ್ತು ಬಿ ಸಂಯೋಜನೆಯಾಗಿದೆ.

471
00:44:37,120 --> 00:44:49,660
ನಮ್ಮ ಹೊಸ ಕಾಂಬೊ ಬಳಸಿಕೊಂಡು 'ಒಂದು' ನಾವು ಬೌ = ಕಾಂಬೊ 'ಒಂದು' ^ ಮೂಲ ಬೌ, ನಾವು ಮೂಲ ಪಡೆಯಲು 'ಒಂದು.'

472
00:44:49,660 --> 00:45:05,170
ಮತ್ತು ಈಗ = ಕಾಂಬೊ 'ಒಂದು' ^ ಹೊಸ ಬೌ, ಮೂಲ ಇದು - ಅಥವಾ 'ಒಂದು' ಅಥವಾ ಬೌ ಇದ್ದ ಈಗ.

473
00:45:05,170 --> 00:45:13,620
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇಲ್ಲಿ ಆ ಡೌನ್. ಈ = ಬೌ, ಹಳೆಯ ಬೌ ಹೊಂದಿದೆ.

474
00:45:13,620 --> 00:45:16,550
ಈಗ ಎಲ್ಲವೂ ಬದಲಾಗಿ ಸಲುವಾಗಿ ಬ್ಯಾಕ್.

475
00:45:16,550 --> 00:45:22,960
ನಾವು ವಾಸ್ತವವಾಗಿ ಬಿಟ್ಗಳು ನೋಡಿವೆ ವೇಳೆ, ಬೌ = ಒಂದು ^ ಬೌ, ಈ 2 XOR ಹಾಕುತ್ತದೆ

476
00:45:22,960 --> 00:45:33,920
ಮತ್ತು ಉತ್ತರವನ್ನು ಈ ಎಂದು ಹೋಗುವುದು, ಮತ್ತು ನಂತರ ಒಂದು = ಒಂದು ^ ಬೌ ಈ 2 XORing ಮತ್ತು ಉತ್ತರವನ್ನು ಇದು ಇದೆ. ಇದೆ

477
00:45:33,920 --> 00:45:41,090
ಪ್ರಶ್ನೆಗಳು? ಸರಿ. ಕಳೆದ ಒಂದು ರೀತಿಯಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚು ಕಷ್ಟ.

478
00:45:41,090 --> 00:45:43,180
[ವಿದ್ಯಾರ್ಥಿ] ಅವರು ಅದರ ಬಗ್ಗೆ ಒಂದು ಪ್ರಶ್ನೆ ನಾನು ಭಾವಿಸುತ್ತೇನೆ. >> ಓಹ್, ಕ್ಷಮಿಸಿ.

479
00:45:43,180 --> 00:45:49,380
[ವಿದ್ಯಾರ್ಥಿ] ವಾಸ್ತವವಾಗಿ ಏನು ವೇಗವಾಗಿ ಈಸ್? ಈ XOR ಬಳಸಲು ನೀವು ಒಂದು ಹೊಸ ವೇರಿಯಬಲ್ ಘೋಷಿಸಿದ ವೇಳೆ, ಅಥವಾ ಅದು?

480
00:45:49,380 --> 00:45:55,190
ಆದ್ದರಿಂದ ಹೊಸ ವೇರಿಯಬಲ್ ಘೋಷಿಸುವ ಅಥವಾ ವಿನಿಮಯ XOR ಬಳಸಿಕೊಂಡು, ವಾಸ್ತವವಾಗಿ ವೇಗವಾಗಿ ಏನು?

481
00:45:55,190 --> 00:45:59,600
ಉತ್ತರ, ಸಂಭಾವ್ಯವಾಗಿ, ತಾತ್ಕಾಲಿಕ ಅಸ್ಥಿರವಾಗಿದೆ.

482
00:45:59,600 --> 00:46:05,780
ಆದ್ದರಿಂದ ವಿಧಾನಸಭೆ ಮಟ್ಟದಲ್ಲಿ - ಅದನ್ನು ಸಂಕಲಿಸಿದ ಒಮ್ಮೆ ಕಾರಣ ಎಂದು

483
00:46:05,780 --> 00:46:12,320
ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಅಥವಾ ಯಾವುದೇ ತಾತ್ಕಾಲಿಕ ಅಸ್ಥಿರ ಅಥವಾ ಈ ವಿಷಯದ ಯಾವುದೇ ಬೇರೆ ವಿಷಯಗಳೇ ಇಲ್ಲ ಇಲ್ಲ.

484
00:46:12,320 --> 00:46:16,060
ಅವರು ಹಾಗೆ ನೀವು - ಮೆಮೊರಿ ಇಲ್ಲ, ಮತ್ತು ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಇವೆ.

485
00:46:16,060 --> 00:46:20,920
ವಿಷಯಗಳನ್ನು ಸಕ್ರಿಯವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ ಅಲ್ಲಿ ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಇವೆ.

486
00:46:20,920 --> 00:46:24,750
ನೀವು ನೆನಪಿಗಾಗಿ 2 ವಿಷಯಗಳನ್ನು ಸೇರಿಸುವುದು ಬೇಡ; ನೀವು ನೊಂದಣಿಗಳನ್ನು 2 ವಿಷಯಗಳನ್ನು ಸೇರಿಸಿ.

487
00:46:24,750 --> 00:46:28,160
ಮತ್ತು ನೀವು, ನಂತರ ಅವುಗಳನ್ನು ಸೇರಿಸಲು ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಆಗಿ ಮೆಮೊರಿ ವಸ್ತುಗಳ ತರಲು

488
00:46:28,160 --> 00:46:33,180
ತದನಂತರ ನೀವು ಮೆಮೊರಿ ಅವುಗಳನ್ನು ಮುಂದೂಡಲಾಗಿದೆ ಇರಬಹುದು, ಆದರೆ ಎಲ್ಲಾ ಕ್ರಮ ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಸಂಭವಿಸುತ್ತದೆ.

489
00:46:33,180 --> 00:46:38,750
ಆದ್ದರಿಂದ ನೀವು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಅಪ್ರೋಚ್ನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಏನಾಗುತ್ತದೆ ಆಗಿದೆ

490
00:46:38,750 --> 00:46:42,810
ಈ 2 ಸಂಖ್ಯೆಗಳು ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಈಗಾಗಲೇ.

491
00:46:42,810 --> 00:46:46,570
ತದನಂತರ ಆ ನೀವು ಬದಲಾಯಿಸಿಕೊಳ್ಳಬಹುದು ಮಾಡಿದ ನಂತರ, ಮೇಲೆ,

492
00:46:46,570 --> 00:46:51,540
ಇದು ಇತರ ರಿಜಿಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ.

493
00:46:51,540 --> 00:46:56,510
ನೀವು ಬೌ ಬಳಸುತ್ತಿದ್ದರು ಎನಿವೇರ್, ಇದು ಈಗಾಗಲೇ ಸಂಗ್ರಹಿಸಲು ಎಂದು ರಿಜಿಸ್ಟರ್ ಬಳಸಿ 'ಒಂದು.'

494
00:46:56,510 --> 00:47:02,180
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಸ್ವಾಪ್ ಮಾಡಲು ಏನು ಅಗತ್ಯವಿಲ್ಲ. ಯಾ?

495
00:47:02,180 --> 00:47:05,690
[ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ಇದು ಬಲ, ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ?

496
00:47:05,690 --> 00:47:10,280
ಇದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಶೇಖರಿಸಿಡಲು ಅಗತ್ಯವಿದೆ ವೇಳೆ ಹೆಚ್ಚು ಮೆಮೊರಿ ಮಾತ್ರ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

497
00:47:10,280 --> 00:47:14,830
ನೀವು ನಂತರ ಎಲ್ಲೋ ಮತ್ತೆ ಆ ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಬಳಸುತ್ತಿದ್ದರೆ ಲೈಕ್,

498
00:47:14,830 --> 00:47:18,920
ನಂತರ - ಅಥವಾ ನೀವು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಏನಾದರೂ ನಿಗದಿಪಡಿಸಬಹುದು.

499
00:47:18,920 --> 00:47:24,630
ಆದ್ದರಿಂದ ಸಮಯ ಟೆಂಪ್ ರಲ್ಲಿ 'ಒಂದು' ಬೌ ಯಾವುದೇ ಹಂತದಲ್ಲಿ ವೇಳೆ, ಭಿನ್ನ ಮೌಲ್ಯಗಳು ಅಥವಾ ಅಂಶವಿದೆ

500
00:47:24,630 --> 00:47:30,680
ಅದು ನೆನಪಿಗಾಗಿ ವಿಶಿಷ್ಟ ಸ್ಥಳಗಳಲ್ಲಿ ಹೊಂದಿದೆ ವಿಶೇಷವೇನು, ಆದರೆ ಸತ್ಯ

501
00:47:30,680 --> 00:47:34,800
ಕೇವಲ ನೊಂದಣಿಗಳನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಇದು ಅನೇಕ ಸ್ಥಳೀಯ ಚರ ಪರಿಮಾಣಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ.

502
00:47:34,800 --> 00:47:44,370
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದನ್ನು ಮೆಮೊರಿಗೆ ಪುಟ್ ಎಂದೂ, ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಮೆಮೊರಿ ಹಾಳುಮಾಡುತ್ತಿದೆ ಎಂದಿಗೂ ನೀವು.

503
00:47:44,370 --> 00:47:58,620
ಸರಿ. ಕೊನೆಯ ಪ್ರಶ್ನೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು.

504
00:47:58,620 --> 00:48:04,850
ಇಲ್ಲಿ, ಈ CS50 ಉಪಕರಣಗಳಲ್ಲಿರುವ, ಒಂದು ನಿಘಂಟು ಇರುತ್ತದೆ.

505
00:48:04,850 --> 00:48:12,390
ಕಾರಣ ಈ ಏಕೆಂದರೆ [? B66] ಬರೆಯುವುದು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ ಅಲ್ಲಿ ಒಂದು ಪದಪರೀಕ್ಷಕ ಆಗಿದೆ

506
00:48:12,390 --> 00:48:15,780
ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಅಥವಾ ಪ್ರಯತ್ನಗಳಲ್ಲಿ ಅಥವಾ ಕೆಲವು ಡೇಟಾವನ್ನು ರಚನೆಯನ್ನು ಬಳಸಿ.

507
00:48:15,780 --> 00:48:22,660
ನೀವು ಒಂದು ಪದಪರೀಕ್ಷಕ ಬರೆಯಲು ನೀನು, ಮತ್ತು ನೀವು ಹಾಗೆ ಈ ನಿಘಂಟು ಬಳಸಿ ಎಂದು ನೀನು.

508
00:48:22,660 --> 00:48:28,280
ಆದರೆ ಈ ಸಮಸ್ಯೆಗೆ, ನಾವು ಕೇವಲ ಒಂದು ಪದ ನಿಘಂಟಿನಲ್ಲಿ ವೇಳೆ ನೋಡಲು ಹುಡುಕುವ ಹೋಗುವ.

509
00:48:28,280 --> 00:48:31,250
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಕೆಲವು ವಿನ್ಯಾಸ ಸಂಪೂರ್ಣ ನಿಘಂಟು ಸಂಗ್ರಹಿಸುವ ಆಫ್

510
00:48:31,250 --> 00:48:35,180
ತದನಂತರ, ಏನು ತಪ್ಪಾಗಿಬರೆಯಲಾದಪದ ಇದ್ದರೆ ನೋಡಲು ಸಂಪೂರ್ಣ ಡಾಕ್ಯುಮೆಂಟ್ ಮೇಲೆ ಕಾಣುವ

511
00:48:35,180 --> 00:48:38,490
ನಾವು 1 ಪದ ಹುಡುಕಲು ಬಯಸುವ. ಆದ್ದರಿಂದ ನಾವು ಸಂಪೂರ್ಣ ನಿಘಂಟು ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಮಾಡಬಹುದು

512
00:48:38,490 --> 00:48:44,300
ನಾವು ಇಡೀ ನಿಘಂಟು ಪದ ಹುಡುಕಲು ಎಂದಿಗೂ ವೇಳೆ ಮತ್ತು, ನಂತರ ಅಲ್ಲಿ ಇರಲಿಲ್ಲ.

513
00:48:44,300 --> 00:48:52,150
ನಾವು ಇಡೀ ನಿಘಂಟು ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಮತ್ತು ಪದ ನೋಡಿ ಹೋದರೆ, ನಾವು ಉತ್ತಮ ನೀವು, ನಾವು ಕಂಡುಬಂದಿಲ್ಲ.

514
00:48:52,150 --> 00:48:56,580
ಇದು ನಾವು C ನ ಕಡತ ನಿರ್ವಹಣಾ ಕಾರ್ಯ ನೋಡಿ ಆರಂಭಿಸಲು ಬಯಸುವ ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ

515
00:48:56,580 --> 00:48:59,930
ನಾವು, ಡಿಕ್ಷನರಿ ಓದಲು ಬಯಸುವ ರಿಂದ

516
00:48:59,930 --> 00:49:07,680
ಆದರೆ ಇದು ನಿಮ್ಮ ಯೋಚಿಸಬೇಕು ಕಾರ್ಯಗಳನ್ನು ಮಾಡಲು ಇಲ್ಲಿ ಸುಳಿವು ನೀಡುತ್ತದೆ.

517
00:49:07,680 --> 00:49:11,510
ನಾನು ಸ್ಪೇಸಸ್ ಅವುಗಳನ್ನು ಬರೆಯಲು ಮಾಡುತ್ತೇವೆ.

518
00:49:11,510 --> 00:49:20,490
ಆದ್ದರಿಂದ ಮುಖ್ಯ ಬಿಡಿಗಳ ನೀವು, ನಂತರ ತೆರೆದ ಮತ್ತು ಎಫ್, ಅನಿವಾರ್ಯವಾಗಿ, ಎಫ್ ಮುಚ್ಚಲಾಗಿದೆ ನೋಡಲು ಬಯಸುವಿರಿ

519
00:49:20,490 --> 00:49:26,540
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ಹೋಗಿ, ಮತ್ತು ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಕಾಣಿಸುತ್ತದೆ.

520
00:49:26,540 --> 00:49:31,060
ನೀವು F ಓದಲು ಬಳಸಲು, ಆದರೆ ನೀವು ಬಹುಶಃ ಬಯಸುವುದಿಲ್ಲ

521
00:49:31,060 --> 00:49:34,200
ಏಕೆಂದರೆ - ಆ ಅಗತ್ಯವಿಲ್ಲದೇ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಇಲ್ಲ.

522
00:49:34,200 --> 00:49:41,880
ಎಫ್ ಸ್ಕ್ಯಾನ್ F ನೀವು ನಿಘಂಟು ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಬಳಸುತ್ತಿರುವ ಎಂದು ನೀನು ಏನು.

523
00:49:41,880 --> 00:49:46,370
ಆದ್ದರಿಂದ ನಿಮ್ಮ ರೀತಿಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಹುಸಿ ಕೋಡ್ ಇಷ್ಟ, ಪರಿಹಾರ ಅಪ್ ಕೋಡ್ ಅಗತ್ಯವಿಲ್ಲ

524
00:49:46,370 --> 00:50:05,200
ಪರಿಹಾರ ಮತ್ತು ನಂತರ ನಾವು ಚರ್ಚಿಸಲು ವಿಲ್.

525
00:50:05,200 --> 00:50:14,110
ನಾನು ಈಗಾಗಲೇ ಈ ನೀಡಿದ ನಂತರ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನೀವು ಯಾವುದೇ ಟರ್ಮಿನಲ್ ಅಥವಾ ನಿಮ್ಮ APPLIANCE ಚಿಪ್ಪಿನ ಹೋಗಿ ವೇಳೆ

526
00:50:14,110 --> 00:50:18,250
ನಾನು ಎಂದು - ನಾನು ಸಾಮಾನ್ಯವಾಗಿ - ನೀವು ಇನ್ನೂ ನೋಡಿಲ್ಲ ನೀವು ತರಗತಿಯಲ್ಲಿ ಮಾಡಿದರೆ, ನಾನು, ಗೊತ್ತಿಲ್ಲ

527
00:50:18,250 --> 00:50:23,490
ಆದರೆ ಮನುಷ್ಯ, ಆದ್ದರಿಂದ ಮನುಷ್ಯ ಪುಟಗಳು, ಅತ್ಯಧಿಕವಾಗಿ ಯಾವುದೇ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನೋಡಲು ಬಹಳ ಉಪಯುಕ್ತ.

528
00:50:23,490 --> 00:50:27,330
ಹಾಗಾಗಿ, ಇಷ್ಟ, ಸ್ಕ್ಯಾನ್ F ಮನುಷ್ಯ F ಮಾಡಬಹುದು.

529
00:50:27,330 --> 00:50:32,300
ಈಗ ಕಾರ್ಯಗಳನ್ನು ಸ್ಕ್ಯಾನ್ F ಕುಟುಂಬದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದೆ.

530
00:50:32,300 --> 00:50:37,070
ನಾನು ಮುಕ್ತ ಮನುಷ್ಯ F, ಇಲ್ಲ, ಮತ್ತು ನನಗೆ ಆ ವಿವರಗಳನ್ನು ನೀಡುತ್ತೇನೆ.

531
00:50:37,070 --> 00:50:40,750
ನೀವು ಬಳಸುತ್ತಿದ್ದರೆ, ಅಥವಾ ನೀವು ಕೋಡ್ ಓದುವ ಏನನ್ನು ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಆದ್ದರಿಂದ

532
00:50:40,750 --> 00:50:43,000
ಮತ್ತು ನೀವು ಕೆಲವು ಕಾರ್ಯ ನೋಡಿ, ನಿಮಗೆ ನೀವು "ಈ ಏನು ಮಾಡುತ್ತದೆ?"

533
00:50:43,000 --> 00:50:45,280
ಕೇವಲ ಮನುಷ್ಯ ಆ ಕಾರ್ಯದ ಹೆಸರು.

534
00:50:45,280 --> 00:50:47,340
ನೀವು ಹೇಳಲು ಹೊಂದಿರಬಹುದು ಅಲ್ಲಿ ವಿಲಕ್ಷಣ ಉದಾಹರಣೆಗಳು ಒಂದೆರಡು ಇವೆ

535
00:50:47,340 --> 00:50:51,620
ಇಷ್ಟ. ಆ ಕ್ರಿಯೆ ಹೆಸರು, ಅಥವಾ ಮನುಷ್ಯ 3 ಆ ಕ್ರಿಯೆ ಹೆಸರು, ಮ್ಯಾನ್ 2

536
00:50:51,620 --> 00:50:58,230
ಆದರೆ ನೀವು ಮಾತ್ರ ಮನುಷ್ಯ ಕಾರ್ಯ ಹೆಸರನ್ನು ಮೊದಲ ಬಾರಿಗೆ ಕೆಲಸ ನಡೆಯುತ್ತಿಲ್ಲ ಎಂದು ಮಾಡಬೇಕು.

537
00:50:58,230 --> 00:51:03,010
[ವಿದ್ಯಾರ್ಥಿ] ಹಾಗಾಗಿ ತೆರೆದ ಮ್ಯಾನ್ ಪುಟವನ್ನು ಓದುವ ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ನಾನು ಇನ್ನೂ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೇಗೆ ಗೊಂದಲ ನುಡಿದರು.

538
00:51:03,010 --> 00:51:06,170
ಸರಿ. ಮನುಷ್ಯ ಪುಟಗಳು ಬಹಳಷ್ಟು ಉಪಯುಕ್ತ ಕಡಿಮೆ.

539
00:51:06,170 --> 00:51:08,470
ನೀವು ಈಗಾಗಲೇ ಅವರು ಏನು ಗೊತ್ತಿಲ್ಲ ವೇಳೆ ಅವು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ಆರ್

540
00:51:08,470 --> 00:51:12,670
ತದನಂತರ ನೀವು ವಾದಗಳನ್ನು ಅಥವಾ ಏನಾದರೂ ಕ್ರಮವನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಕೇವಲ ಅಗತ್ಯವಿದೆ.

541
00:51:12,670 --> 00:51:17,640
ಅಥವಾ ನೀವು ಒಂದು ಸಾಮಾನ್ಯ ಅವಲೋಕನ ನೀಡಬಹುದು, ಆದರೆ ಕೆಲವರು ಬಹಳ ಅಗಾಧ ಇವೆ.

542
00:51:17,640 --> 00:51:22,220
ಎಫ್ ಸ್ಕ್ಯಾನ್ ಎಫ್ ಕೂಡ. ಇದು, ನೀವು ಈ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ

543
00:51:22,220 --> 00:51:28,120
ಮತ್ತು 1 ಸಾಲಿನ ಕೆಳಗೆ ಇಲ್ಲಿ ಹೇಳಲು ಸಂಭವಿಸುತ್ತದೆ, "F ಸ್ಕ್ಯಾನ್ F ಸ್ಟ್ರಿಂಗ್ ಪಾಯಿಂಟ್ ಅಥವಾ ಸ್ಟ್ರೀಮ್ ಓದುತ್ತದೆ."

544
00:51:28,120 --> 00:51:32,360
ಆದರೆ F ತೆರೆಯಲು. ಆದ್ದರಿಂದ, ಹೇಗೆ ನಾವು ಎಫ್ ಮುಕ್ತ ಬಳಸಬಹುದು?

545
00:51:32,360 --> 00:51:38,470
ಕಡತದ ಅಗತ್ಯವಿದೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಕಲ್ಪನೆಯನ್ನು I / O ಎಂದು

546
00:51:38,470 --> 00:51:45,070
ನೀವು ಮೊದಲ ನಿಮ್ಮೊಂದಿಗೆ ಕೆಲಸಗಳನ್ನು ಬಯಸುವ ಕಡತವನ್ನು ತೆರೆಯಲು ಅಗತ್ಯವಿದೆ, ಮತ್ತು ಅನಿವಾರ್ಯವಾಗಿ,

547
00:51:45,070 --> 00:51:51,220
ಫೈಲ್ ವಸ್ತುಗಳ ಓದಲು ಮತ್ತು ಅವರೊಂದಿಗೆ ವಿಷಯವನ್ನು ಹೊಂದಿದ್ದೇವೆ.

548
00:51:51,220 --> 00:51:55,350
ಎಫ್ ಮುಕ್ತ ನಾವು ಕಡತವನ್ನು ತೆರೆಯಲು ಬಳಸಲು ಏನು.

549
00:51:55,350 --> 00:52:04,190
ನಾವು ತೆರೆಯಲು ಯಾವ ಫೈಲ್ ಬಯಸುತ್ತೀರಿ ಆದ್ದರಿಂದ ನಾವು, ಹಿಂದೆ ವಿಷಯ, ನಮಗೆ ನೀಡುತ್ತದೆ -

550
00:52:04,190 --> 00:52:11,970
ಇಲ್ಲಿ ಇದನ್ನು "/ ಬಳಕೆದಾರ / ಷೇರು / dict / ಪದಗಳು." ಹೇಳುತ್ತಾರೆ

551
00:52:11,970 --> 00:52:16,740
ಈ ನಾವು ತೆರೆಯಲು ಬಯಸುವ ಫೈಲ್, ಮತ್ತು ನಾವು ಅದನ್ನು ತೆರೆಯಲು ಬಯಸುವ -

552
00:52:16,740 --> 00:52:21,440
ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ನಾವು ಓದಲು ಅಥವಾ ನಾವು ತೆರೆಯಲು ಬಯಸಿದರೆ ಇದನ್ನು ಬರೆಯಲು ತೆರೆಯಲು ಬಯಸುತ್ತೀರೆ ಎಂದು ಸೂಚಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

553
00:52:21,440 --> 00:52:26,490
ಇಲ್ಲ ಸಂಯೋಜನೆಗಳು ಮತ್ತು ವಿಷಯವನ್ನು ಒಂದೆರಡು, ಆದರೆ ನಾವು ಓದುವ ಈ ತೆರೆಯಲು ಬಯಸುವ.

554
00:52:26,490 --> 00:52:29,380
ನಾವು ಕಡತದಿಂದ ಓದಲು ಬಯಸುವ.

555
00:52:29,380 --> 00:52:34,290
ಆದ್ದರಿಂದ ಈ ರಿಟರ್ನ್ ಏನು ಮಾಡುತ್ತದೆ? ಇದು ಒಂದು ಕಡತ ನಕ್ಷತ್ರ (*), ಹಿಂದಿರುಗಿಸುತ್ತದೆ

556
00:52:34,290 --> 00:52:37,260
ಮತ್ತು ನಾನು ವೇರಿಯಬಲ್ F ಎಲ್ಲವನ್ನೂ, ಆದ್ದರಿಂದ *, ತೋರುವಿರಿ

557
00:52:37,260 --> 00:52:40,840
ಮತ್ತೊಮ್ಮೆ, ಇದು ಒಂದು ಪಾಯಿಂಟರ್, ಆದರೆ ನಾವು ಪಾಯಿಂಟರ್ಸ್ ವ್ಯವಹರಿಸಲು ಬಯಸುವುದಿಲ್ಲ.

558
00:52:40,840 --> 00:52:46,470
ನೀವು, ಎಫ್ ಈಗ ನೀವು ಫೈಲ್ ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಲು ನೀನು ವ್ಯತ್ಯಯ ಎಫ್ ನಗರದ.

559
00:52:46,470 --> 00:52:49,850
ನೀವು ಕಡತದಿಂದ ಓದಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ನೀವು ಎಫ್ ಓದುವುದಕ್ಕೆ.

560
00:52:49,850 --> 00:52:54,820
ನೀವು ಕಡತವನ್ನು ಮುಚ್ಚಲು ಬಯಸಿದರೆ, ನೀವು ಎಫ್ ಮುಚ್ಚಿ.

561
00:52:54,820 --> 00:53:00,350
ಆದ್ದರಿಂದ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ನಾವು ಅನಿವಾರ್ಯವಾಗಿ ಕಡತವನ್ನು ಮುಚ್ಚಲು ಬಯಸುವ ಮಾಡಿದಾಗ, ನಾವು ಏನು ಮಾಡಬೇಕು?

562
00:53:00,350 --> 00:53:06,750
ನಾವು ಎಫ್ ಅಳಿಸಲು.

563
00:53:06,750 --> 00:53:12,600
ನಾವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಎಷ್ಟು ಈಗ ಕೊನೆಯಾಗಿ ಕಡತ ಕಾರ್ಯ ಸ್ಕ್ಯಾನ್ F, ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಆಗಿದೆ.

564
00:53:12,600 --> 00:53:20,930
ಮತ್ತು ಆ ಮಾಡುತ್ತದೆ ಅದನ್ನು ಹೊಂದಿಸಲು ಒಂದು ಮಾದರಿ ಹುಡುಕುತ್ತಿರುವ ಫೈಲ್ ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಆಗಿದೆ.

565
00:53:20,930 --> 00:53:39,100
ಇಲ್ಲಿ ಮನುಷ್ಯ ಪುಟ ನಲ್ಲಿ ನೋಡುತ್ತಿರುವುದು, ನಾವು ಇಂಟ್ F ಸ್ಕ್ಯಾನ್ ಎಫ್ ನೋಡಿ, ಈಗ ಪ್ರತಿಯಾಗಿ ಮೌಲ್ಯ ನಿರ್ಲಕ್ಷಿಸಿ.

566
00:53:39,100 --> 00:53:45,230
ಮೊದಲ ವಾದವನ್ನು ಫೈಲ್ * ಸ್ಟ್ರೀಮ್, ನಾವು ರವಾನಿಸ ಬೇಕೆಂದಿರುವ ಎಂದು ನೀನು ಮೊದಲ ವಾದವನ್ನು F ಆದ್ದರಿಂದ.

567
00:53:45,230 --> 00:53:47,900
ನಾವು ಎಫ್ ಮೇಲೆ ಸ್ಕ್ಯಾನಿಂಗ್ ಮಾಡುತ್ತಿದ್ದೇವೆ.

568
00:53:47,900 --> 00:53:53,680
ಎರಡನೇ ವಾದದ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.

569
00:53:53,680 --> 00:53:58,310
ನಾನು ಈಗ ನೀವು ಒಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ನೀಡುತ್ತದೆ.

570
00:53:58,310 --> 00:54:05,180
ನಾವು, 127s \ N, ಅನಗತ್ಯ ಎಂದು ಬಹಳಷ್ಟು ಹೇಳಲು ಸಂಭವಿಸಿ ಭಾವಿಸುತ್ತೇನೆ.

571
00:54:05,180 --> 00:54:12,490
ಆ ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಏನು ಕಲ್ಪನೆಯನ್ನು, ನೀವು ಮುದ್ರಣ ಎಫ್ ವಿರುದ್ಧ ಮಾಹಿತಿ ಸ್ಕ್ಯಾನ್ ಎಫ್ ನಗರದ ಹೊಂದಿದೆ.

572
00:54:12,490 --> 00:54:17,160
ಆದ್ದರಿಂದ ಮುದ್ರಣ F, ನಾವು ರೂಪದಲ್ಲಿ ನಿಯತಾಂಕವನ್ನು ಈ ರೀತಿಯ ಬಳಸಿ ಮುದ್ರಣ F,

573
00:54:17,160 --> 00:54:25,000
ಆದರೆ ಮುದ್ರಣ F ನಾವು ಮಾಡುತ್ತಿರುವುದು ಏನು - ನ ಸಮಾನ ನೋಡೋಣ.

574
00:54:25,000 --> 00:54:32,550
ಆದ್ದರಿಂದ F ಮುದ್ರಿಸಲು, ಮತ್ತು ಮೊದಲ ವಾದವನ್ನು F ಎಂದು ಹೋಗಿ ಅಲ್ಲಿ F ಮುದ್ರಣ ಎಫ್ ಕೂಡ ನಿಜವಾಗಿ ಇಲ್ಲ.

575
00:54:32,550 --> 00:54:40,980
ನೀವು F ಮುದ್ರಿಸಲು, ನಾವು, ನಾವು ಕೆಲವು ತಂತಿ ಹಾದು ವೇಳೆ ನಂತರ, ಯಾವುದೋ ರೀತಿಯಲ್ಲಿ "ಮುದ್ರಣ 127s \ n" ಹೇಳಲು ಸಾಧ್ಯವಾಗಿತ್ತು

576
00:54:40,980 --> 00:54:44,050
ಈ ವಾಕ್ಯವನ್ನು ಮತ್ತು ನಂತರ ಒಂದು ಹೊಸ ಸಾಲು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು.

577
00:54:44,050 --> 00:54:49,690
ಏನು 127 ಅಂದರೆ, ನಾನು ಬಹಳ ಖಚಿತವಾಗಿ, ಆದರೆ ನಾನು ಅದನ್ನು ನಾನೇ ನಿರ್ಬಂಧಿಸಲಾಗುತ್ತದೆ ನಾನೆಂದಿಗೂ

578
00:54:49,690 --> 00:54:52,470
ನೀವು, ಮುದ್ರಣ ಎಫ್ '127 'ಹೇಳುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು

579
00:54:52,470 --> 00:54:57,090
ಆದರೆ ಅದರ ಅರ್ಥ ಮೊದಲ 127 ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿದೆ.

580
00:54:57,090 --> 00:54:59,350
ಹಾಗಾಗಿ ಪ್ರಕರಣ ಎಂದು ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ. ನೀವು ಗೂಗಲ್ ಮಾಡಬಹುದು.

581
00:54:59,350 --> 00:55:03,000
ಆದರೆ ಮುಂದಿನ ಒಂದು ನಾನು ಅಂದರೆ ಬಹುತೇಕ ಸಕಾರಾತ್ಮಕ ಆಗಿದ್ದೇನೆ.

582
00:55:03,000 --> 00:55:08,880
ಆದ್ದರಿಂದ ಈ ಹೊಸ ಲೈನ್ ನಂತರ ಮೊದಲ 127 ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸಲು ಹೊಂದಿದೆ.

583
00:55:08,880 --> 00:55:14,680
ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಈಗ, ಬದಲಿಗೆ ವೇರಿಯಬಲ್ ನೋಡಿ ಮತ್ತು ಅದನ್ನು ಮುದ್ರಿಸುವ,

584
00:55:14,680 --> 00:55:22,620
ಇದು ಕೆಲವು ಸ್ಟ್ರಿಂಗ್ ನೋಡಲು, ಮತ್ತು ವೇರಿಯಬಲ್ ಗೆ ಮಾದರಿ ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವೇನು.

585
00:55:22,620 --> 00:55:26,360
ನ ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಉದಾಹರಣೆಯಲ್ಲಿ ಸ್ಕ್ಯಾನ್ F ಬಳಸಲು ಅನುಮತಿ.

586
00:55:26,360 --> 00:55:31,670
ಆದ್ದರಿಂದ ನಮಗೆ ಕೆಲವು ಇಂಟ್ ತಿಳಿಸಿದ, x = 4,

587
00:55:31,670 --> 00:55:41,110
ಮತ್ತು ನಾವು ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ ಸೃಷ್ಟಿಸಲು ಬಯಸಿದ್ದರು - ಸ್ಟ್ರಿಂಗ್ ಸೃಷ್ಟಿಸಲು ಬಯಸಿದ್ದರು

588
00:55:41,110 --> 00:55:44,250
ಇದು ನಂತರ ಬರುತ್ತವೆ, ಆ, ಎಂದು

589
00:55:44,250 --> 00:55:49,020
ಕೇವಲ 4.jpg ನಂತಹ ಹೊಂದಿರುವ ವಿಷಯ.

590
00:55:49,020 --> 00:55:51,870
ಆದ್ದರಿಂದ ಈ, ನೀವು ಮೊತ್ತವು ಪ್ರತಿ ಹೊಂದಿರುತ್ತದೆ ಅಲ್ಲಿ ಒಂದು ಕಾರ್ಯಕ್ರಮ ಇರಬಹುದು

591
00:55:51,870 --> 00:55:56,420
ನಾನು ಎದುರಿಸಲು ಮೊತ್ತವು, ಮತ್ತು ಚಿತ್ರಗಳನ್ನು ಒಂದು ಗುಂಪೇ ಉಳಿಸಲು ಬಯಸುವ.

592
00:55:56,420 --> 00:56:02,430
ನೀವು ನಾನು ನಿಮ್ಮ ಲೂಪ್ ಕೆಲವು ಪುನರಾವರ್ತನೆ ಅಲ್ಲಿ i.jpg, ಉಳಿಸಲು ಬಯಸುವ.

593
00:56:02,430 --> 00:56:05,500
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು JPEG ಈ ಸಾಲನ್ನು ಮಾಡಲು ಹೇಗೆ?

594
00:56:05,500 --> 00:56:11,720
ನೀವು 4.jpg ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಪ್ರಿಂಟ್ F,% d.jpg, ಹೇಳಬಹುದು

595
00:56:11,720 --> 00:56:14,410
ತದನಂತರ ಆ JPEG ಮುದ್ರಣ ಎಂದು.

596
00:56:14,410 --> 00:56:20,050
ನಾವು ಸ್ಟ್ರಿಂಗ್ 4.jpg ಉಳಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಸ್ಕ್ಯಾನ್ F ಬಳಸಿ.

597
00:56:20,050 --> 00:56:30,860
ಸ್ಟ್ರಿಂಗ್ ರು ಆದ್ದರಿಂದ - ವಾಸ್ತವವಾಗಿ ನಾವು can't - ಅಕ್ಷರ, ಚಾರ್ ರು, 100 ಹೋಗಲು ಬಿಡುವುದಿಲ್ಲ.

598
00:56:30,860 --> 00:56:35,400
ಆದ್ದರಿಂದ ನಾನು, 100 ಪಾತ್ರಗಳು ಕೆಲವು ಸರಣಿ ಘೋಷಿಸಿತು

599
00:56:35,400 --> 00:56:39,830
ಮತ್ತು ನಾವು ಅನಿವಾರ್ಯವಾಗಿ ಆ JPEG ಸೈನ್ ಸಂಗ್ರಹಿಸಲು ಎಂದು ನೀನು ಇಲ್ಲಿದೆ

600
00:56:39,830 --> 00:56:47,920
ನಾವು ಸ್ಕ್ಯಾನ್ F ಬಳಸಲು ಹೋಗಿ, ಮತ್ತು ನಾವು% d.jpg ಹೇಳುತ್ತಿದ್ದರು ಹೇಗೆ ರೂಪದಲ್ಲಿ, ನೀವು

601
00:56:47,920 --> 00:56:54,980
4.jpg ಮುದ್ರಿಸಲು ಸಲುವಾಗಿ, ಈ ವಿನ್ಯಾಸವನ್ನು% d.jpg ಏರಲಿದೆ.

602
00:56:54,980 --> 00:57:04,020
ಆದ್ದರಿಂದ ರೂಪದಲ್ಲಿ% d.jpg, ಎಂಬುದನ್ನು ನಾವು% D ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೀರೆ X ಹೊಂದಿದೆ, ಇದು

603
00:57:04,020 --> 00:57:06,590
ಮತ್ತು ಈಗ ನಾವು ಎಲ್ಲೋ ಒಂದು ತಂತುವಿನ ಶೇಖರಿಸಿಡಲು ಅಗತ್ಯವಿದೆ.

604
00:57:06,590 --> 00:57:12,500
ಮತ್ತು ನಾವು ಈ ಸರಣಿಯನ್ನು ಶೇಖರಿಸಿಡಲು ನೀನು ಅಲ್ಲಿ ಸರಣಿ s ನಲ್ಲಿ ಹೊಂದಿದೆ.

605
00:57:12,500 --> 00:57:21,640
ಆದ್ದರಿಂದ, ಕೋಡ್, ರು ಈ ಸಾಲಿನ ನಂತರ ನಾವು ವೇರಿಯಬಲ್ ರು ಎಫ್,% ರು ಮುದ್ರಿಸಲು ವೇಳೆ,

606
00:57:21,640 --> 00:57:26,280
ಇದು 4.jpg ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು.

607
00:57:26,280 --> 00:57:38,930
ಆದ್ದರಿಂದ F ಸ್ಕ್ಯಾನ್ F ಈಗ ಈ ಫೈಲ್ ಮೇಲೆ ಹುಡುಕುತ್ತಿದ್ದಳು ಹೊರತುಪಡಿಸಿ, ಸ್ಕ್ಯಾನ್ F ಒಂದೇ

608
00:57:38,930 --> 00:57:43,600
s ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಯಾವ.

609
00:57:43,600 --> 00:57:46,160
ಆ ಕಡೆಯ ವಾದ ಎಂದು ಏನು ನಡೆಯುತ್ತಿದೆ.

610
00:57:46,160 --> 00:57:54,170
ಕಾರ್ಯಗಳನ್ನು ಸ್ಕ್ಯಾನ್ಗಳನ್ನು "ಸ್ಕ್ಯಾನ್ F ಕುಟುಂಬ ಕೆಳಗೆ ಪ್ರಯತ್ನಿಸಿದರು ಎಂದು ಎರಡೂ ಸ್ವರೂಪಕ್ಕೆ ಪ್ರಕಾರ - ನಾವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುತ್ತೇನೆ.

611
00:57:54,170 --> 00:58:02,450
ಯಾವುದೇ ಸ್ಥಳ ಅಂಕಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ನೀವು ಮರಳಿ ಇರಬಹುದು - "

612
00:58:02,450 --> 00:58:12,910
ಇಲ್ಲ, ನಾವು ಉತ್ತಮ ಇರಬಹುದು. ಅಂತ ಎರಡನೇ ಆಲೋಚಿಸುತ್ತೀರಿ ತಿಳಿಸಿ.

613
00:58:12,910 --> 00:58:26,350
ಆದ್ದರಿಂದ ಸ್ಕ್ಯಾನ್ F ಮಾಡುವುದಿಲ್ಲ - ಬೀಟಿಂಗ್ ಎಂದು ಯಾವ ಕಾರ್ಯವೇನು?

614
00:58:26,350 --> 00:58:31,650
ಆದ್ದರಿಂದ ಸ್ಕ್ಯಾನ್ ಎಫ್ ಒಂದು ಪೂರ್ಣಾಂಕ ತೆಗೆದುಕೊಂಡು ಡಾಟ್ JPG ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ.

615
00:58:31,650 --> 00:58:43,490
ಇದು [mumbles] ಹೋಗುವುದಿಲ್ಲ.

616
00:58:43,490 --> 00:58:49,360
ಸ್ಟ್ರಿಂಗ್ ಇಂಟ್ ಸಿ ರಲ್ಲಿ ಇಂಟ್ ವೇರಿಯಬಲ್ ಉಳಿಸಿ

617
00:58:49,360 --> 00:58:55,940
ಏನು ಈ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಅಥವಾ ಈ ಫಂಕ್ಷನ್ ಏನು ಕರೆಯುತ್ತಾರೆ?

618
00:58:55,940 --> 00:59:04,950
ಹೌದು. That's - ಹೌದು. ಹಾಗಾಗಿ ನಾನು ನಿಮಗೆ ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೊದಲು, ರು ಮುದ್ರಣ F ಆಗಿತ್ತು

619
00:59:04,950 --> 00:59:09,820
ಅದು - ಇದು ಮುದ್ರಣ ಎಫ್ ನಂತಹ ಹೆಚ್ಚು ಹೇಳಿದರು ಏಕೆ ಹೆಚ್ಚು ಅರ್ಥದಲ್ಲಿ, ಮಾಡುತ್ತದೆ.

620
00:59:09,820 --> 00:59:14,700
ಸ್ಕ್ಯಾನ್ F ಮುದ್ರಣ ಎಫ್ ನಂತಹ ಇನ್ನೂ ರೀತಿಯ, ಆದರೆ ರು ಮುದ್ರಣ F ಅದನ್ನು ಸ್ಕ್ಯಾನ್ ಹಾಕುತ್ತದೆ

621
00:59:14,700 --> 00:59:17,510
ಮತ್ತು ವ್ಯತ್ಯಾಸಗಳ ಬದಲಿಗೆ ಈಗ ಸಾಲಿನಲ್ಲಿ ಶೇಖರಿಸಿಡಬೇಕು.

622
00:59:17,510 --> 00:59:19,620
ಬದಲಿಗೆ ಅದನ್ನು ಮುದ್ರಿಸುವ, ಅದು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

623
00:59:19,620 --> 00:59:25,070
ಇದರಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಿ. ನೀವು ಇನ್ನೂ ಮುದ್ರಣ F ಹಾಗೆ ಸ್ವರೂಪ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ನಗರದ.

624
00:59:25,070 --> 00:59:34,510
ನಾವು 4.jpg ವಿಷಯವನ್ನು ಬಯಸಿದರೆ ಈಗ, ನಾವು, ಈ X ರು ಮುದ್ರಣ F ಮಾಡಬೇಕಾಗುವುದು.

625
00:59:34,510 --> 00:59:38,520
ನಿಮ್ಮ ಪ್ರಶ್ನೆಯನ್ನು ಎಂದು ಹೋಗಿ ಏನು - ಹಾಗಾಗಿ ಸ್ಕ್ಯಾನ್ F ಏನು ಇದೆ?

626
00:59:38,520 --> 00:59:40,820
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು ನಾವು ಇಲ್ಲಿಯೇ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಬಗ್ಗೆ ಗೊಂದಲ ನಾನು

627
00:59:40,820 --> 00:59:43,450
ಆ JPEG ಜೊತೆ. ಆ 1 ಹೆಚ್ಚು ಸಮಯ ವಿವರಿಸಲು ಸಾಧ್ಯ?

628
00:59:43,450 --> 00:59:52,710
ಆದ್ದರಿಂದ ಈ - ಇದು ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಈಗ ಕಡಿಮೆ relevent ಇಲ್ಲಿದೆ; ಆಶಾದಾಯಕವಾಗಿ, ಇದು ರೀತಿಯಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಮತ್ತೆ ಟೈ ಕಾಣಿಸುತ್ತದೆ.

629
00:59:52,710 --> 01:00:02,240
ಆದರೆ ಏನು ನಾನು ಆರಂಭದಲ್ಲಿ ತೋರಿಸಲು ಉದ್ದೇಶವಿಲ್ಲದೇ ಆಗಿತ್ತು - ಈ ವಾಸ್ತವವಾಗಿ ಈ [ನೇರವಾಗಿ ಪ್ರಸ್ತುತವಾಗಿರುವ? ಎಫ್ 5]

630
01:00:02,240 --> 01:00:08,520
ನೀವು ರು ಮುದ್ರಣ F ಬಳಸುತ್ತಿರಬಹುದು ಎಂದು ನೀನು,,, ನಾವು 100 ಚಿತ್ರಗಳನ್ನು ಹೊಂದಿವೆ ಹೇಳುತ್ತಾರೆ

631
01:00:08,520 --> 01:00:13,630
ಮತ್ತು ನೀವು ಚಿತ್ರವನ್ನು 1.jpg, 2.jpg, 3.jpg ಓದಲು ಬಯಸುವ.

632
01:00:13,630 --> 01:00:21,520
ಆದ್ದರಿಂದ ಹಾಗೆ ಮಾಡಲು, ನೀವು ಎಫ್ ಮುಕ್ತ ಅಗತ್ಯವಿದೆ, ಮತ್ತು ನಂತರ ನೀವು ತೆರೆಯಲು ಬಯಸುವ ಸಾಲಿನಲ್ಲಿ ರವಾನಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

633
01:00:21,520 --> 01:00:30,020
ನಾವು 1.jpg ತೆರೆಯಲು ಬಯಸುತ್ತೇನೆ; 1.jpg ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಸೃಷ್ಟಿ ಮಾಡಲು,

634
01:00:30,020 --> 01:00:37,660
% ಆಫ್ ನಾವು ರು ಏನು ಮುದ್ರಣ F d.jpg-ನಾವು ಇಂಟ್ ನಾನು = 0 ಕಾಣಲಿಲ್ಲ.

635
01:00:37,660 --> 01:00:46,580
ನಾನು <40, ನಾನು + +.

636
01:00:46,580 --> 01:00:51,130
ಆದ್ದರಿಂದ ರು ಮುದ್ರಣ F% i ನ d.jpg.

637
01:00:51,130 --> 01:00:56,320
ಆದ್ದರಿಂದ ಈ ಸಾಲಿನ ನಂತರ, ಈಗ ವೇರಿಯಬಲ್ ಅಥವಾ ರಚನೆಯ ರು 1.jpg ಹೋಗುವ ಇದೆ.

638
01:00:56,320 --> 01:01:10,610
ಅಥವಾ, 0.jpg, 1.jpg, 2.jpg. ಆದ್ದರಿಂದ ನಾವು, ಪ್ರತಿಯಾಗಿ, ಓದುವಿಕೆ ಪ್ರತಿ ಚಿತ್ರ ತೆರೆಯಬಹುದಾಗಿದೆ.

639
01:01:10,610 --> 01:01:19,550
ಇದರಿಂದ ರು ಎಫ್ ಮಾಡುತ್ತದೆ ಮುದ್ರಿಸಲು ಏನು. ನೀವು ರು F ಈಗ ಮಾಡುತ್ತಿರುವ ಮುದ್ರಿಸಲು ಏನನ್ನು ನೋಡುತ್ತಾರೆ?

640
01:01:19,550 --> 01:01:25,720
[ವಿದ್ಯಾರ್ಥಿ] ಸರಿ, ಆದ್ದರಿಂದ ಕೈಗೊಳ್ಳುತ್ತದೆ - ಇದು ಒಂದು ಸರಣಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, something.jpg, ಮತ್ತು ನಂತರ ಅದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

641
01:01:25,720 --> 01:01:30,360
ಹೌದು. ಇದು ಸೃಷ್ಟಿಸುತ್ತದೆ - ಈ ಕೇವಲ ಸ್ಕ್ಯಾನ್ ಎಫ್ ಮತ್ತು ಮುದ್ರಣ ಎಫ್ ನಂತಹ ಮತ್ತೊಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ,

642
01:01:30,360 --> 01:01:37,530
ಅಲ್ಲಿ ಎರಡನೇ ವಾದವು ಅದನ್ನು ಒಳಸೇರಿಸಿದನು ಅಸ್ಥಿರಗಳ ಎಲ್ಲಾ, ರು ಎಂದು ನಾನು ವಿರುದ್ಧವಾಗಿ ಇರಬಹುದು.

643
01:01:37,530 --> 01:01:42,280
ಬಹುಶಃ - ನಾನು ಕೇಸ್ ಎಂದು ಅರ್ಥ. ಆದರೆ ಯಾವುದೇ ವಾದಗಳು ಕ್ರಮವಾಗಿದೆ.

644
01:01:42,280 --> 01:01:45,440
ಇದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಎಲ್ಲಾ ಸೇರಿಸಲು ವಿಶೇಷವೇನು

645
01:01:45,440 --> 01:01:52,250
ತದನಂತರ ನಮ್ಮ ಬಫರ್ ಆಗಿ ಸಂಗ್ರಹಿಸಲು; ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸಂಗ್ರಹಿಸಲು ನೀವು ಅಲ್ಲಿ ಒಂದು ಬಫರ್, ಇದು ಎಂದು ಕರೆ.

646
01:01:52,250 --> 01:02:00,750
ನಾವು ಸರಿಯಾಗಿ ಸ್ವರೂಪದ ಸ್ಟ್ರಿಂಗ್,% d 4 ಆಕ್ರಮಿಸಿದೆ ನಂತರ ಒಳಗೆ ರು ಆಫ್ ಸಂಗ್ರಹಿಸುವ ಮಾಡಲಾಗುತ್ತದೆ.

647
01:02:00,750 --> 01:02:08,080
[ವಿದ್ಯಾರ್ಥಿ] ಈ ಮಾಡಲಿಲ್ಲ ಆದ್ದರಿಂದ, ಕೇವಲ reassigned ಹಿಂದಿರುಗಬಹುದೆಂದು ವೇರಿಯಬಲ್ F ಆಗಿದೆ?

648
01:02:08,080 --> 01:02:18,110
ಹೌದು. ಆದ್ದರಿಂದ ನಾವು ಈ ಮೊದಲೇ ಮೂಲ F ಮುಚ್ಚಿ ಮಾಡಬೇಕು.

649
01:02:18,110 --> 01:02:22,810
ಆದರೆ - ಒಂದು ಎಫ್ ಇಲ್ಲಿ ತೆರೆಯಲು ಇಲ್ಲ ವೇಳೆ ಮತ್ತು ನಂತರ ಕೂಡ, ನಾವು ಹೇಳುವ ಅಗತ್ಯವಿದೆ -

650
01:02:22,810 --> 01:02:29,280
ಹೌದು. ಆದರೆ ನೂರು ವಿವಿಧ ಕಡತಗಳನ್ನು ತೆರೆಯಿತು.

651
01:02:29,280 --> 01:02:37,360
ಸರಿ - [ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ನಾವು ಪ್ರವೇಶಿಸಲು ಅಥವಾ ಸಾಧ್ಯವಾಗದಿರಬಹುದು.

652
01:02:37,360 --> 01:02:44,230
ಸರಿ. ಆದ್ದರಿಂದ ಸ್ಕ್ಯಾನ್ F, ಎಫ್ ಸ್ಕ್ಯಾನ್ F, ಅದೇ ವಿಚಾರವನ್ನು ರೀತಿಯ

653
01:02:44,230 --> 01:02:53,610
ಬದಲಿಗೆ, ಬದಲಿಗೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅದನ್ನು ಸಂಗ್ರಹಿಸಿ, ಇದು ನೀವು ಈಗ ಅನಿಸುತ್ತದೆ

654
01:02:53,610 --> 01:03:02,420
ಒಂದು ತಂತುವಿನ ವಿರುದ್ಧ ತಾಳೆಯಾಗುವ ಒಂದು ಸ್ಟಿಂಗ್ ಮತ್ತು ಮಾದರಿ ಹೋಗುವಾಗ ಮತ್ತು ಅಸ್ಥಿರ ಆಗಿ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ.

655
01:03:02,420 --> 01:03:11,290
ನೀವು 4.jpg ರೀತಿಯ ಮೇಲೆ ಬಿಡಿಸಿ, ಮತ್ತು ಮೊತ್ತವು ಇಂಟ್ x * ಪೂರ್ಣಾಂಕ 4 ಶೇಖರಿಸಿಡಲು ಸ್ಕ್ಯಾನ್ F ಬಳಸಬಹುದು.

656
01:03:11,290 --> 01:03:13,430
ಎಂದು ನಾವು ಸ್ಕ್ಯಾನ್ F ಬಳಸಿ ಮಾಡಬಹುದು.

657
01:03:13,430 --> 01:03:16,300
ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಆಜ್ಞಾ ಸಾಲಿನ ಆ ಮಾಡಲು ಹೋಗುತ್ತದೆ.

658
01:03:16,300 --> 01:03:19,200
ನಾನು ವಾಸ್ತವವಾಗಿ ಈ CS50 ಗ್ರಂಥಾಲಯದ ಏನು ಆಗಿದೆ ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ.

659
01:03:19,200 --> 01:03:29,050
ಆದ್ದರಿಂದ ನೀವು ಹೇಳುವುದಾದರೆ, "ಇಂಟ್ ಪಡೆಯಲು," ಇದು ಸ್ಕ್ಯಾನ್ F-ING ಮುಗಿಯುವ - ಸ್ಕ್ಯಾನ್ F ನೀವು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಮಾರ್ಗ.

660
01:03:29,050 --> 01:03:34,670
ಎಫ್ ಸ್ಕ್ಯಾನ್ F ಒಂದೇ ವಿಷಯವನ್ನು ಹೋಗುವ ಆದರೆ ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಒಂದು ಕಡತವನ್ನು ಬಳಸಿಕೊಂಡು ಇದೆ.

661
01:03:34,670 --> 01:03:41,090
ಇಲ್ಲಿ, ನಾವು ಈ ಕಡತ ಮೇಲೆ ಸ್ಕ್ಯಾನ್ ಮಾಡಲಾಗುತ್ತದೆ.

662
01:03:41,090 --> 01:03:45,460
ನಾವು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಮಾದರಿ 127 ಪಾತ್ರಗಳು ಉದ್ದವಾಗಿದೆ ಕೆಲವು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ

663
01:03:45,460 --> 01:03:48,100
ಹೊಸ ಸಾಲಿನ ನಂತರ

664
01:03:48,100 --> 01:03:54,770
ಹಾಗಾಗಿ ನಿಘಂಟಿನಲ್ಲಿ ರಿಂದ ", ರು ಹೊಂದಾಣಿಕೆ" ನಾವು ಕೇವಲ ಹೇಳಬಹುದು ಬಹಳ ಖಚಿತವಾಗಿ ಆಮ್

665
01:03:54,770 --> 01:03:57,770
ನಾವು ಸಂಭವಿಸಿದಾಗ, ನಾವು ಯಾವುದೇ ಪದ ಎಂದು ಉದ್ದವಾಗಿದೆ ಖಾತರಿ ನೀವು,

666
01:03:57,770 --> 01:04:03,310
ಮತ್ತು ಎಫ್ ಸ್ಕ್ಯಾನ್ F, ನನಗನ್ನಿಸುತ್ತದೆ, ಹೊಸ ಲೈನ್ ನಲ್ಲಿ ಯಾವುದೇ ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತವೆ.

667
01:04:03,310 --> 01:04:06,970
ಆದರೆ ಪಂದ್ಯದಲ್ಲಿ ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಿ, ಮತ್ತು ನಾವು -

668
01:04:06,970 --> 01:04:13,960
[ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಹೊಸ ಲೈನ್ ಇರದೇ ಇದ್ದರೆ, ಅದು ಒಂದು ಪದದ ಭಾಗಗಳು ಹೇಗೆ ಎಂದು?

669
01:04:13,960 --> 01:04:22,900
ಅದು - ಪ್ರತಿ - ನಿಘಂಟು ನೋಡಿ -

670
01:04:22,900 --> 01:04:26,200
ಆದ್ದರಿಂದ ನಿಘಂಟಿನಲ್ಲಿ, ಈ ನಮ್ಮ ಪದಗಳ ಎಲ್ಲಾ.

671
01:04:26,200 --> 01:04:30,500
ಪ್ರತಿಯೊಂದು ಹೊಸ ಹಾದಿಯಲ್ಲಿದೆ.

672
01:04:30,500 --> 01:04:32,510
ಸ್ಕ್ಯಾನ್ ಎಫ್ ಈ ಪದವು ತೆಗೆದುಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ.

673
01:04:32,510 --> 01:04:38,750
ನಾವು ಹೊಸ ಲೈನ್ ಒಳಗೊಂಡಿಲ್ಲ, ಇದನ್ನು ಮುಂದಿನ ಸ್ಕ್ಯಾನ್ F ಕೇವಲ ಹೊಸ ಸಾಲನ್ನು ಓದಲು ಕಾಣಿಸುತ್ತದೆ ಸಾಧ್ಯತೆಯೂ ಇರುತ್ತದೆ.

674
01:04:38,750 --> 01:04:44,180
ಆದರೆ ಹೊಸ ಲೈನ್ ಸೇರಿದಂತೆ ನಂತರ ಕೇವಲ ಹೊಸ ಲೈನ್ ನಿರ್ಲಕ್ಷಿಸುತ್ತವೆ.

675
01:04:44,180 --> 01:04:49,440
ನಾವು ಯಾವಾಗಲೂ ಹೊಸ ಸಾಲಿಗೆ ಯಾವುದೇ ಅಪ್ ಓದುತ್ತಿದ್ದಲ್ಲಿ ರಿಂದ ಆದರೆ, ಪದದ ಭಾಗ ಪಡೆಯಲು ಎಂದಿಗೂ.

676
01:04:49,440 --> 01:04:54,530
[ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ಏನು cissa ನಂತಹ ಪದ "cissa," ಹುಡುಕಲು ವೇಳೆ.

677
01:04:54,530 --> 01:04:57,380
ಅದನ್ನು ಕಂಡು, ಮತ್ತು ಇದು ಪಂದ್ಯದಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಕಾಣಿಸುತ್ತದೆ?

678
01:04:57,380 --> 01:05:05,110
ಇಲ್ಲಿ ನಾವು - ಇದು ಓದಲು ಕಾಣಿಸುತ್ತದೆ - ಈ ನಿಜವಾಗಿ ಒಂದು ಒಳ್ಳೆಯ ಬಿಂದುವಾಗಿದೆ.

679
01:05:05,110 --> 01:05:10,660
ನಾವು ಪ್ರಸ್ತುತ ಬಳಸಿ ಎಂದಿಗೂ ನೀವು - ನಾವು ಹುಡುಕುತ್ತಿರುವ ಪದ ಮೊದಲ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವು.

680
01:05:10,660 --> 01:05:16,460
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್, ಪದ = argv 1.

681
01:05:16,460 --> 01:05:20,020
ನಾವು ಹುಡುಕುತ್ತಿರುವ ಸ್ಟ್ರಿಂಗ್ argv 1.

682
01:05:20,020 --> 01:05:23,290
ನಮ್ಮ ಸ್ಕ್ಯಾನ್ F ಎಲ್ಲಾ ಒಂದು ಪದ ಹುಡುಕುತ್ತಿರುವ ಇಲ್ಲ.

683
01:05:23,290 --> 01:05:28,030
ನಾವು ಸ್ಕ್ಯಾನ್ ಎಫ್ ಜೊತೆ ಏನು ಮಾಡುತ್ತಿದ್ದೀರಿ, ಡಿಕ್ಷನರಿ ಪ್ರತಿಯೊಂದು ಪದವು ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ

684
01:05:28,030 --> 01:05:34,320
ಮತ್ತು ನಂತರ ಒಮ್ಮೆ ನಾವು ಅವುಗಳನ್ನು ಹೋಲಿಸಿ strcmp ಬಳಸಲು ನೀನು ಪದವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

685
01:05:34,320 --> 01:05:39,210
ನಮ್ಮ ಪದ ಹೋಲಿಸಲು ನೀನು ಮತ್ತು ನಾವು ಸೈನ್ ಓದಿ

686
01:05:39,210 --> 01:05:45,110
ಆದ್ದರಿಂದ ಅನಿವಾರ್ಯವಾಗಿ, ನಾವು ಸ್ಕ್ಯಾನ್ FS ಒಂದು ಗುಂಪೇ ಮಾಡುವುದರಿಂದ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು

687
01:05:45,110 --> 01:05:52,130
ಇದು ಕೇವಲ ಆದ್ದರಿಂದ ಸ್ಕ್ಯಾನ್ F ಹಿಂತಿರುಗುವುದು ಅದು ಸಂಭವಿಸಿದಲ್ಲಿ ತನಕ -

688
01:05:52,130 --> 01:05:54,800
ಇದು ಎಲ್ಲಿಯವರೆಗೆ ಹೊಸ ಪದ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ ಮಾಡಿದೆ ಎಂದು, ಒಂದು ಹಿಂತಿರುಗುವುದು

689
01:05:54,800 --> 01:06:01,360
ಮತ್ತು ತಕ್ಷಣ ಅದನ್ನು ಪದವನ್ನು ಹೊಂದಿಸಲು ವಿಫಲವಾಗಿದೆ ಎಂದು ಯಾವುದೋ ಹಿಂತಿರುಗುವುದು.

690
01:06:01,360 --> 01:06:08,440
ನಾವು ವೇರಿಯಬಲ್ ರು ಪ್ರತಿಯೊಂದು ಪದವು ರೇಖೆಯಿಂದ ಸಾಲು ಸಂಗ್ರಹಿಸುವ, ಇಡೀ ನಿಘಂಟು ಮೇಲೆ ಓದುತ್ತಿದ್ದಲ್ಲಿ.

691
01:06:08,440 --> 01:06:17,240
ನಂತರ ನಾವು, ರು ಪದದ ಹೋಲಿಸಿ, ಮತ್ತು ಹೋಲಿಕೆ == 0 ವೇಳೆ ಮಾಡಲಾಗುತ್ತದೆ

692
01:06:17,240 --> 01:06:21,650
strcmp ಪಂದ್ಯದಲ್ಲಿ ಮಾಡಲಾಯಿತು ವೇಳೆ 0 ತರಲು ಸಂಭವಿಸುತ್ತದೆ.

693
01:06:21,650 --> 01:06:31,510
ಅದು 0 ಎಂದು ಆದ್ದರಿಂದ, ನಾವು, ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ, ಎಫ್ ಮುದ್ರಿಸಬಹುದು

694
01:06:31,510 --> 01:06:35,370
ಅಥವಾ ಪದ ನಿಘಂಟಿನಲ್ಲಿ, ಅಥವಾ ನೀವು F ಮುದ್ರಿಸಲು ಬಯಸುವ ಯಾವುದೇ.

695
01:06:35,370 --> 01:06:41,450
ತದನಂತರ - ನಾವು ಎಫ್ ಮತ್ತೆ ಸುಮಾರು ಮುಚ್ಚಿ ಮತ್ತು ಬಯಸುವುದಿಲ್ಲ.

696
01:06:41,450 --> 01:06:50,410
ಈ ನಾವು ಬಯಸುವ ವಿಷಯ ರೀತಿಯ, ಮತ್ತು ನಾವು ನಿಘಂಟಿನಲ್ಲಿ ಪದ ಹುಡುಕುತ್ತಿರುವ ಇಲ್ಲ.

697
01:06:50,410 --> 01:06:56,660
ನಾವು, ನೀವು ಮೊದಲು ಹೇಳಿದ ಹಾಗೆ, ನಾವು ಅವರ ಮಾದರಿ, cissa ನೋಡಲು ಬಯಸಿದರೆ, ಹಾಗೆ ಆಗಲಿಲ್ಲ

698
01:06:56,660 --> 01:07:00,260
ನಾವು ವಿನ್ಯಾಸಕ್ಕಾಗಿ ನೋಡಲು ಬಯಸಿದರೆ, ಅದು ಸಂದರ್ಭದಲ್ಲಿ ವಿಫಲರಾಗಿದ್ದಾರೆ

699
01:07:00,260 --> 01:07:08,010
ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ ಅಲ್ಲ, ಆದರೆ ನಿಘಂಟು ಪದಗಳ ಒಂದು ಇದು ಹೊಂದಿಲ್ಲ ಸಂಭವಿಸಲಿ ಎಂದು. ಏಕೆಂದರೆ

700
01:07:08,010 --> 01:07:13,560
ಆದ್ದರಿಂದ ಈ ಪದವನ್ನು ಹೊಂದಿಸಲು, ಆದರೆ ಪದದ ಈ ಉಪ ಒಂದು ಪದವು ಅಲ್ಲ.

701
01:07:13,560 --> 01:07:17,250
ಆದರೆ ನಾವು ಬಳಸುತ್ತಿರುವ ಹೇಗೆ ಅಲ್ಲ; ನಾವು ಪ್ರತಿ ಪದವನ್ನು ಓದುವ ನೀವು

702
01:07:17,250 --> 01:07:19,740
ನಂತರ ನಾವು ಆ ಶಬ್ದದ ಹೊಂದಿರುತ್ತವೆ ಪದ ಹೋಲಿಸಿ.

703
01:07:19,740 --> 01:07:25,780
ಆದ್ದರಿಂದ ನಾವು ಯಾವಾಗಲೂ ಸಂಪೂರ್ಣ ಪದಗಳನ್ನು ಹೋಲಿಸಿ ಮಾಡುತ್ತಿದ್ದೇವೆ.

704
01:07:25,780 --> 01:07:29,620
ನಾನು ನಂತರ ಅಂತಿಮಗೊಳಿಸಿತು ಪರಿಹಾರಗಳು ಕಳುಹಿಸಬಹುದು.

705
01:07:29,620 --> 01:07:32,050
ಈ ಸುಮಾರು ಸರಿ ಉತ್ತರ ರೀತಿಯ, ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

706
01:07:32,050 --> 01:07:34,720
[ವಿದ್ಯಾರ್ಥಿ ಕಾಮೆಂಟ್, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

707
01:07:34,720 --> 01:07:40,870
ಮೊದಲು ಒಹ್, ನಾನು ತೊಡೆದುಹಾಕಲು ನೀಡಲಿಲ್ಲ? ಚಾರ್ ರು, ನಾವು 127 ಹೇಳಿದರು ಊಹೆ - ನಾನು ದೊಡ್ಡ ಎಂಬುದನ್ನು ಮರೆಯಬೇಡಿ.

708
01:07:40,870 --> 01:07:44,100
ನಾವು 128 ಮಾಡುತ್ತೇನೆ; ಈಗ ರು ಸಾಕಷ್ಟು ದೀರ್ಘವಾಗಿದೆ.

709
01:07:44,100 --> 01:07:46,570
ನಾವು ಏನು ಮುದ್ರಿಸಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

710
01:07:46,570 --> 01:07:56,440
ನಾವು ನಮ್ಮ ಫೈಲ್ ಮುಚ್ಚಲು ಬೇಕು ಎಂದು ನೀನು, ಮತ್ತು ಸರಿ ಉತ್ತರ ಬಗ್ಗೆ ಇರಬೇಕು.

711
01:07:56,440 --> 01:07:59,440
CS50.TV