1
00:00:00,000 --> 00:00:02,210
[Powered by Google Translate] [ದರ್ಶನ - ಸಮಸ್ಯೆ ಸೆಟ್ 6]

2
00:00:02,210 --> 00:00:04,810
[Zamyla ಚಾನ್ - ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,810 --> 00:00:07,240
[ಈ CS50 ಹೊಂದಿದೆ. - CS50.TV]

4
00:00:07,240 --> 00:00:12,180
>> ಹಲೋ, ಎಲ್ಲರೂ, ಮತ್ತು ದರ್ಶನ 6 ಸ್ವಾಗತ: Huff'n ಪಫ್.

5
00:00:12,180 --> 00:00:17,440
Huff'n ಪಫ್ ನಾವು ಏನು ಒಂದು ಹಫ್ಮನ್ ಸಂಕುಚಿತ ಕಡತ ವ್ಯವಹರಿಸುವಾಗ ಏರಲಿದೆ

6
00:00:17,440 --> 00:00:20,740
ನಂತರ, ಮತ್ತೆ ಅದನ್ನು puffing ಅದು decompressing

7
00:00:20,740 --> 00:00:25,810
ನಾವು 0 ಸೆ ಮತ್ತು 1 ಬಳಕೆದಾರ ನಮಗೆ ಕಳುಹಿಸುತ್ತದೆ ಭಾಷಾಂತರಿಸಿ ಇದರಿಂದ

8
00:00:25,810 --> 00:00:30,660
ಮೂಲ ಪಠ್ಯ ಅದನ್ನು ಪುನಃ ಪರಿವರ್ತಿಸಬಹುದು.

9
00:00:30,660 --> 00:00:34,360
ನೀವು ಉಪಕರಣಗಳು ಕೆಲವು ನೋಡಲು ನೀನು ಏಕೆಂದರೆ Pset 6 ಸುಂದರವಾಗಿದೆ ಎಂದು ಹೋಗುತ್ತದೆ

10
00:00:34,360 --> 00:00:41,730
ನೀವು 1 ಬಹಳ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸಿದರೆ pset 4 ಮತ್ತು pset 5 ಮತ್ತು ರೀತಿಯ ಬಳಸಿದ

11
00:00:41,730 --> 00:00:43,830
ನೀವು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು ಬಂದಾಗ.

12
00:00:43,830 --> 00:00:50,110
>> ಸಹ ವಾದಯೋಗ್ಯವಾಗಿ, pset 4 ಮತ್ತು 5 ನಾವು ನೀಡುವ ಅತ್ಯಂತ ಸವಾಲಿನ psets ಇದ್ದರು.

13
00:00:50,110 --> 00:00:53,950
ಈಗ ನಾವು, ಸಿ ಈ 1 ಹೆಚ್ಚು pset ಹೊಂದಿವೆ

14
00:00:53,950 --> 00:00:56,480
ಮತ್ತು ಆ ನಂತರ ನಾವು ವೆಬ್ ಕಾರ್ಯಕ್ರಮವನ್ನು ಇದ್ದೇವೆ.

15
00:00:56,480 --> 00:01:02,310
ಆದ್ದರಿಂದ CS50 ಅತೀ ಕಠಿಣವಾದ ದಿಣ್ಣೆ ಮೇಲೆ ಪಡೆಯಲು ನಿಮ್ಮನ್ನು ಅಭಿನಂದಿಸುತ್ತೇನೆ.

16
00:01:03,630 --> 00:01:09,760
>> Huff'n ಪಫ್ ಮೇಲೆ ಮೂವಿಂಗ್, ಈ pset ನಮ್ಮ ಉಪಕರಣ, ಹಫ್ಮನ್ ಮರಗಳು ಮುಂದುವರೆಸುತ್ತೇವೆ

17
00:01:09,760 --> 00:01:14,700
ಆದ್ದರಿಂದ ಬೈನರಿ ಮರಗಳು ಕೆಲಸ ಆದರೆ ನಿರ್ದಿಷ್ಟವಾಗಿ ಹಫ್ಮನ್ ಮರಗಳು ಕೇವಲ ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

18
00:01:14,700 --> 00:01:16,240
ಹೇಗೆ ಅವರು ನಿರ್ಮಿಸಿದ ಮಾಡುತ್ತಿದ್ದೇವೆ.

19
00:01:16,240 --> 00:01:20,210
ನಂತರ ನಾವು, ಈ pset ವಿತರಿಸುವ ಕೋಡ್ ಒಂದು ಬಹಳಷ್ಟು ಎಂದು ನೀನು

20
00:01:20,210 --> 00:01:22,480
ಮತ್ತು ನಾವು ಕೋಡ್ ಕೆಲವು ಎಂದು ವಾಸ್ತವವಾಗಿ ನೋಡಲು ಬಂದು ವಿಲ್

21
00:01:22,480 --> 00:01:24,670
ನಾವು, ಸಂಪೂರ್ಣವಾಗಿ ಇನ್ನೂ ತಿಳಿಯಲು ಸಾಧ್ಯವಾಗದೆ ಇರಬಹುದು

22
00:01:24,670 --> 00:01:30,080
ಮತ್ತು ಆದ್ದರಿಂದ ಆ ನಂತರ ಅವುಗಳ ಜೊತೆಗೆ. H ಕಡತಗಳನ್ನು. ಸಿ ಕಡತಗಳನ್ನು ಇರಬಹುದು ಆದರೆ

23
00:01:30,080 --> 00:01:34,300
ನಮಗೆ ನಾವು ಆ ಕಾರ್ಯಗಳನ್ನು ಕೆಲಸ ಗೊತ್ತಿಲ್ಲ ಆದ್ದರಿಂದ ಅಗತ್ಯವಿರುವ ಸಾಕಷ್ಟು ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ

24
00:01:34,300 --> 00:01:38,100
ಅಥವಾ ಕನಿಷ್ಠ ತಾವು ಮಾಡಲು ನಿಯಮವಿದೆ - ಅವುಗಳ ಆದಾನಗಳು ಮತ್ತು -

25
00:01:38,100 --> 00:01:40,760
ನಾವು ಕಪ್ಪು ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಏನು ಸಂಭವಿಸುತ್ತಿದೆ ಗೊತ್ತಿಲ್ಲ ಸಹ

26
00:01:40,760 --> 00:01:44,090
ಅಥವಾ ಒಳಗೆ ಕಪ್ಪು ಬಾಕ್ಸ್ ನಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ.

27
00:01:44,090 --> 00:01:49,400
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ಎಂದಿನಂತೆ, ನಾವು, ಹೊಸ ದತ್ತಾಂಶ ರಚನೆಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ

28
00:01:49,400 --> 00:01:51,840
ಆ ಗ್ರಂಥಿಗಳು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಬೆರಳು

29
00:01:51,840 --> 00:01:56,080
ಮತ್ತು ಇಲ್ಲಿ ವಿನ್ಯಾಸ ಪ್ರಕ್ರಿಯೆಗೆ ಕೇವಲ ಒಂದು ಪೆನ್ ಮತ್ತು ಪೇಪರ್ ಹೊಂದಿರುವ

30
00:01:56,080 --> 00:01:58,470
ಮತ್ತು ನೀವು ನಿಮ್ಮ pset ಕೆಲಸ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

31
00:01:58,470 --> 00:02:00,520
ಆದರೆ ಡೀಬಗ್ ಸಮಯದಲ್ಲಿ.

32
00:02:00,520 --> 00:02:06,140
ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಏನು ಕೆಳಗೆ ಸ್ವಲ್ಪ ನಿಮ್ಮ ಪೆನ್ ಮತ್ತು ಪೇಪರ್ ಜೊತೆಗೆ GDB ಹೊಂದಬಹುದು

33
00:02:06,140 --> 00:02:09,320
ಅಲ್ಲಿ ನಿಮ್ಮ ಬಾಣಗಳನ್ನು ಸೂಚಿಸುವ, ಮತ್ತು ಆ ತರಹದ ವಸ್ತುಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ.

34
00:02:09,320 --> 00:02:13,720
>> ಮೊದಲ ಹಫ್ಮನ್ ಮರಗಳು ನೋಡೋಣ.

35
00:02:13,720 --> 00:02:19,600
ಹಫ್ಮನ್ ಮರಗಳು ಪ್ರತಿ ನೋಡ್ 2 ಮಕ್ಕಳಿದ್ದಾರೆ ಅಂದರೆ ದ್ವಿಮಾನ ಮರಗಳು ಇವೆ.

36
00:02:19,600 --> 00:02:24,870
ಹಫ್ಮನ್ ಮರಗಳಲ್ಲಿ ಲಕ್ಷಣ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮೌಲ್ಯಗಳು

37
00:02:24,870 --> 00:02:27,140
fewest ಬಿಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

38
00:02:27,140 --> 00:02:32,690
ನಾವು ಮೋರ್ಸ್ ಕೋಡ್ ಉಪನ್ಯಾಸ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಕಾರ್ಯ ಯಾವ ರೀತಿಯ ಕೆಲವು ಪತ್ರಗಳಲ್ಲಿ ಕಂಡಿತು.

39
00:02:32,690 --> 00:02:38,030
ನೀವು ಉದಾಹರಣೆಗೆ ಒಂದು ಒಂದು ಅಥವಾ ಇ, ಭಾಷಾಂತರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೆ

40
00:02:38,030 --> 00:02:43,940
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಅನುವಾದ ನೀವು, ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಬಿಟ್ಗಳು ಪೂರ್ಣ ಸೆಟ್ ಅನ್ನು ಹೊಂದುವ

41
00:02:43,940 --> 00:02:48,640
ಎಂದು ಸಾಮಾನ್ಯ ಅಕ್ಷಾಂಶ ರೀತಿಯ ನಿಯೋಜಿತವಾದ, ನೀವು, ಕಡಿಮೆ ಮಾಡಲು ಅದನ್ನು ಕುಗ್ಗಿಸುವಾಗ

42
00:02:48,640 --> 00:02:53,730
ತದನಂತರ ನಿರೂಪಿಸಲಾಗಿದೆ ಯಾರು ಅಕ್ಷರಗಳು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿ ಮುಂದೆ ಬಿಟ್ಗಳು ಪ್ರತಿಬಿಂಬಿಸುತ್ತವೆ

43
00:02:53,730 --> 00:02:59,840
ಆ ಅಕ್ಷರಗಳನ್ನು ಕಂಡುಬರುವ ಆವರ್ತನಗಳಲ್ಲಿ ತೂಕಹಾಕುತ್ತವೆ ನೀವು ಆ ನಿಭಾಯಿಸುತ್ತೇನೆ ಕಾರಣ.

44
00:02:59,840 --> 00:03:03,020
ನಾವು ಹಫ್ಮನ್ ಮರಗಳು ಇಲ್ಲಿ ಅದೇ ಆಲೋಚಿಸಿದ್ದರೆ

45
00:03:03,020 --> 00:03:12,360
ಅಲ್ಲಿ ನಾವು ಒಂದು ಸರಣಿ, ನಿರ್ದಿಷ್ಟ ಪಾತ್ರಗಳಿಗೆ ಪಡೆಯಲು ಮಾರ್ಗ ಒಂದು ರೀತಿಯ ಮಾಡುತ್ತಿದ್ದಾರೆ.

46
00:03:12,360 --> 00:03:14,470
ತದನಂತರ ಹೆಚ್ಚಿನ ತರಂಗಾಂತರ ಹೊಂದಿರುವ ಪಾತ್ರಗಳು

47
00:03:14,470 --> 00:03:17,940
fewest ಬಿಟ್ಗಳು ಮೂಲಕ ಹೋಗುವುದಾಗಿ.

48
00:03:17,940 --> 00:03:22,020
>> ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಆ ರೀತಿಯಲ್ಲಿ

49
00:03:22,020 --> 00:03:27,430
ಪಠ್ಯ ಕಂಡುಬರುವ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಇರಿಸುವ ಮೂಲಕ

50
00:03:27,430 --> 00:03:30,630
ಮತ್ತು ಅವುಗಳ ಆವರ್ತನ ಲೆಕ್ಕ, ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.

51
00:03:30,630 --> 00:03:33,880
ಈ ಎರಡೂ ಪತ್ರಗಳನ್ನು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಎಷ್ಟು ಬಾರಿ ಎಣಿಕೆ ಇರಬಹುದು

52
00:03:33,880 --> 00:03:40,270
ಅಥವಾ ಬಹುಶಃ ಪ್ರತಿ ಒಂದು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಷ್ಟು ಎಲ್ಲಾ ಪಾತ್ರಗಳ ಔಟ್ ಶೇಕಡಾವಾರು.

53
00:03:40,270 --> 00:03:44,270
ಆದ್ದರಿಂದ ನೀವು ಏನು, ಒಮ್ಮೆ ಆ ಮ್ಯಾಪ್ ಔಟ್ ಎಲ್ಲಾ ಹೊಂದಿದೆ

54
00:03:44,270 --> 00:03:49,060
ನಂತರ ನೀವು 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ನೋಡಿ ತದನಂತರ ಒಡಹುಟ್ಟಿದವರ ಅವರನ್ನು ಸೇರಲು

55
00:03:49,060 --> 00:03:55,660
ಅಲ್ಲಿ ನಂತರ ಪೋಷಕ ನೋಡ್ ತನ್ನ 2 ಮಕ್ಕಳು ಮೊತ್ತವು ಆವರ್ತನದಲ್ಲಿ ಹೊಂದಿದೆ.

56
00:03:55,660 --> 00:04:00,870
ತದನಂತರ ನೀವು ರೂಢಿ ಹೇಳುತ್ತಾರೆ ಎಡ ನೋಡ್

57
00:04:00,870 --> 00:04:03,770
ನೀವು 0 ಶಾಖೆಯ ನಂತರ ಮೂಲಕ ಅನುಸರಿಸಿ

58
00:04:03,770 --> 00:04:08,140
ತದನಂತರ ಬಲತುದಿಯಲ್ಲಿ ನೋಡ್ 1 ಶಾಖೆಯಾಗಿದೆ.

59
00:04:08,140 --> 00:04:16,040
ನಾವು ಮೋರ್ಸ್ ಸಂಕೇತದಲ್ಲಿ ಕಂಡಿದ್ದರಿಂದ, ಒಂದು gotcha ಎಂದು ನೀವು ಕೇವಲ ಒಂದು ಬೀಪ್ ಶಬ್ದ ಮತ್ತು ಬೀಪ್ ಶಬ್ದ ಹೊಂದಿದ್ದರೆ

60
00:04:16,040 --> 00:04:18,120
ಇದು ಅಸ್ಪಷ್ಟವಾಗಿತ್ತು.

61
00:04:18,120 --> 00:04:22,430
ಇದು 1 ಅಕ್ಷರದ ಆಗಿರಬಹುದು ಅಥವಾ ಇದು 2 ಅಕ್ಷರಗಳ ಅನುಕ್ರಮ ಆಗಿರಬಹುದು.

62
00:04:22,430 --> 00:04:27,790
ಆದ್ದರಿಂದ ಯಾವ ಹಫ್ಮನ್ ಮರಗಳು ಹೊಂದಿದವರಿಗೆ ಪಾತ್ರಗಳ ಸ್ವಭಾವತಃ ಏಕೆಂದರೆ

63
00:04:27,790 --> 00:04:34,140
ಅಥವಾ ನಮ್ಮ ಅಂತಿಮ ನಿಜವಾದ ಪಾತ್ರಗಳು ಶಾಖೆ ಕೊನೆಯ ನೋಡ್ ಎಂದು -

64
00:04:34,140 --> 00:04:39,300
ನಾವು ಎಲೆಗಳನ್ನು ಆ ನೋಡಿ - ಆ ಕಾರಣದಿಂದ ಯಾವುದೇ ದ್ವಂದ್ವಾರ್ಥತೆಯನ್ನು ಇರುತ್ತದೆ ಸಾಧ್ಯವಿಲ್ಲ

65
00:04:39,300 --> 00:04:45,160
ನೀವು ಬಿಟ್ಗಳು ಸರಣಿ ಎನ್ಕೋಡ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಇದು ಅಕ್ಷರದ ಪರಿಭಾಷೆಯಲ್ಲಿ

66
00:04:45,160 --> 00:04:50,670
ಏಕೆಂದರೆ 1 ಅಕ್ಷರದ ಪ್ರತಿನಿಧಿಸುವ ಬಿಟ್ಗಳು ಉದ್ದಕ್ಕೂ ಎಲ್ಲಿಯೂ

67
00:04:50,670 --> 00:04:55,960
ನೀವು ಇನ್ನೊಂದು ಇಡೀ ಅಕ್ಷರದ ಎದುರಿಸಿದರೆ, ಮತ್ತು ಯಾವುದೇ ಗೊಂದಲ ಇರುವುದಿಲ್ಲ.

68
00:04:55,960 --> 00:04:58,430
ಆದರೆ ನಾವು ನೀವು ಹುಡುಗರಿಗೆ ವಾಸ್ತವವಾಗಿ ಕಾಣಬಹುದಾಗಿದೆ ಉದಾಹರಣೆಗಳು ಆಗಿ ಹೋಗುತ್ತೇನೆ ಎಂದು

69
00:04:58,430 --> 00:05:02,120
ಬದಲು ನಮಗೆ ಕೇವಲ ಸತ್ಯ ಎಂದು ತಿಳಿಸುವ.

70
00:05:02,120 --> 00:05:06,390
>> ನ ಒಂದು ಹಫ್ಮನ್ ಮರದ ಒಂದು ಸರಳ ಉದಾಹರಣೆ ನೋಡೋಣ.

71
00:05:06,390 --> 00:05:09,380
ನಾನು 12 ಪಾತ್ರಗಳು ಉದ್ದವಾಗಿದೆ ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿರುತ್ತವೆ.

72
00:05:09,380 --> 00:05:14,010
ನಾನು 6 Bs, ಮತ್ತು 2 ಸಿ, 4 ಹೊಂದಿರುತ್ತವೆ.

73
00:05:14,010 --> 00:05:17,270
ನನ್ನ ಮೊದಲ ಹೆಜ್ಜೆ ಎಣಿಸಲು ಎಂದು.

74
00:05:17,270 --> 00:05:20,760
ಎ ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ? ಇದು ಸಾಲಿನಲ್ಲಿ 4 ಬಾರಿ ಕಂಡುಬರುತ್ತದೆ.

75
00:05:20,760 --> 00:05:25,060
ಬಿ 6 ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು C 2 ಬಾರಿ ಕಂಡುಬರುತ್ತದೆ.

76
00:05:25,060 --> 00:05:28,970
ಸ್ವಾಭಾವಿಕವಾಗಿ, ನಾನು, ಹೆಚ್ಚಾಗಿ ಬಿ ಬಳಸಿ ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

77
00:05:28,970 --> 00:05:35,970
ಆದ್ದರಿಂದ ನಾನು ಬಿಟ್ಗಳ fewest ಸಂಖ್ಯೆ, 0 ಸೆ ಮತ್ತು 1 ಗಳ fewest ಸಂಖ್ಯೆಯ ಬಿ ಪ್ರತಿನಿಧಿಸಲು ಬಯಸುತ್ತೇನೆ.

78
00:05:35,970 --> 00:05:42,600
ತದನಂತರ ನಾನು ಸಿ ಹಾಗೂ 0 ಸೆ ಮತ್ತು 1 ಹೆಚ್ಚಿನ ಪ್ರಮಾಣವನ್ನು ಅಗತ್ಯವಿದೆ ನಿರೀಕ್ಷೆ ಪಡೆಯಲಿದ್ದೇನೆ.

79
00:05:42,600 --> 00:05:48,550
ಮೊದಲ ನಾನು ಇಲ್ಲಿ ಏನು ನಾನು ಆವರ್ತನ ಪರಿಭಾಷೆಯಲ್ಲಿ ಏರುವ ಇರಿಸಿತು ಇದೆ.

80
00:05:48,550 --> 00:05:52,710
ನಾವು ಸಿ ಮತ್ತು ಎ, ಆ ನಮ್ಮ 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಎಂದು ನೋಡಿ.

81
00:05:52,710 --> 00:06:00,290
, ನಾವು ಮೂಲ ನೋಡ್ ರಚಿಸಿ, ಮತ್ತು ಪೋಷಕ ನೋಡ್ ಇದು ಸಂಬಂಧಿಸಿದ ಪತ್ರವನ್ನು ಹೊಂದಿಲ್ಲ

82
00:06:00,290 --> 00:06:05,070
ಆದರೆ ಮೊತ್ತವು ಆವರ್ತನದಲ್ಲಿ, ಹೊಂದಿದೆ.

83
00:06:05,070 --> 00:06:08,780
ಮೊತ್ತ 6 ಇದು 2 + 4, ಆಗುತ್ತದೆ.

84
00:06:08,780 --> 00:06:10,800
ನಂತರ ನಾವು ಎಡ ಶಾಖೆ ಅನುಸರಿಸಿ.

85
00:06:10,800 --> 00:06:14,970
ನಾವು 6 ನೋಡ್ನಲ್ಲಿ ಆಗಿದ್ದರೆ, ಆಗ ಸಿ ಪಡೆಯಲು 0 ಅನುಸರಿಸಿ

86
00:06:14,970 --> 00:06:17,450
ನಂತರ 1 ಎ ಪಡೆಯಲು

87
00:06:17,450 --> 00:06:20,300
ಈಗ ನಾವು 2 ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

88
00:06:20,300 --> 00:06:23,920
ನಾವು ಮೌಲ್ಯವನ್ನು 6 ಮತ್ತು ನಂತರ ನಾವು ಮೌಲ್ಯವನ್ನು 6 ಇನ್ನೊಂದು ನೋಡ್ ಹೊಂದಿರುತ್ತವೆ.

89
00:06:23,920 --> 00:06:28,550
ಮತ್ತು ಆದ್ದರಿಂದ ಆ 2 ಕಡಿಮೆ 2 ಆದರೆ ಬಿಡಲಾಗಿದೆ ಎಂದು ಕೇವಲ 2, ಕೇವಲ

90
00:06:28,550 --> 00:06:33,820
ಆದ್ದರಿಂದ ನಾವು ಮೊತ್ತವು 12 ಎಂಬ ಮತ್ತೊಂದು ಪೋಷಕರು ಆ ಸೇರಲು.

91
00:06:33,820 --> 00:06:36,300
ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಹಫ್ಮನ್ ಮರದ ಹೊಂದಿವೆ

92
00:06:36,300 --> 00:06:40,020
ಬಿ ಪಡೆಯಲು ಅಲ್ಲಿ, ಕೇವಲ ಬಿಟ್ 1 ಎಂದು

93
00:06:40,020 --> 00:06:45,430
ಮತ್ತು ನಂತರ ಒಂದು ಪಡೆಯಲು ನಾವು ಸಿ 00 ಹೊಂದಿರುವ ನಂತರ 01 ಮತ್ತು ಎಂದು.

94
00:06:45,430 --> 00:06:51,300
ಇಲ್ಲಿ ನಾವು ಮೂಲಭೂತವಾಗಿ ನಾವು 1 ಅಥವಾ 2 ಬಿಟ್ಗಳು ಎರಡೂ ಈ ಅಕ್ಷರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ನೀವು ನೋಡಿ

95
00:06:51,300 --> 00:06:55,160
ಅಲ್ಲಿ ಭವಿಷ್ಯ ಬಿ, ಕನಿಷ್ಠ ಹೊಂದಿದೆ.

96
00:06:55,160 --> 00:07:01,730
ನಂತರ, ನಾವು ಸಿ ಬಹುತೇಕ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ, ಆದರೆ ಇದು ಒಂದು ಸಣ್ಣ ಹಫ್ಮನ್ ಮರದ ರಿಂದ

97
00:07:01,730 --> 00:07:06,020
ನಂತರ ಒಂದು ಸಹ ಎಲ್ಲೋ ಮಧ್ಯದಲ್ಲಿ ವಿರುದ್ಧವಾಗಿ 2 ಬಿಟ್ಗಳು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

98
00:07:07,820 --> 00:07:11,070
>> ಕೇವಲ ಹಫ್ಮನ್ ಮರದ ಇನ್ನೊಂದು ಸರಳ ಉದಾಹರಣೆಗೆ ಮೇಲೆ ಹೋಗಿ,

99
00:07:11,070 --> 00:07:19,570
ನೀವು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿವೆ ಹೇಳುತ್ತಾರೆ "ಹಲೋ."

100
00:07:19,570 --> 00:07:25,360
ನೀವು ಏನು ನೀವು ಎಷ್ಟು ಬಾರಿ ಎಚ್ ಈ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಹೇಳುತ್ತಿದ್ದರು ಮೊದಲ?

101
00:07:25,360 --> 00:07:34,200
ಎಚ್ ಒಮ್ಮೆ ತದನಂತರ ಇ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಒಮ್ಮೆ ಮತ್ತು ನಾವು ಎರಡು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ L ಹೊಂದಿವೆ

102
00:07:34,200 --> 00:07:36,580
ಮತ್ತು ಒ ಬಾರಿ ಕಾಣಿಸಿಕೊಂಡರು.

103
00:07:36,580 --> 00:07:44,310
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಬಿಟ್ಗಳು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ಮೂಲಕ ನಿರೂಪಿಸಲಾಗಿದೆ ಯಾವ ಅಕ್ಷರದ ನಿರೀಕ್ಷಿಸಬಹುದು?

104
00:07:44,310 --> 00:07:47,450
[ವಿದ್ಯಾರ್ಥಿ] ಎಲ್. >> ಎಲ್. ಹೌದು. L ಹಕ್ಕು.

105
00:07:47,450 --> 00:07:50,730
ನಾವು L ಬಿಟ್ಗಳು ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ನಿರೂಪಿಸಲಾಗಿದೆ ಎಂಬ ನಂಬುಗೆ

106
00:07:50,730 --> 00:07:55,890
ಏಕೆಂದರೆ L "ಹಲೋ." ಸ್ಟ್ರಿಂಗ್ ಅತ್ಯಂತ ಬಳಸಲಾಗುತ್ತದೆ

107
00:07:55,890 --> 00:08:04,280
ಈಗ ನಾನು ಹೋಗುವ ನನಗೆ ಈ ಗ್ರಂಥಿಗಳು ಅವಾಂತ ಇದೆ.

108
00:08:04,280 --> 00:08:15,580
ನಾನು ಒ ಇದು ಇ ಇದು ಮತ್ತೊಂದು 1, ಮತ್ತು ನಂತರ ಒಂದು 1, ಎಚ್ ಇದು, 1, ಮತ್ತು -

109
00:08:15,580 --> 00:08:23,410
L ಇದು, ನಂತರ 2 - ಈಗ ನಾನು ಸಲುವಾಗಿ ಅವರನ್ನು ಇರಿಸುವ ನುಡಿದರು.

110
00:08:23,410 --> 00:08:32,799
ಆಗ ನಾನು ಒಂದು ಹಫ್ಮನ್ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ರೀತಿಯಲ್ಲಿ ಕನಿಷ್ಠ ಫ್ರೀಕ್ವೆನ್ಸೀಸ್ 2 ಘಟಕಗಳು ಪಡೆಯುವುದು ಎಂದು ಹೇಳುತ್ತಾರೆ

111
00:08:32,799 --> 00:08:38,010
ಮತ್ತು ಪೋಷಕ ನೋಡ್ ರಚಿಸುವ ಮೂಲಕ ಒಡಹುಟ್ಟಿದವರ ಮಾಡಿ.

112
00:08:38,010 --> 00:08:41,850
ಇಲ್ಲಿ ನಾವು ಕಡಿಮೆ ತರಂಗಾಂತರ ಜೊತೆ 3 ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಅವರು ಎಲ್ಲಾ 1 ಆರ್.

113
00:08:41,850 --> 00:08:50,620
ಇಲ್ಲಿ ನಾವು ಮೊದಲ ಲಿಂಕ್ ಎಂದು ನೀನು ಆಯ್ಕೆ.

114
00:08:50,620 --> 00:08:54,850
ಲೆಟ್ಸ್ ನಾನು H ಮತ್ತು ಇ ಆಯ್ಕೆ ಹೇಳುತ್ತಾರೆ.

115
00:08:54,850 --> 00:09:01,150
1 ಮೊತ್ತವು + 1 2, ಆದರೆ ಈ ನೋಡ್ ಇದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಪತ್ರವನ್ನು ಹೊಂದಿಲ್ಲ.

116
00:09:01,150 --> 00:09:04,440
ಇದು ಕೇವಲ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

117
00:09:04,440 --> 00:09:10,950
ಈಗ ನಾವು ಮುಂದಿನ 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ನೋಡಲು.

118
00:09:10,950 --> 00:09:15,590
ಆ 2 ಮತ್ತು 1. ಆ ಎರಡೂ ಆ 2 ಆಗಿರಬಹುದು, ಆದರೆ ನಾನು ಈ ಒಂದು ಆಯ್ಕೆ ಪಡೆಯಲಿದ್ದೇನೆ.

119
00:09:15,590 --> 00:09:18,800
ಮೊತ್ತ 3.

120
00:09:18,800 --> 00:09:26,410
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾನು ಮಾತ್ರ ಆದ್ದರಿಂದ 5 ಆಗುತ್ತದೆ ಎಂದು, 2 ಉಳಿದಿದೆ.

121
00:09:26,410 --> 00:09:32,010
ನಾನು ಆ ಎನ್ಕೋಡಿಂಗ್ ಭರ್ತಿ ವೇಳೆ ನಂತರ ಇಲ್ಲಿ, ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿತ್ತು,

122
00:09:32,010 --> 00:09:37,480
1 ಸೆ ಯಾವಾಗಲೂ ಬಲ ಶಾಖೆ ಮತ್ತು 0 ಸೆ ಎಡ ಒಂದು ಅವು.

123
00:09:37,480 --> 00:09:45,880
ನಾವು 2 ರಿಂದ ಕೇವಲ 1 ಬಿಟ್ ಮತ್ತು ನಂತರ O ಅದಕ್ಕೆ ನಿರೂಪಿಸಲಾಗಿದೆ L ಹೊಂದಿವೆ

124
00:09:45,880 --> 00:09:52,360
ನಂತರ 2 ಇ ಮತ್ತು ನಂತರ H 3 ಬಿಟ್ಗಳ ಕೆಳಗೆ ಬೀಳುತ್ತದೆ.

125
00:09:52,360 --> 00:09:59,750
ಆದ್ದರಿಂದ ನೀವು "ಹಲೋ" ಈ ಸಂದೇಶವನ್ನು ಹರಡಬಹುದು ಬದಲಿಗೆ ವಾಸ್ತವವಾಗಿ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿ

126
00:09:59,750 --> 00:10:02,760
ಕೇವಲ 0 ಸೆ ಮತ್ತು 1 ರಿಂದ.

127
00:10:02,760 --> 00:10:07,910
ಆದಾಗ್ಯೂ, ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಾವು ನಮ್ಮ ಆವರ್ತನ ಜೊತೆಗೂ ನಂಟು ಹೊಂದಿದ್ದರು ಎಂದು ನೆನಪಿಡಿ.

128
00:10:07,910 --> 00:10:11,900
ನಾವು ಎರಡೂ ಬಹುಶಃ ಮೊದಲ ಎಚ್ ಮತ್ತು O ಸೇರಿದರು ಸಾಧ್ಯವಿಲ್ಲ.

129
00:10:11,900 --> 00:10:15,730
ಅಥವಾ ನಂತರ ನಾವು 2 ನಿರೂಪಿಸಲಾಗಿದೆ L ಬೀರಿದ ಮೇಲೆ

130
00:10:15,730 --> 00:10:19,410
ಅಲ್ಲದೇ 2 ರಿಂದ ನಿರೂಪಿಸಲಾಗಿದೆ ಒಂದು ಸೇರಿದರು, ನಾವು ಎರಡೂ ಒಂದು ಲಿಂಕ್ ಇರಬಹುದು.

131
00:10:19,410 --> 00:10:23,630
>> ಆದ್ದರಿಂದ ನೀವು ನೆನಪಿನಲ್ಲಿಡಲು 0 ಸೆ ಮತ್ತು 1, ವಾಸ್ತವವಾಗಿ ಖಾತರಿ ಇಲ್ಲ

132
00:10:23,630 --> 00:10:27,090
ಸ್ವೀಕರಿಸುವವರ ಸಂಪೂರ್ಣವಾಗಿ ಬಲ ಬ್ಯಾಟ್ ಆಫ್ ನಿಮ್ಮ ಸಂದೇಶವನ್ನು ಓದಬಹುದು

133
00:10:27,090 --> 00:10:30,490
ಅವರು ನೀವು ಎಂಬ ನಿರ್ಧಾರವನ್ನು ಗೊತ್ತಿಲ್ಲ ಎಂಬ ಕಾರಣಕ್ಕೆ.

134
00:10:30,490 --> 00:10:34,920
ನಾವು ಹಫ್ಮನ್ ಒತ್ತಡಕ ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ,

135
00:10:34,920 --> 00:10:40,090
ಹೇಗಾದರೂ ನಾವು ನಿರ್ಧರಿಸಿದ್ದಾರೆ ಹೇಗೆ ನಮ್ಮ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುವವರ ಹೇಳಲು ಹೊಂದಿವೆ -

136
00:10:40,090 --> 00:10:43,470
ಅವರು ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ರೀತಿಯ ಅವಶ್ಯಕತೆ

137
00:10:43,470 --> 00:10:46,580
ಸಂಕುಚಿತ ಸಂದೇಶವನ್ನು ಜೊತೆಗೆ.

138
00:10:46,580 --> 00:10:51,490
ಅವರು, ಮರ ವಾಸ್ತವವಾಗಿ ತೋರುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಬೇಕು

139
00:10:51,490 --> 00:10:55,450
ನಾವು ವಾಸ್ತವವಾಗಿ ಆ ನಿರ್ಧಾರಗಳನ್ನು ಹೇಗೆ.

140
00:10:55,450 --> 00:10:59,100
>> ಇಲ್ಲಿ ನಾವು, ನಿಜವಾದ ಎಣಿಕೆ ಆಧರಿಸಿ ಉದಾಹರಣೆಗಳು ಮಾಡಿದಿರಿ

141
00:10:59,100 --> 00:11:01,550
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ಒಂದು ಹಫ್ಮನ್ ಮರದ ಹೊಂದಬಹುದು

142
00:11:01,550 --> 00:11:05,760
ಆವರ್ತನೆಯ ಆಧಾರದಲ್ಲಿ ಅಕ್ಷರಗಳು ಕಂಡುಬರುತ್ತವೆ, ಮತ್ತು ನಿಖರವಾದ ಅದೇ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ ಇದು.

143
00:11:05,760 --> 00:11:09,090
ಇಲ್ಲಿ ನಾನು, ಶೇಕಡಾವಾರು ಅಥವಾ ಭಿನ್ನರಾಶಿ ಪರಿಭಾಷೆಯಲ್ಲಿ ಅದು ವ್ಯಕ್ತಪಡಿಸುವ ನಾನು

144
00:11:09,090 --> 00:11:11,290
ಮತ್ತು ಇಲ್ಲಿ ಸರಿಯಾದ ಒಂದೇ.

145
00:11:11,290 --> 00:11:15,300
ನಾನು, 2 ಕಡಿಮೆ, ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ, ಕಡಿಮೆ ಮುಂದಿನ 2, ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ ಹೇಗೆ

146
00:11:15,300 --> 00:11:19,390
ನಾನು ಸಂಪೂರ್ಣ ಮರದ ತನಕ.

147
00:11:19,390 --> 00:11:23,610
ನಾವು ನಾವು ಶೇಕಡಾವಾರು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ ಯಾವುದೇ ರೀತಿ, ಇಲ್ಲ ಸಹ

148
00:11:23,610 --> 00:11:27,760
ನಾವು ವಸ್ತುಗಳ ವಿಭಜಿತ ಮತ್ತು ದಶಮಾಂಶಗಳು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಅರ್ಥ ಅಥವಾ ಬದಲಿಗೆ ತೇಲುತ್ತದೆ ಎಂದು

149
00:11:27,760 --> 00:11:30,900
ನಾವು ಒಂದು ತಲೆಯ ಅಕ್ಷಾಂಶ ರಚನೆಗಳ ಬಗ್ಗೆ ಥಿಂಕಿಂಗ್.

150
00:11:30,900 --> 00:11:32,540
ನಾವು ಫ್ಲೋಟ್ಗಳು ಬಗ್ಗೆ ಏನು ಗೊತ್ತು?

151
00:11:32,540 --> 00:11:35,180
ನಾವು ಫ್ಲೋಟ್ಗಳು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಒಂದು ಸಾಮಾನ್ಯ ತೊಂದರೆ ಏನು?

152
00:11:35,180 --> 00:11:38,600
[ವಿದ್ಯಾರ್ಥಿ] ನಿಖರವಲ್ಲದ ಅಂಕಗಣಿತದ. >> ಹೌದು. ನಿಖರವಲ್ಲದಿರುವಿಕೆ.

153
00:11:38,600 --> 00:11:43,760
ಏಕೆಂದರೆ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ನಿಖರವಲ್ಲದಿರುವಿಕೆ ಈ pset ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಎಷ್ಟು

154
00:11:43,760 --> 00:11:49,450
ನಾವು ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು, ನಾವು ವಾಸ್ತವವಾಗಿ ಎಣಿಕೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು.

155
00:11:49,450 --> 00:11:54,880
ನೀವು ಇಲ್ಲಿ ರಚನೆ ಮತ್ತೆ ನೋಡಿದರೆ, ಒಂದು ಹಫ್ಮನ್ ನೋಡ್ ಆಲೋಚಿಸಬೇಕು ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ

156
00:11:54,880 --> 00:12:01,740
ನೀವು ಹಸಿರು ಚರಾಂಕಗಳ ನೋಡಿದರೆ ಇದು ಸಂಬಂಧಿಸಿದ ಒಂದು ಆವರ್ತನ ಹೊಂದಿದೆ

157
00:12:01,740 --> 00:12:08,760
ಹಾಗೆಯೇ ಅದರ ಎಡಕ್ಕೆ ಒಂದು ನೋಡ್ ಮತ್ತು ಅದರ ಬಲಕ್ಕೆ ಒಂದು ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

158
00:12:08,760 --> 00:12:13,970
ತದನಂತರ ಕೆಂಪು ಬಣ್ಣದವು ಸಹ ಅವುಗಳನ್ನು ಸಂಬಂಧಿಸಿದ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿದೆ.

159
00:12:13,970 --> 00:12:18,900
ನಾವು, ಪೋಷಕರು ಮತ್ತು ನಂತರ ಅಂತಿಮ ಗ್ರಂಥಿಗಳು ಪ್ರತ್ಯೇಕ ಬಿಡಿಗಳ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ

160
00:12:18,900 --> 00:12:23,680
ಇದು ನಾವು ಎಲೆಗಳು ಎಂದು ನೋಡಿ, ಆದರೆ ಆ ಕೇವಲ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

161
00:12:23,680 --> 00:12:31,050
ಪ್ರತಿ ನೋಡ್ ನಾವು ಒಂದು ಅಕ್ಷರ, ಆ ನೋಡ್ ಪ್ರತಿನಿಧಿಸುವ ಚಿಹ್ನೆ ನಿಮಗಿದೆ

162
00:12:31,050 --> 00:12:40,490
ನಂತರ ಒಂದು ಆವರ್ತನ ಮತ್ತು ಅದರ ಎಡ ಮಗು ಮತ್ತು ಅದರ ಬಲ ಮಗುವಿಗೆ ಒಂದು ಪಾಯಿಂಟರ್.

163
00:12:40,490 --> 00:12:45,680
ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ ಅವು ಎಲೆಗಳು ಕೂಡ ನೋಡ್ ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿರುತ್ತದೆ

164
00:12:45,680 --> 00:12:49,550
ತಮ್ಮ ಎಡ ಮತ್ತು ಅವರ ಬಲಕ್ಕೆ, ಆದರೆ ಆ ಮೌಲ್ಯಗಳು ನಿಜವಾದ ಗ್ರಂಥಿಗಳು ತೋರುತ್ತಿರುವಂತೆ ಕಾರಣ,

165
00:12:49,550 --> 00:12:53,970
ತಮ್ಮ ಮೌಲ್ಯವನ್ನು ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಸಾಂಕೇತಿಕಕೊಂಡಿಯು. >> ಸಾಂಕೇತಿಕಕೊಂಡಿಯು. ನಿಖರವಾಗಿ.

166
00:12:53,970 --> 00:12:58,430
ಇಲ್ಲಿ ನೀವು ಫ್ಲೋಟ್ಗಳು ರಲ್ಲಿ ತರಂಗಾಂತರ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಎಂಬುದರ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ

167
00:12:58,430 --> 00:13:02,130
ಆದರೆ, ಪೂರ್ಣಾಂಕಗಳು ಜೊತೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು

168
00:13:02,130 --> 00:13:06,780
ಆದ್ದರಿಂದ ನಾನು ಎಲ್ಲಾ ದತ್ತಾಂಶವನ್ನು ರೀತಿಯ ಬದಲಾವಣೆ.

169
00:13:06,780 --> 00:13:09,700
>> ನ ಸಂಕೀರ್ಣ ಉದಾಹರಣೆಗೆ ಒಂದು ಸ್ವಲ್ಪ ಮೇಲೆ ಹೋಗಿ ನೋಡೋಣ.

170
00:13:09,700 --> 00:13:13,360
ಆದರೆ ಈಗ ನಾವು ಸರಳ ಸೋನಾರ್ಗಳು ಮಾಡಿದ ಅದು ಕೇವಲ ಒಂದೇ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ.

171
00:13:13,360 --> 00:13:20,290
ನೀವು 2 ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಹುಡುಕಲು, ಆವರ್ತನಗಳಲ್ಲಿ ಮೊತ್ತವು

172
00:13:20,290 --> 00:13:22,450
ಮತ್ತು, ನಿಮ್ಮ ಮೂಲ ನೋಡ್ ಹೊಸ ಆವರ್ತನ ಇಲ್ಲಿದೆ

173
00:13:22,450 --> 00:13:29,310
ಇದು ನಂತರ 1 ಶಾಖೆ 0 ಶಾಖೆ ಮತ್ತು ಬಲ ತನ್ನ ಎಡ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

174
00:13:29,310 --> 00:13:34,200
ನಾವು ಸ್ಟ್ರಿಂಗ್ "ಈ cs50 ಹೊಂದಿದೆ," ಇದ್ದರೆ ನಾವು, ಟಿ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಎಷ್ಟು ಬಾರಿ ಲೆಕ್ಕ

175
00:13:34,200 --> 00:13:38,420
H ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ, ಇ, ಎಸ್, ಸಿ, 5, 0.

176
00:13:38,420 --> 00:13:42,010
ನಂತರ ಏನು ನಾನು ಇಲ್ಲಿ ಮಾಡಿದರು, ನಾನು ನೆಟ್ಟ ಕೆಂಪು ನೋಡ್ಗಳ ಜೊತೆ ಆಗಿದೆ

177
00:13:42,010 --> 00:13:48,530
ನಾನು ನನ್ನ ಮರದ ಕೆಳಭಾಗದಲ್ಲಿ ಅಂತಿಮವಾಗಿ ಈ ಪಾತ್ರಗಳು ಹೊಂದಿರುವ ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳಿದರು.

178
00:13:48,530 --> 00:13:51,740
ಆ ಎಲೆಗಳನ್ನು ಎಲ್ಲಾ ಮುಂದುವರೆಸುತ್ತೇವೆ.

179
00:13:51,740 --> 00:13:58,200
ನಂತರ ಏನು ನಾನು, ನಾನು ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ತರಂಗಾಂತರ ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ

180
00:13:58,200 --> 00:14:02,950
ಮತ್ತು ಈ ವಾಸ್ತವವಾಗಿ pset ಕೋಡ್ ಅದು ಹೇಳಿದರು

181
00:14:02,950 --> 00:14:07,550
ಇದು ಆವರ್ತನ ಅದಕ್ಕೆ ರೀತಿಯ ಇದು ತದನಂತರ ವರ್ಣಮಾಲೆಯ ಹೊಂದಿದೆ.

182
00:14:07,550 --> 00:14:13,870
ಆದ್ದರಿಂದ ಆವರ್ತನ ಅದಕ್ಕೆ ವರ್ಣಮಾಲೆಯ ಮೊದಲ ತದನಂತರ ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ.

183
00:14:13,870 --> 00:14:18,520
ನಂತರ ಏನು ನಾನು ಎಂದು ನಾನು 2 ಕಡಿಮೆ ಕಂಡುಕೊಳ್ಳಲಿರುವ ಹೊಂದಿದೆ. ಆ 0 ಮತ್ತು 5 ರ.

184
00:14:18,520 --> 00:14:22,390
ನಾನು ಅವುಗಳನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ, ಮತ್ತು ಆ 2 ನ. ನಂತರ ನಾನು ಮುಂದಿನ 2 ಕಡಿಮೆ ಪತ್ತೆ, ಮುಂದುವರಿಯಿತು.

185
00:14:22,390 --> 00:14:26,100
ಆ ಎರಡು 1 ಸೆ, ಮತ್ತು ಆ ಜೊತೆಗೆ 2 ಸ್ಥಾನವನ್ನು ಪಡೆಯಿತು.

186
00:14:26,100 --> 00:14:31,570
ಈಗ ನನ್ನ ಮುಂದಿನ ಹಂತದಲ್ಲಿ, ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಸೇರುವ ಏರಲಿದೆ ತಿಳಿದಿದೆ

187
00:14:31,570 --> 00:14:41,380
ಇದು, 1 ಟಿ, ಮತ್ತು ನಂತರ ಆವರ್ತನ ಎಂದು 2 ಹೊಂದಿರುವ ನೋಡ್ಗಳು ಒಂದು ಆಯ್ಕೆ.

188
00:14:41,380 --> 00:14:44,560
ಇಲ್ಲಿ ನಾವು 3 ಆಯ್ಕೆಗಳಿವೆ.

189
00:14:44,560 --> 00:14:47,980
ನಾನು ಸ್ಲೈಡ್ಗಾಗಿ ಮಾಡಲು ಹೋಗುವ ನನಗೆ ಕೇವಲ ದೃಷ್ಟಿ ನೀವು ಅವುಗಳನ್ನು ಮರುಹೊಂದಿಸಿ ಇದೆ

190
00:14:47,980 --> 00:14:51,790
ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ನಿರ್ಮಿಸುವ ನಾನು ಹೇಗೆ ನೋಡಬಹುದು.

191
00:14:51,790 --> 00:14:59,040
ಕೋಡ್ ಮತ್ತು ನಿಮ್ಮ ವಿತರಣೆ ಕೋಡ್ ಮಾಡಲು ಏನಾಗುತ್ತಿದೆ ಟಿ ಒಂದು ಸೇರಲು ಎಂದು

192
00:14:59,040 --> 00:15:01,410
0 ಮತ್ತು 5 ಘಟಕ.

193
00:15:01,410 --> 00:15:05,060
ಆದ್ದರಿಂದ ನಂತರ 3 ಸಂಕಲನವನ್ನು, ಮತ್ತು ನಾವು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಸಲು ನಾವು.

194
00:15:05,060 --> 00:15:08,660
2 ಮತ್ತು 2 ಈಗ ಆದ್ದರಿಂದ, 4 ಆ ಮೊತ್ತವು ಕಡಿಮೆ.

195
00:15:08,660 --> 00:15:12,560
ಎಲ್ಲರೂ ಇಲ್ಲಿಯವರೆಗೆ ನಂತರ? ಸರಿ.

196
00:15:12,560 --> 00:15:16,410
ಆ ನಂತರ ನಾವು, 3 ಮತ್ತು ಸೇರಿಸಲಾಗಿದೆ ಬೇಕಿರುವ 3

197
00:15:16,410 --> 00:15:21,650
ನೀವು ತುಂಬಾ ಗೊಂದಲಮಯ ಪಡೆಯಲು ಅದು ದೃಷ್ಟಿ ಆದ್ದರಿಂದ ನೋಡಬಹುದು ಆದ್ದರಿಂದ ಆದ್ದರಿಂದ ಮತ್ತೆ ನಾನು ಅದನ್ನು ಬದಲಿಸುವ ನುಡಿದರು.

198
00:15:21,650 --> 00:15:25,740
ನಾವು ಕೇವಲ 2 ಗ್ರಂಥಿಗಳು ಹೊಂದಿರುವ ನಂತರ ನಾವು 6 ಹೊಂದಿವೆ, ಮತ್ತು ನಂತರ ನಮ್ಮ ಅಂತಿಮ ಹಂತದ ಈಗ

199
00:15:25,740 --> 00:15:30,440
ನಾವು 10 ಇದು ನಮ್ಮ ಮರ, ಮೂಲ ಮಾಡಲು ಆ ಮೊತ್ತ.

200
00:15:30,440 --> 00:15:34,100
ಪ್ರತಿ ನೋಡ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಮತ್ತು ಸಂಖ್ಯೆ 10, ಅರ್ಥವಿಲ್ಲ

201
00:15:34,100 --> 00:15:40,750
ತಮ್ಮ ಮೌಲ್ಯವನ್ನು ಅವುಗಳ ಆವರ್ತನ ಸಂಖ್ಯೆ, ಅವರು ಪಂಕ್ತಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡರು ಎಷ್ಟು ಪಟ್ಟು

202
00:15:40,750 --> 00:15:46,350
ತದನಂತರ ನಮ್ಮ ಸಾಲಿನಲ್ಲಿ 5 ಅಕ್ಷರಗಳು ಉಳಿದಿವೆ, ಅರ್ಥವನ್ನು ನೀಡುವ ಹಾಗೆ.

203
00:15:48,060 --> 00:15:52,320
ನಾವು ವಾಸ್ತವವಾಗಿ ಎನ್ಕೋಡ್ ಹೇಗೆ ನಲ್ಲಿ ಹುಡುಕುವ, ವೇಳೆ

204
00:15:52,320 --> 00:15:56,580
ನಿರೀಕ್ಷೆಯಂತೆ, ನಾನು ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಕಂಡುಬರುವ ರು,

205
00:15:56,580 --> 00:16:01,350
ಬಿಟ್ಗಳ fewest ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

206
00:16:03,660 --> 00:16:05,660
>> ಇಲ್ಲಿ ಜಾಗರೂಕರಾಗಿರಿ.

207
00:16:05,660 --> 00:16:09,780
ಹಫ್ಮನ್ ಮರಗಳಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಮ್ಯಾಟರ್ಸ್.

208
00:16:09,780 --> 00:16:13,670
ಒಂದು ದೊಡ್ಡಕ್ಷರ ಎಸ್ ಒಂದು ಸಣ್ಣ ರು ಭಿನ್ನವಾದುದಾಗಿದೆ.

209
00:16:13,670 --> 00:16:21,260
ನಾವು ಹೊಂದಿದ್ದರೆ, ಸಣ್ಣ ರು ಕೇವಲ ಎರಡು ಕಾಣುತ್ತದೆ ನಂತರ, ದೊಡ್ಡ ಅಕ್ಷರಗಳಲ್ಲಿ "ಈ CS50 ಹೊಂದಿದೆ"

210
00:16:21,260 --> 00:16:27,120
ಅದರ ಮೌಲ್ಯ 2 ಒಂದು ನೋಡ್ ಎಂದು, ತದನಂತರ ದೊಡ್ಡಕ್ಷರ ಎಸ್ ಒಮ್ಮೆ ಮಾತ್ರ ಎಂದು.

211
00:16:27,120 --> 00:16:33,440
ನೀವು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಎಲೆ ಏಕೆಂದರೆ ಆದ್ದರಿಂದ ನಿಮ್ಮ ಮರದ ರಚನೆಗಳು ಬದಲಾಯಿತು.

212
00:16:33,440 --> 00:16:36,900
ಆದರೆ ಮೊತ್ತ ಇನ್ನೂ 10 ಎಂದು.

213
00:16:36,900 --> 00:16:39,570
ಎಂದು, ನಾವು ವಾಸ್ತವವಾಗಿ checksum ಕರೆ ಮಾಡಲು ನೀನು ಇಲ್ಲಿದೆ

214
00:16:39,570 --> 00:16:44,060
ಎಣಿಕೆಗಳು ಎಲ್ಲಾ ಜೊತೆಗೆ.

215
00:16:46,010 --> 00:16:50,990
>> ಈಗ ನಾವು ಹಫ್ಮನ್ ಮರಗಳು ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ನಾವು Huff'n ಪಫ್, pset ಆಗಿ ಆಳಕ್ಕೆ ಡೈವ್ ಮಾಡಬಲ್ಲದು.

216
00:16:50,990 --> 00:16:52,900
ನಾವು, ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದು ವಿಭಾಗ ಆರಂಭವಾಗಬೇಕು ಎಂದು ನೀನು

217
00:16:52,900 --> 00:16:57,990
ಮತ್ತು ಈ ನೀವು ಬೈನರಿ ಮರಗಳು ಮತ್ತು ಹೇಗೆ ಎಂದು ಸುಮಾರು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಜೊತೆ ಒಗ್ಗಿಕೊಂಡಿರಲಿಲ್ಲವಾದ್ದರಿಂದ ಕಾಣುವುದು ಇದೆ:

218
00:16:57,990 --> 00:17:03,230
ರೇಖಾಚಿತ್ರ ಗ್ರಂಥಿಗಳು, ಒಂದು ನೋಡ್ ನಿಮ್ಮ ಸ್ವಂತ typedef struct ಸೃಷ್ಟಿಸುತ್ತದೆ

219
00:17:03,230 --> 00:17:07,230
ಮತ್ತು ನೀವು ಒಂದು ಬೈನರಿ ಮರದ ಪ್ರತಿಗಳ ಮಾಡಿದ್ದೇವೆ ಸೇರಿಸಲು ಎಂಬುದರ ನೋಡಿದ,

220
00:17:07,230 --> 00:17:09,050
ಇದು, ಮತ್ತು ಆ ವಿಷಯಗಳನ್ನು ಗ್ಯಾಲರಿ.

221
00:17:09,050 --> 00:17:14,560
ಜ್ಞಾನ ಖಂಡಿತವಾಗಿಯೂ Huff'n ಪಫ್ ಭಾಗದ ಮೇಲೆ ನೀವು ಡೈವ್ ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲಿದ್ದಾನೆ

222
00:17:14,560 --> 00:17:17,089
pset ನ.

223
00:17:19,150 --> 00:17:26,329
Pset ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿಯಲ್ಲಿ, ನಿಮ್ಮ ಕೆಲಸವನ್ನು, ಪಫ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆಗಿದೆ

224
00:17:26,329 --> 00:17:30,240
ಮತ್ತು ಹ್ಯಾಕರ್ ಆವೃತ್ತಿಯಲ್ಲಿ ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಹಫ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೊಂದಿದೆ.

225
00:17:30,240 --> 00:17:38,490
ಹಫ್ ಹೊಂದಿದೆ ಏನು, ಅದು ಪಠ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದು 0 ಸೆ ಮತ್ತು 1 ಅದನ್ನು ಭಾಷಾಂತರಿಸಿದರೆ

226
00:17:38,490 --> 00:17:41,990
ಆದ್ದರಿಂದ ನಾವು ಆವರ್ತನಗಳ ಎಣಿಕೆ ಅಲ್ಲಿ ನಾವು ಮೇಲೆ ಆ ಪ್ರಕ್ರಿಯೆ

227
00:17:41,990 --> 00:17:50,970
ನಂತರ ಮರದ ಮಾಡಿದ ನಂತರ ಹೇಳಿದರು "ನಾನು ಹೇಗೆ ಟಿ ಸಿಗುತ್ತವೆ?"

228
00:17:50,970 --> 00:17:54,840
ಟಿ 100 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇಂತಹ ವಿಷಯಗಳನ್ನು,

229
00:17:54,840 --> 00:17:58,860
ತದನಂತರ ಹಫ್ ಪಠ್ಯ ಮತ್ತು ನಂತರ ಔಟ್ಪುಟ್ ಎಂದು ಅವಳಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

230
00:17:58,860 --> 00:18:04,920
ಆದರೆ ನಾವು ನಮ್ಮ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುವವರ ಅನುಮತಿಸಲು ಬಯಸುವ ತಿಳಿದಿರುವ ಕಾರಣ

231
00:18:04,920 --> 00:18:11,790
ಅದೇ ಮರದ ಮರುಸೃಷ್ಟಿಸಲು, ಇದು ಆವರ್ತನ ಎಣಿಕೆಗಳು ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.

232
00:18:11,790 --> 00:18:17,980
ನಂತರ ಪಫ್ ನಾವು 0 ಸೆ ಮತ್ತು 1 ಗಳ ಒಂದು ದ್ವಿಮಾನ ಕಡತ ನೀಡಲಾಗಿದೆ

233
00:18:17,980 --> 00:18:21,740
ಮತ್ತು ತರಂಗಾಂತರಗಳನ್ನು ಬಗ್ಗೆ ಮಾಹಿತಿ ನೀಡಲಾಗುತ್ತದೆ.

234
00:18:21,740 --> 00:18:26,740
ನಾವು, ಮೂಲ ಸಂದೇಶಕ್ಕೆ ಆ 0 ಸೆ ಮತ್ತು 1 ಮತ್ತೆ ಎಲ್ಲಾ ಭಾಷಾಂತರಿಸಿ

235
00:18:26,740 --> 00:18:29,350
ಆದ್ದರಿಂದ ನಾವು decompressing ಮಾಡುತ್ತಿದ್ದೇವೆ.

236
00:18:29,350 --> 00:18:36,450
ನೀವು ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿ ಮಾಡುವುದರಿಂದ, ನೀವು, ಹಫ್ ಜಾರಿಗೆ ಅಗತ್ಯವಿಲ್ಲ

237
00:18:36,450 --> 00:18:39,290
ಆದ್ದರಿಂದ ನೀವು ಹಫ್ ಸಿಬ್ಬಂದಿ ಅನುಷ್ಠಾನಕ್ಕೆ ಬಳಸಬಹುದು.

238
00:18:39,290 --> 00:18:42,080
ಹಾಗೆ ಹೇಗೆ ವಿಶೇಷ ಸೂಚನೆಗಳನ್ನು ಇವೆ.

239
00:18:42,080 --> 00:18:48,780
ನೀವು ನಿರ್ದಿಷ್ಟ ಪಠ್ಯ ಕಡತ ಮೇಲೆ ಹಫ್ ಸಿಬ್ಬಂದಿ ಅನುಷ್ಠಾನ ಚಲಾಯಿಸಬಹುದು

240
00:18:48,780 --> 00:18:53,270
ತದನಂತರ ಪಫ್ ನಿಮ್ಮ ಇನ್ಪುಟ್ ಎಂದು ಔಟ್ಪುಟ್ ಅನ್ನು.

241
00:18:53,270 --> 00:18:59,330
>> ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ, ನಾವು ಈ ಒಂದು ವಿತರಣಾ ಕೋಡ್ ಸಾಕಷ್ಟು ಹೊಂದಿರುತ್ತವೆ.

242
00:18:59,330 --> 00:19:01,810
ನಾನು ಮೂಲಕ ಹೋಗುವ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

243
00:19:01,810 --> 00:19:04,400
ನಾನು ಸಮಯ ಕಳೆಯುವುದು ಪಡೆಯಲಿದ್ದೇನೆ. H ಕಡತಗಳನ್ನು

244
00:19:04,400 --> 00:19:07,660
ನಾವು. H ಏಕೆಂದರೆ. ಸಿ ಕಡತಗಳಲ್ಲಿ, ಏಕೆಂದರೆ

245
00:19:07,660 --> 00:19:11,650
ಮತ್ತು, ಕಾರ್ಯಗಳನ್ನು ಮೂಲಮಾದರಿಗಳ ನೀಡುತ್ತದೆ

246
00:19:11,650 --> 00:19:15,520
ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ನಿಖರವಾಗಿ ತಿಳಿಯಲು ಅಗತ್ಯವಿಲ್ಲ -

247
00:19:15,520 --> 00:19:20,280
ನೀವು. ಸಿ ಕಡತಗಳಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥ ಇದ್ದರೆ, ನಂತರ, ಹೆಚ್ಚು ಚಿಂತಿಸಬೇಡಿ

248
00:19:20,280 --> 00:19:23,600
ಇದು ಕೆಲವು ಸುಳಿವುಗಳನ್ನು ನೀಡುವುದು ಎಂದು ಏಕೆಂದರೆ ಆದರೆ ಖಂಡಿತವಾಗಿಯೂ ಒಂದು ನೋಟ ತೆಗೆದುಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸಿ

249
00:19:23,600 --> 00:19:29,220
ಮತ್ತು ಇತರ ಜನರ ಕೋಡ್ ಓದುವ ಬಳಸಲಾಗುತ್ತದೆ ನಿಮಗೆ ಉಪಯುಕ್ತವಾಗಿರುವ.

250
00:19:38,940 --> 00:19:48,270
>> Huffile.h ಗಮನಿಸುತ್ತಿದ್ದೇವೆ ಕಾಮೆಂಟ್ಗಳನ್ನು ಅದನ್ನು ಹಫ್ಮನ್ ಕೋಡೆಡ್ ಕಡತಗಳನ್ನು ಅಮೂರ್ತತೆಯ ಪದರವನ್ನು ಘೋಷಿಸುತ್ತದೆ.

251
00:19:48,270 --> 00:20:01,660
ನಾವು ಕೆಳಗೆ ಹೋದರೆ, ನಾವು ಕೋಡ್ಗಳನ್ನು ಅಗತ್ಯವಿದೆ ಎಂದು 256 ಚಿಹ್ನೆಗಳನ್ನು ಗರಿಷ್ಠ ಎಂದು ನೋಡಿ.

252
00:20:01,660 --> 00:20:05,480
ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಸಣ್ಣ - - ಈ ವರ್ಣಮಾಲೆಯ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ

253
00:20:05,480 --> 00:20:08,250
ತದನಂತರ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಸಂಖ್ಯೆಗಳ, ಇತ್ಯಾದಿ

254
00:20:08,250 --> 00:20:11,930
ನಂತರ ಇಲ್ಲಿ ನಾವು ಹಫ್ಮನ್ ಕೋಡೆಡ್ ಫೈಲ್ ಗುರುತಿಸಿಕೊಂಡ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ.

255
00:20:11,930 --> 00:20:15,890
ಒಂದು ಹಫ್ಮನ್ ಕೋಡ್ ಒಳಗೆ ಅವರು ಕೆಲವು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ ಎಂದು ನೀನು

256
00:20:15,890 --> 00:20:18,560
ಶಿರೋಲೇಖ ಸಂಬಂಧವಿಲ್ಲ.

257
00:20:18,560 --> 00:20:21,110
ಇದು ಕೇವಲ ಒಂದು ಯಾದೃಚ್ಛಿಕ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ರೀತಿ ಇರಬಹುದು

258
00:20:21,110 --> 00:20:27,160
ನೀವು ನಿಜವಾಗಿಯೂ ASCII ಅದನ್ನು ಭಾಷಾಂತರಿಸಲು ಆದರೆ, ಅದು ವಾಸ್ತವವಾಗಿ ಹಫ್ ಔಟ್ ವಿವರಿಸುತ್ತದೆ.

259
00:20:27,160 --> 00:20:34,290
ಇಲ್ಲಿ ನಾವು ಒಂದು ಹಫ್ಮನ್-ಎನ್ಕೋಡ್ ಮಾಡಿದ ಫೈಲ್ ಒಂದು struct ಹೊಂದಿರುತ್ತವೆ.

260
00:20:34,290 --> 00:20:39,670
ಒಂದು ಹಫ್ ಕಡತದೊಂದಿಗೆ ಈ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಎಲ್ಲಾ ಇಲ್ಲ.

261
00:20:39,670 --> 00:20:47,080
ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ನಾವು ಹಫ್ ಕಡತ ಹೆಡರ್ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು Huffeader ಕರೆ

262
00:20:47,080 --> 00:20:50,810
ಬದಲಿಗೆ ಅದು ಹೇಗಾದರೂ ಅದೇ ಶಬ್ದಗಳನ್ನು ಏಕೆಂದರೆ ಹೆಚ್ಚುವರಿ H ಸೇರಿಸಲು.

263
00:20:50,810 --> 00:20:52,720
Cute.

264
00:20:52,720 --> 00:20:57,790
ನಾವು ಸಂಬಂಧಿಸಿದ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಯ.

265
00:20:57,790 --> 00:21:09,040
ಇದು ನಿಜವಾದ ಹಫ್ ಕಡತ ಅದನ್ನು, ಮೇಲಿನ ಈ ಮ್ಯಾಜಿಕ್ ಒಂದು ಸಂಖ್ಯೆಯಾಗಿರಬೇಕು ಹೋಗುವುದಿಲ್ಲ.

266
00:21:09,040 --> 00:21:14,720
ಮತ್ತು ನಂತರ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

267
00:21:14,720 --> 00:21:18,750
ಆದ್ದರಿಂದ ಪ್ರತಿ ಚಿಹ್ನೆಯ, ಇದರಲ್ಲಿ 256 ಇವೆ

268
00:21:18,750 --> 00:21:24,760
ಇದು ಆ ಚಿಹ್ನೆಗಳು ಆವರ್ತನ ಹಫ್ ಕಡತ ಒಳಗೆ ಏನು ಪಟ್ಟಿಗೆ ವಿಶೇಷವೇನು.

269
00:21:24,760 --> 00:21:28,090
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು, ಆವರ್ತನಗಳ ಒಂದು checksum ಹೊಂದಿವೆ

270
00:21:28,090 --> 00:21:32,160
ಆ ಆವರ್ತನಗಳಲ್ಲಿ ಮೊತ್ತವು ಆಗಿರಬೇಕು.

271
00:21:32,160 --> 00:21:36,520
ಆದ್ದರಿಂದ ಏನನ್ನು ಒಂದು Huffeader ಹೊಂದಿದೆ.

272
00:21:36,520 --> 00:21:44,600
ನಂತರ ನಾವು ಹಫ್ ಕಡತ ಮುಂದಿನ ಬಿಟ್ ಹಿಂದಿರುಗಲು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು

273
00:21:44,600 --> 00:21:52,580
ಹಾಗೆಯೇ hfclose, ಇಲ್ಲಿ ಈ ಕ್ರಿಯೆಯ ನಂತರ, ಹಫ್ ಕಡತಕ್ಕೆ ಒಂದು ಬಿಟ್ ಬರೆಯುತ್ತಾರೆ, ಮತ್ತು

274
00:21:52,580 --> 00:21:54,650
ಎಂದು ವಾಸ್ತವವಾಗಿ ಹಫ್ ಕಡತ ಮುಚ್ಚಲ್ಪಡುತ್ತದೆ.

275
00:21:54,650 --> 00:21:57,290
ಮೊದಲು, ನಾವು ನೇರವಾಗಿ ಕೇವಲ fclose ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಲಾಯಿತು

276
00:21:57,290 --> 00:22:01,190
ಆದರೆ ನೀವು ಹಫ್ ಕಡತ ಹೊಂದಿರುವಾಗ, ಬದಲಿಗೆ ಇದು fclosing ಆಫ್

277
00:22:01,190 --> 00:22:06,080
ನಿಮಗೆ ನಿಜವಾಗಿ ಏನು ಎಂದು ನೀನು hfclose ಮತ್ತು hfopen ಹೊಂದಿದೆ.

278
00:22:06,080 --> 00:22:13,220
ಆ ನಾವು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು ಆ ಹಫ್ ಕಡತಗಳನ್ನು ನಿರ್ದಿಷ್ಟವಾದ ಕ್ರಿಯೆಗಳು.

279
00:22:13,220 --> 00:22:19,230
ನಂತರ ಇಲ್ಲಿ ನಾವು ಹೆಡರ್ ನಲ್ಲಿ ಓದಿ ನಂತರ ಹೆಡರ್ ಬರೆಯಲು.

280
00:22:19,230 --> 00:22:25,700
>> ಕೇವಲ. H ಕಡತವನ್ನು ಓದುವ ಮೂಲಕ ನಾವು, ಒಂದು ಹಫ್ ಕಡತ ಇರಬಹುದು ಎಂಬುದರ ಅರ್ಥ ಪಡೆಯಲು ರೀತಿಯ ಮಾಡಬಹುದು

281
00:22:25,700 --> 00:22:32,480
ಇದು ವಾಸ್ತವವಾಗಿ huffile.c ಹಂತಕ್ಕೆ ಹೋಗದೆ ಏನು ಗುಣಲಕ್ಷಣಗಳು

282
00:22:32,480 --> 00:22:36,750
ಇದು ನಾವು ಧುಮುಕುವುದಿಲ್ಲ ವೇಳೆ, ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಎಂದು ಹೋಗುತ್ತದೆ.

283
00:22:36,750 --> 00:22:41,270
ಇದು I / O ಇಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ವ್ಯವಹರಿಸುವಾಗ ಕಡತ ಎಲ್ಲಾ ಹೊಂದಿದೆ.

284
00:22:41,270 --> 00:22:48,010
ಇಲ್ಲಿ ನಾವು hfread ಕರೆ ಮಾಡಿದಾಗ, ಉದಾಹರಣೆಗೆ, ಇದು ಇನ್ನೂ fread ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೋಡಿ.

285
00:22:48,010 --> 00:22:53,050
ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಆ ಕಾರ್ಯಗಳನ್ನು ತೊಡೆದುಹಾಕಿದ್ದೇವೆ ಇಲ್ಲ, ಆದರೆ ನಾವು ಆರೈಕೆ ತೆಗೆದುಕೊಂಡು ಆ ಕಳುಹಿಸಲು ನೀವು

286
00:22:53,050 --> 00:22:59,760
ಬದಲಿಗೆ ಇದು ನಾವೇ ಎಲ್ಲಾ ಮಾಡುವ ಹಫ್ ಕಡತ ಒಳಗೆ.

287
00:22:59,760 --> 00:23:02,300
ನೀವು ಕುತೂಹಲದಿಂದ, ನೀವು ಈ ಮೂಲಕ ಸ್ಕ್ಯಾನ್ ಮುಕ್ತವಾಗಿರುವ

288
00:23:02,300 --> 00:23:08,410
ಮತ್ತು ಹೋಗಿ ಮರಳಿ ಪದರವು ಸ್ವಲ್ಪ ಸಿಪ್ಪೆ.

289
00:23:20,650 --> 00:23:24,060
>> ನಾವು ನೋಡಲು ನೀನು ಮುಂದಿನ ಕಡತ tree.h. ಆಗಿದೆ

290
00:23:24,060 --> 00:23:30,210
ದರ್ಶನ ಸ್ಲೈಡ್ಸ್ ಮೊದಲು ನಾವು ಒಂದು ಹಫ್ಮನ್ ನೋಡ್ ನಿರೀಕ್ಷಿಸಬಹುದು ಹೇಳಿದರು

291
00:23:30,210 --> 00:23:32,960
ಮತ್ತು ನಾವು typedef struct ನೋಡ್ ಮಾಡಿದ.

292
00:23:32,960 --> 00:23:38,360
ನಾವು ಒಂದು ಚಿಹ್ನೆ ಒಂದು ಆವರ್ತನ, ತದನಂತರ 2 ನೋಡ್ ನಕ್ಷತ್ರಗಳಂತೆ ನಿರೀಕ್ಷಿಸಬಹುದು.

293
00:23:38,360 --> 00:23:41,870
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಮಾಡುತ್ತಿರುವುದು ಈ ಅದೇ ಆಗಿದೆ

294
00:23:41,870 --> 00:23:46,880
ಬದಲಿಗೆ ನೋಡ್ನ ಹೊರತುಪಡಿಸಿ ನಾವು ಅವುಗಳನ್ನು ಮರಗಳು ಕರೆಯಲು ನೀನು.

295
00:23:48,790 --> 00:23:56,760
ನೀವು ಮರದ ಮಾಡಲು ಕರೆ ಮಾಡಿದಾಗ ಅದು ಒಂದು ಮರದ ಪಾಯಿಂಟರ್ ಮರಳಿಸುವ ಒಂದು ಫಂಕ್ಷನ್.

296
00:23:56,760 --> 00:24:03,450
ನೀವು ಒಂದು ಹೊಸ ನೋಡ್ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಪೆಲ್ಲರ್ ಹಿಂತಿರುಗಿ

297
00:24:03,450 --> 00:24:11,410
ನೀವು ಹೇಳಿದ ನೋಡ್ * ಹೊಸ ಪದ = malloc (sizeof) ಮತ್ತು ವಿಷಯಗಳನ್ನು.

298
00:24:11,410 --> 00:24:17,510
ಮೂಲತಃ, mktree ನೀವು ಆ ವ್ಯವಹರಿಸುವಾಗ ಏರಲಿದೆ.

299
00:24:17,510 --> 00:24:20,990
ಹಾಗೆಯೇ, ನೀವು ಒಂದು ಮರ ತೆಗೆಯಲು ಬಯಸಿದಾಗ,

300
00:24:20,990 --> 00:24:24,810
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನೀವು ಪೂರೈಸಿದ ಮೇಲೆ ಮರದ ಮುಕ್ತಗೊಳಿಸಿದ ವಿಶೇಷವೇನು

301
00:24:24,810 --> 00:24:33,790
ಬದಲಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಮೇಲೆ ಉಚಿತ ಕರೆ ಆಫ್, ನೀವು ವಾಸ್ತವವಾಗಿ ಕೇವಲ rmtree ಕಾರ್ಯವನ್ನು ಬಳಸಲು ನೀನು

302
00:24:33,790 --> 00:24:40,360
ನೀವು ಆ ಮರದ ದಿಕ್ಸೂಚಕ ರವಾನಿಸಲು ಮತ್ತು ಅಲ್ಲಿ tree.c ನೀವು ಆ ಆರೈಕೆಯನ್ನು ಕಾಣಿಸುತ್ತದೆ.

303
00:24:40,360 --> 00:24:42,490
>> ನಾವು tree.c. ತನಿಖೆ

304
00:24:42,490 --> 00:24:47,240
ನಾವು ಹಾಗೂ ಅನುಷ್ಠಾನದ ನೋಡಲು ಹೊರತುಪಡಿಸಿ ಅದೇ ಕಾರ್ಯಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು.

305
00:24:47,240 --> 00:24:57,720
ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ, ನೀವು mktree ಕರೆ ಮಾಡಿದಾಗ ಅದು ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ಮರದ ಗಾತ್ರ mallocs

306
00:24:57,720 --> 00:25:03,190
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮೌಲ್ಯ, ಆದ್ದರಿಂದ 0 ಸೆ ಅಥವಾ NULLs, ಮೌಲ್ಯವನ್ನು ಎಲ್ಲಾ ಆರಂಭಿಸುತ್ತದೆ

307
00:25:03,190 --> 00:25:08,280
ತದನಂತರ ನೀವು ನಿಮಗೆ malloc'd ನೀವು ಆ ಮರದ ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

308
00:25:08,280 --> 00:25:13,340
ಇಲ್ಲಿ ನೀವು ಮರ ತೆಗೆದು ಕರೆ ಅದು ಮೊದಲ ನೀವು ಡಬಲ್ ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

309
00:25:13,340 --> 00:25:18,320
ನೀವು ನಿಜವಾಗಿ ನೀವು ತೆಗೆದುಹಾಕಲು ನೀವು ಒಂದು ಮರ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

310
00:25:18,320 --> 00:25:23,330
ಒಂದು ಮರ ತನ್ನ ಮಕ್ಕಳು ಒಳಗೊಂಡಿದೆ, ಇಲ್ಲಿ ಏಕೆಂದರೆ

311
00:25:23,330 --> 00:25:29,560
ಇದು ಏನು ಇದು ಪುನರಾವರ್ತಿತವಾಗಿ ಮರದ ಎಡ ನೋಡ್ ಮರದ ತೆಗೆದುಹಾಕಲು ಕರೆಗಳು

312
00:25:29,560 --> 00:25:31,650
ಅಲ್ಲದೇ ಬಲ ನೋಡ್ ಮಾಹಿತಿ.

313
00:25:31,650 --> 00:25:37,790
ಇದು ಮೂಲ ಬಿಡುಗಡೆ ಮೊದಲು, ಇದನ್ನು ಮಕ್ಕಳಿಗೆ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ.

314
00:25:37,790 --> 00:25:42,770
ಪೋಷಕ ಸಹ ಮೂಲ ಜೊತೆ ಪರಸ್ಪರ ಹೊಂದಿದೆ.

315
00:25:42,770 --> 00:25:46,500
ಆದ್ದರಿಂದ ಮುತ್ತಾತನ ಮುತ್ತಾತನ ತಾತ ನಂತಹ ಪ್ರಥಮ ಮೂಲ,

316
00:25:46,500 --> 00:25:52,130
ಅಥವಾ ಅಜ್ಜಿ ಮರ, ಮೊದಲ ನಾವು ಮೊದಲ ಮಟ್ಟದ ಕೆಳಗೆ ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

317
00:25:52,130 --> 00:25:58,490
ಆದ್ದರಿಂದ ಆ ಉಚಿತ, ಕೆಳಕ್ಕೆ ಚಲಿಸುವಾಗ, ಮತ್ತು ಆ, ಇತ್ಯಾದಿ, ಮತ್ತೆ ಉಚಿತ ಬರಲು

318
00:26:00,400 --> 00:26:02,210
ಆ ಮರದ.

319
00:26:02,210 --> 00:26:04,240
>> ಈಗ ನಾವು ಅರಣ್ಯ ನೋಡಲು.

320
00:26:04,240 --> 00:26:09,860
ನಿಮ್ಮ ಹಫ್ಮನ್ ಮರಗಳ ಎಲ್ಲಾ ಇರಿಸಿ ಅಲ್ಲಿ ಕಾಡು.

321
00:26:09,860 --> 00:26:12,910
ಇದು ಒಂದು ಸಂಚು ಎಂದು ನಾವು ಅಂಶವಿದೆ ಎಂದು ನೀನು ಹೇಳುವ ವಿಶೇಷವೇನು

322
00:26:12,910 --> 00:26:22,320
ಒಂದು ಮರದ ಒಂದು ಪಾಯಿಂಟರ್ ಹಾಗೆಯೇ ಮುಂದಿನ ಎಂಬ ಕಥೆಯ ಒಂದು ಪಾಯಿಂಟರ್ ಒಳಗೊಂಡಿದೆ.

323
00:26:22,320 --> 00:26:28,480
ಯಾವ ರಚನೆ ಕಾಣುವ ಈ ರೀತಿಯ ಮಾಡುತ್ತದೆ?

324
00:26:29,870 --> 00:26:32,490
ಇದು ರೀತಿಯ ಅದನ್ನು ಮೇಲೆ ಹೇಳುತ್ತಾರೆ.

325
00:26:34,640 --> 00:26:36,700
ಇಲ್ಲಿಯೇ ಮೇಲೆ.

326
00:26:37,340 --> 00:26:39,170
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ.

327
00:26:39,170 --> 00:26:44,590
ನಾವು ಒಂದು ಕಥಾವಸ್ತುವನ್ನು ಹೊಂದಿದ್ದು ಅದು ಪ್ಲಾಟ್ಗಳು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಹೀಗಿದೆ ನೋಡಿ.

328
00:26:44,590 --> 00:26:53,020
ಒಂದು ಕಾಡು, ಪ್ಲಾಟ್ಗಳು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

329
00:26:53,020 --> 00:26:58,100
ಆದ್ದರಿಂದ ಅರಣ್ಯ ರಚನೆ ನಾವು ನಮ್ಮ ಮೊದಲ ಕಥಾವಸ್ತುವಿನ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುವ ನೀನು ಆಗಿದೆ

330
00:26:58,100 --> 00:27:02,740
ಮತ್ತು ಕಥಾವಸ್ತು ಅದನ್ನು ಒಂದು ಮರವನ್ನು ಹೊಂದಿದೆ ಅಥವಾ ಬದಲಿಗೆ ಮರದ ಸೂಚಿತವಾಗಿರುತ್ತದೆ

331
00:27:02,740 --> 00:27:06,190
ನಂತರ ಹೀಗೆ ಇತ್ಯಾದಿ, ಮುಂದಿನ ಕಥಾವಸ್ತುವಿನ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

332
00:27:06,190 --> 00:27:11,100
ಒಂದು ಅರಣ್ಯ ಮಾಡಲು ನಾವು mkforest ಕರೆ.

333
00:27:11,100 --> 00:27:14,930
ನಾವು ಇಲ್ಲಿ ಕೆಲವು ಬಹಳ ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು.

334
00:27:14,930 --> 00:27:23,240
ನೀವು ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಒಂದು ಟ್ರೀ * ನಂತರ ಒಂದು ಅರಣ್ಯದಲ್ಲಿ ಹಾದು ಮತ್ತು ಅಲ್ಲಿ ನಾವು ಆಯ್ಕೆ ಹೊಂದಿವೆ

335
00:27:23,240 --> 00:27:25,210
ಒಂದು ಮರದ ಒಂದು ಪಾಯಿಂಟರ್.

336
00:27:25,210 --> 00:27:29,370
ಯಾವ ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ತೋರಿಸುವ ನೀವು ಅದನ್ನು ಕಾಡು ಹೋಗಿ ನೋಡುತ್ತಾರೆ

337
00:27:29,370 --> 00:27:35,240
ಆ ಕಾಡು ಕಡಿಮೆ ಆವರ್ತನದ ಒಂದು ಮರ ತೆಗೆದು

338
00:27:35,240 --> 00:27:38,330
ಮತ್ತು ನಂತರ ಒಂದು ಮರದ ನೀವು ಪಾಯಿಂಟರ್ ನೀಡಿ.

339
00:27:38,330 --> 00:27:43,030
ನೀವು ಆಯ್ಕೆ ಕರೆ ಒಮ್ಮೆ, ಮರ, ಎಂದಿಗೂ ಕಾಡಿನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ

340
00:27:43,030 --> 00:27:48,550
ಆದರೆ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಒಂದು ಮರದ ಸೂಚಿಯಾಗಿದೆ.

341
00:27:48,550 --> 00:27:50,730
ನಂತರ ನೀವು ಸಸ್ಯ ಹೊಂದಿರುತ್ತವೆ.

342
00:27:50,730 --> 00:27:57,420
ನೀವು 0 ತರಂಗಾಂತರ ಹೊಂದಿರುವ ಮರದ ಒಂದು ಪಾಯಿಂಟರ್ ರಲ್ಲಿ ಹಾದು ಒದಗಿಸಿದ

343
00:27:57,420 --> 00:28:04,040
ಯಾವ ಸಸ್ಯ ಮಾಡುತ್ತೇನೆ ಇದು ಅರಣ್ಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮರದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ಸಸ್ಯ ಕಾಣಿಸುತ್ತದೆ ಎಂದು ಕಾಡಿನ ಮರದ ಒಳಗೆ.

344
00:28:04,040 --> 00:28:06,370
ಇಲ್ಲಿ ನಾವು rmforest ಹೊಂದಿರುತ್ತವೆ.

345
00:28:06,370 --> 00:28:11,480
ಮೂಲತಃ ನಮಗೆ ನಮ್ಮ ಮರಗಳ ಎಲ್ಲಾ ಬಿಡುಗಡೆ ಇದು ಮರ, ತೆಗೆದುಹಾಕಲು ರೀತಿಯ

346
00:28:11,480 --> 00:28:16,600
ಅರಣ್ಯ ತೆಗೆದುಹಾಕುವಂತೆ ಅರಣ್ಯ ಒಳಗೊಂಡಿರುವ ಉಚಿತ ಎಲ್ಲವೂ ತಿನ್ನುವೆ.

347
00:28:16,600 --> 00:28:24,890
>> ನಾವು forest.c ನೋಡೋಣ, ನಾವು, ಅಲ್ಲಿ ಕನಿಷ್ಠ 1 rmtree ಆಜ್ಞೆಯನ್ನು ನೋಡಿ ನಿರೀಕ್ಷೆ ಮಾಡುತ್ತೇವೆ

348
00:28:24,890 --> 00:28:30,090
ಏಕೆಂದರೆ ಅರಣ್ಯ ಇದು ಮರಗಳು ವೇಳೆ ಅರಣ್ಯ ಮುಕ್ತ ಸ್ಮರಣೆಗೆ,

349
00:28:30,090 --> 00:28:32,930
ನಂತರ ಅಂತಿಮವಾಗಿ ನೀವು ತುಂಬಾ ಆ ಮರಗಳು ತೆಗೆದುಹಾಕಲು ಹೊಂದಿರುವ ನೀನು.

350
00:28:32,930 --> 00:28:41,020
ನಾವು forest.c ತನಿಖೆ ವೇಳೆ, ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು ಎಂದು ಇದು ನಮ್ಮ mkforest ಹೊಂದಿರುತ್ತವೆ.

351
00:28:41,020 --> 00:28:42,890
ನಾವು malloc ವಿಷಯಗಳು.

352
00:28:42,890 --> 00:28:51,740
ಆರಂಭದಲ್ಲಿ ಅದು ಖಾಲಿ ಏಕೆಂದರೆ ನಾವು, ಶೂನ್ಯ ಎಂದು ಅರಣ್ಯ ಮೊದಲ ಕಥಾವಸ್ತುವಿನ ಆರಂಭಿಸಲು

353
00:28:51,740 --> 00:29:05,940
ಆಗ ಅತೀ ಕಡಿಮೆ ತೂಕ ಹೊಂದಿರುವ ಮರದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಇದು ಆಯ್ಕೆ, ಕಡಿಮೆ ಆವರ್ತನ, ನೋಡಿ

354
00:29:05,940 --> 00:29:13,560
ತದನಂತರ ನಿರ್ದಿಷ್ಟ ನೋಡ್ ಹೋಗಲಾಡಿಸಲು ಗಳಿಸುವ ಒಂದು ಮರದ ಅಂಕಗಳನ್ನು ಮತ್ತು ಮುಂದಿನ ಒಂದು,

355
00:29:13,560 --> 00:29:16,760
ಆದ್ದರಿಂದ ಅರಣ್ಯ ಲಿಂಕ್ ಪಟ್ಟಿ ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

356
00:29:16,760 --> 00:29:24,510
ತದನಂತರ ಇಲ್ಲಿ ನಾವು ಯಾವ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಳಸೇರಿಸಿದನು ಮರದ ಸಸ್ಯ ಹೊಂದಿರುತ್ತವೆ.

357
00:29:24,510 --> 00:29:29,960
ಯಾವ ಕಾಡಿನ ಇದು ಉತ್ತಮವಾಗಿ ಅದು ನಮಗೆ ವಿಂಗಡಿಸಲಾದ ಇಡುತ್ತದೆ ಹೊಂದಿದೆ ಮಾಡುವುದಿಲ್ಲ.

358
00:29:29,960 --> 00:29:37,910
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ, ನಾವು ಇಲ್ಲ ಎಂದು rmtree ಹೊಂದಿವೆ, rmforest ಮತ್ತು.

359
00:29:46,650 --> 00:29:55,440
>> ಇಲ್ಲಿಯವರೆಗೆ ವಿತರಣೆ ಕೋಡ್ ಗಮನಿಸುತ್ತಿದ್ದೇವೆ huffile.c, ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ದೂರದ ಕಠಿಣ ಅದಕ್ಕೆ ಕರೆದಿರಬಹುದು

360
00:29:55,440 --> 00:29:59,990
ಇತರ ಫೈಲ್ಗಳನ್ನು ಆದರೆ ತಮ್ಮನ್ನು ಅನುಸರಿಸಲು ಬಹಳ ಸರಳವಾಗಿದ್ದವು.

361
00:29:59,990 --> 00:30:03,090
ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಮತ್ತು ನಮ್ಮ ಜ್ಞಾನ,

362
00:30:03,090 --> 00:30:04,860
ನಾವು ಬಹಳ ಚೆನ್ನಾಗಿ ಅನುಸರಿಸಲು ಸಮರ್ಥರಾಗಿದ್ದರು.

363
00:30:04,860 --> 00:30:10,500
ಆದರೆ ನಿಜವಾಗಿಯೂ ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಖಚಿತವಾಗಿ ಅಗತ್ಯವಿದೆ ಎಲ್ಲಾ. H ಫೈಲ್ಗಳನ್ನು

364
00:30:10,500 --> 00:30:15,840
ನೀವು ಆ ಹಿಂದಿರುಗುವ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ, ಆ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ

365
00:30:15,840 --> 00:30:20,590
ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಕೈಗೊಳ್ಳಲಾಗುವುದು ಹೋಗುವ ಯಾವ ಕ್ರಮ ಅರ್ಥ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

366
00:30:20,590 --> 00:30:24,290
ನೀವು ಆ ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಕರೆ ಮಾಡಿದಾಗ.

367
00:30:24,290 --> 00:30:33,020
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಇದು ಒಳಗೆ ಅರ್ಥೈಸಿಕೊಳ್ಳಲು ನಾವು ಆ ಕಾರಣ ಸಾಕಷ್ಟು ಅನಿವಾರ್ಯವಲ್ಲ. H ಕಡತಗಳು.

368
00:30:35,170 --> 00:30:39,490
ನಮ್ಮ ವಿತರಣಾ ಕೋಡ್ ಉಳಿದ 2 ಹೆಚ್ಚು ಕಡತಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

369
00:30:39,490 --> 00:30:41,640
>> ನ ಡಂಪ್ ನೋಡೋಣ.

370
00:30:41,640 --> 00:30:47,230
ಇಲ್ಲಿ ಅದರ ಕಾಮೆಂಟ್ ಮೂಲಕ ಡಂಪ್ ಒಂದು ಹಫ್ಮನ್-ಸಂಕುಚಿತ ಕಡತ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

371
00:30:47,230 --> 00:30:55,580
ತದನಂತರ ಅನುವಾದಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡಂಪ್ ಅದರ ಎಲ್ಲಾ ಔಟ್.

372
00:31:01,010 --> 00:31:04,260
ಇಲ್ಲಿ ನಾವು hfopen ಕರೆ ಎಂದು ನೋಡಿ.

373
00:31:04,260 --> 00:31:10,770
ಈ, * ಇನ್ಪುಟ್ = fopen ಸಲ್ಲಿಸುವಂತೆ ಪ್ರತಿಬಿಂಬಿಸುವ ರೀತಿಯ

374
00:31:10,770 --> 00:31:13,500
ತದನಂತರ ನೀವು ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಲು.

375
00:31:13,500 --> 00:31:18,240
ಇದು ಬದಲಾಗಿ ನೀವು Huffile ಸಾಗುವ ಮಾಡಲಾಗಿರುವ ಕಡತ * ಹೊರತುಪಡಿಸಿ ಬಹುತೇಕ ಒಂದೇ ಆಗಿದೆ;

376
00:31:18,240 --> 00:31:22,030
ಬದಲಿಗೆ fopen ನಿಮಗೆ hfopen ಸಾಗುವ ನೀವು.

377
00:31:22,030 --> 00:31:29,280
ಇಲ್ಲಿ ನಾವು ವಿಧದ ನಾವು ಹೆಡರ್ ಓದಲು ಹೇಗೆ ಹೋಲುತ್ತದೆ ಇದು ಮೊದಲ ಹೆಡರ್ ನಲ್ಲಿ ಓದಿ

378
00:31:29,280 --> 00:31:33,580
ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಕಡತ.

379
00:31:33,580 --> 00:31:38,000
ನಾವು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವುದು ನೋಡಲು ಪರೀಕ್ಷಿಸುವ ಎಂಬುದನ್ನು ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು

380
00:31:38,000 --> 00:31:44,330
ಇದು ನಿಜವಾದ ಹಫ್ ಕಡತ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಬಲ ಮ್ಯಾಜಿಕ್ ಹೊಂದಿದೆ,

381
00:31:44,330 --> 00:31:53,610
ನಂತರ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಪರೀಕ್ಷೆಗಳಿಗೆ ಎಲ್ಲಾ ನಾವು ಮುಕ್ತ ವಾಸ್ತವಿಕ huffed ಕಡತ ಅಥವಾ ಆ ಕಡತವನ್ನು ಎಂದು.

382
00:31:53,610 --> 00:32:05,330
ಏನು ಮಾಡುತ್ತದೆ ನಾವು ನೋಡಬಹುದು ಸಂಕೇತಗಳನ್ನು ಎಲ್ಲಾ ಆವರ್ತನಗಳ ಹೊರತರುವ ಆಗಿದೆ

383
00:32:05,330 --> 00:32:09,790
ಒಂದು ಚಿತ್ರಾತ್ಮಕ ಟೇಬಲ್ಲಿಗೆ ಟರ್ಮಿನಲ್ ಒಳಗೆ.

384
00:32:09,790 --> 00:32:15,240
ಈ ಭಾಗವು ಉಪಯುಕ್ತ ಎಂದು ಹೋಗುತ್ತದೆ.

385
00:32:15,240 --> 00:32:24,680
ಇದು ಒಂದು ಬಿಟ್ ಮತ್ತು ವೇರಿಯಬಲ್ ಬಿಟ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ತೋರಿಸುತ್ತದೆ.

386
00:32:28,220 --> 00:32:35,430
ನಾನು ಫೈಲ್ huffing ಪರಿಣಾಮವಾಗಿ ಇದು hth.bin ಮೇಲೆ ಡಂಪ್ ಕರೆಯಲು ಅವು ಆದ್ದರಿಂದ

387
00:32:35,430 --> 00:32:39,490
ಸಿಬ್ಬಂದಿ ಪರಿಹಾರವನ್ನು ಬಳಸಿಕೊಂಡು, ಈ ಪಡೆಯುತ್ತೀರಿ.

388
00:32:39,490 --> 00:32:46,000
ಈ ಪಾತ್ರಗಳು ಎಲ್ಲಾ ಉತ್ಪಾದಿಸುವ ಮತ್ತು ನಂತರ ಅವರು ಕಂಡುಬರುವ ತರಂಗಾಂತರಗಳ ಪುಟ್ಟಿಂಗ್ ನ.

389
00:32:46,000 --> 00:32:51,180
ನಾವು ನೋಡಿದರೆ, ಅವುಗಳಲ್ಲಿ ಈ ಹೊರತುಪಡಿಸಿ 0 ಸೆ ಇವೆ: ಎರಡು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಎಚ್,

390
00:32:51,180 --> 00:32:54,820
ಮತ್ತು ನಂತರ ಒಮ್ಮೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಟಿ.

391
00:32:54,820 --> 00:33:07,860
ತದನಂತರ ಇಲ್ಲಿ ನಾವು 0 ಸೆ ಮತ್ತು 1 ನೈಜ ಸಂದೇಶವನ್ನು ಹೊಂದಿದೆ.

392
00:33:07,860 --> 00:33:15,450
ನಾವು hth.txt ನೋಡಿದರೆ, ಇದು ಸಂಭಾವ್ಯವಾಗಿ huffed ಎಂದು ಮೂಲ ಸಂದೇಶ

393
00:33:15,450 --> 00:33:22,490
ನಾವು ಅಲ್ಲಿ ಕೆಲವು ಎಚ್ಗಳು ಮತ್ತು ಟಿಗಳು ನೋಡಿ ನಿರೀಕ್ಷೆ.

394
00:33:22,490 --> 00:33:28,720
ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು ಕೇವಲ 1 ಟಿ ಮತ್ತು 2 ಎಚ್ಗಳು ನೋಡಿ ನಿರೀಕ್ಷೆ.

395
00:33:32,510 --> 00:33:37,440
ಇಲ್ಲಿ ನಾವು hth.txt ಇವೆ. ಇದು ನಿಜಕ್ಕೂ HTH ಹೊಂದಿದೆ.

396
00:33:37,440 --> 00:33:41,270
ನಾವು ನೋಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದರೂ, ಇಲ್ಲ ಸೇರಿಸಲಾಗಿದೆ, ಒಂದು ಹೊಸಸಾಲು ಪಾತ್ರವಾಗಿದೆ.

397
00:33:41,270 --> 00:33:53,190
ಹಫ್ ಕಡತ hth.bin ಸಹ ಹೊಸಸಾಲು ಅಕ್ಷರ ಎನ್ಕೋಡಿಂಗ್ ಇದೆ.

398
00:33:55,680 --> 00:34:01,330
ಇಲ್ಲಿ ನಾವು, ಆದೇಶ ಹೊಸಸಾಲು ನಂತರ HTH ಮತ್ತು ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ

399
00:34:01,330 --> 00:34:07,340
ನಾವು ಕೇವಲ ಒಂದು 1 ಬಹುಶಃ ಎಚ್ ನಿರೂಪಿಸಲಾಗಿದೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ನೋಡಬಹುದು

400
00:34:07,340 --> 00:34:17,120
ನಂತರ ಟಿ ಬಹುಶಃ 01 ಮತ್ತು ನಂತರ ಮುಂದಿನ ಎಚ್ 1 ಹಾಗು

401
00:34:17,120 --> 00:34:21,139
ಮತ್ತು ನಾವು ಎರಡು 0 ಸೆ ಸೂಚಿಸಲಾಗುತ್ತದೆ ಒಂದು ಹೊಸಸಾಲು ಹೊಂದಿರುತ್ತವೆ.

402
00:34:22,420 --> 00:34:24,280
ಕೂಲ್.

403
00:34:26,530 --> 00:34:31,600
>> ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು ಅನೇಕ. ಸಿ ವ್ಯವಹರಿಸುವ ಮತ್ತು. ಆಗಿರುವ ಕಾರಣ H ಕಡತಗಳನ್ನು,

404
00:34:31,600 --> 00:34:36,350
ನಾವು, ಕಂಪೈಲರ್ ಒಂದು ಬಹಳ ಸಂಕೀರ್ಣ ವಾದವನ್ನು ಹೊಂದಿರುವ ನೀನು

405
00:34:36,350 --> 00:34:40,460
ಮತ್ತು ಇಲ್ಲಿ ನಾವು ನಿಮಗೆ ಡಂಪ್ ಮಾಡುವ ಒಂದು Makefile ಹೊಂದಿರುತ್ತವೆ.

406
00:34:40,460 --> 00:34:47,070
ಆದರೆ ವಾಸ್ತವವಾಗಿ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ puff.c ಫೈಲ್ ಮಾಡಲು ಹೋಗಬೇಕಾಗುತ್ತದೆ.

407
00:34:47,070 --> 00:34:54,330
Makefile ವಾಸ್ತವವಾಗಿ ನೀವು puff.c ತಯಾರಿಸುವ ವ್ಯವಹರಿಸುವುದಿಲ್ಲ.

408
00:34:54,330 --> 00:34:59,310
ನಾವು Makefile ಸಂಪಾದಿಸಲು ನಿಮಗೆ ಸುಮಾರು ಬಿಟ್ಟು ನೀವು.

409
00:34:59,310 --> 00:35:05,930
ನಿಮ್ಮ ಎಲ್ಲಾ ರೀತಿಯ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ ಸಂದರ್ಭದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನೀವು ಅವುಗಳನ್ನು ಎಲ್ಲಾ ಮಾಡುತ್ತದೆ.

410
00:35:05,930 --> 00:35:10,760
ಕಳೆದ pset ರಿಂದ Makefile ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಿದರೆ ಹಿಂಜರಿಯಬೇಡಿ

411
00:35:10,760 --> 00:35:17,400
ಹಾಗೆಯೇ ನಿಮ್ಮ ಪಫ್ ಫೈಲ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಈ ಆಫ್ ಹೋಗುವ

412
00:35:17,400 --> 00:35:20,260
ಈ Makefile ಸಂಪಾದಿಸುವುದರ ಮೂಲಕ.

413
00:35:20,260 --> 00:35:22,730
ನಮ್ಮ ವಿತರಣಾ ಕೋಡ್ ಅದರ ಬಗ್ಗೆ.

414
00:35:22,730 --> 00:35:28,380
>> ಆ ಮೂಲಕ ಪಡೆದ ಒಮ್ಮೆ, ನಂತರ ಇಲ್ಲಿ ಮತ್ತೊಂದು ಜ್ಞಾಪನೆ ಇಲ್ಲಿದೆ

415
00:35:28,380 --> 00:35:30,980
ಹೇಗೆ ನಾವು ಹಫ್ಮನ್ ಗ್ರಂಥಿಗಳು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೀನು.

416
00:35:30,980 --> 00:35:35,400
ನಾವು ಅವುಗಳನ್ನು ಇನ್ನು ಮುಂದೆ ಘಟಕಗಳು ಕರೆ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ; ನಾವು ಅವುಗಳನ್ನು ಮರಗಳು ಕರೆ ಮಾಡಲು ನೀನು

417
00:35:35,400 --> 00:35:39,260
ನಾವು ಚಾರ್ ತಮ್ಮ ಚಿಹ್ನೆಯಾಗಿ ಪ್ರತಿನಿಧಿಸುವ ಎಂದು ನೀನು ಅಲ್ಲಿ,

418
00:35:39,260 --> 00:35:43,340
ಅವುಗಳ ಆವರ್ತನ, ಒಂದು ಪೂರ್ಣಾಂಕದೊಂದಿಗೆ ಸಂಭವಿಸುವಿಕೆಗಳ ಸಂಖ್ಯೆ.

419
00:35:43,340 --> 00:35:47,370
ಇದು ಒಂದು ಫ್ಲೋಟ್ ಹೆಚ್ಚು ನಿಖರ ಏಕೆಂದರೆ ನಾವು ಬಳಸುತ್ತಿದ್ದೀರಿ.

420
00:35:47,370 --> 00:35:52,980
ನಂತರ ನಾವು ಎಡ ಮಗುವಿನ ಜೊತೆಗೆ ಸರಿಯಾದ ಮಗುವಿಗೆ ಇನ್ನೊಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ.

421
00:35:52,980 --> 00:35:59,630
ಒಂದು ಕಾಡು, ನಾವು ಕಂಡುಕೊಂಡ, ಕೇವಲ ಮರಗಳ ಲಿಂಕ್ ಪಟ್ಟಿ.

422
00:35:59,630 --> 00:36:04,670
ಅಂತಿಮವಾಗಿ, ನಾವು ನಮ್ಮ ಹಫ್ ಕಡತವನ್ನು ನಿರ್ಮಿಸುವ ಮಾಡಿದಾಗ,

423
00:36:04,670 --> 00:36:07,580
ನಮ್ಮ ಅರಣ್ಯ ಕೇವಲ 1 ವೃಕ್ಷವನ್ನು ಬಯಸುವ -

424
00:36:07,580 --> 00:36:12,420
1 ಮರ, ಅನೇಕ ಮಕ್ಕಳು 1 ಮೂಲ.

425
00:36:12,420 --> 00:36:20,840
ಮೊದಲು ನಾವು ನಮ್ಮ ಹಫ್ಮನ್ ಮರಗಳು ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ ಮೇಲೆ,

426
00:36:20,840 --> 00:36:25,360
ನಮ್ಮ ಪರದೆಯ ಮೇಲೆ ನೋಡ್ಗಳ ಎಲ್ಲಾ ಮೂಲಕ ಆರಂಭವಾಯಿತು

427
00:36:25,360 --> 00:36:27,790
ಮತ್ತು, ಈ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಎಂದು ನೀನು ಹೇಳುವ

428
00:36:27,790 --> 00:36:32,920
ಅಂತಿಮವಾಗಿ ಅವು ಎಲೆಗಳು ಎಂದು ನೀನು, ಮತ್ತು ಈ ತಮ್ಮ ಸಂಕೇತವಾಗಿದೆ, ಈ ಅವುಗಳ ಆವರ್ತನ.

429
00:36:32,920 --> 00:36:42,070
ನಾವು 3 ಅಕ್ಷರಗಳು ಹೊಂದಿದ್ದರೆ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿ, ಆ 3 ಮರಗಳ ಕಾಡಿನ.

430
00:36:42,070 --> 00:36:45,150
ನಂತರ ನಾವು ಮೊದಲ ಪೋಷಕ ಸೇರಿಸಿದಾಗ, ಮೇಲೆ ಹೋಗಿ ಎಂದು

431
00:36:45,150 --> 00:36:48,080
ನಾವು 2 ಮರಗಳ ಕಾಡು ಮಾಡಿದ.

432
00:36:48,080 --> 00:36:54,930
ನಮ್ಮ ಕಾಡು ಆ ಮಕ್ಕಳ 2 ತೆಗೆದು ನಂತರ ಪೋಷಕ ನೋಡ್ ಬದಲಾಯಿಸಿಕೊಂಡವು

433
00:36:54,930 --> 00:36:58,820
ಮಕ್ಕಳು ಆ 2 ಗ್ರಂಥಿಗಳು ಹೊಂದಿತ್ತು.

434
00:36:58,820 --> 00:37:05,600
ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಕಳೆದ ಹಾಗೆ, Bs ನಮ್ಮ ಉದಾಹರಣೆಗೆ ತಯಾರಿಸುವ ಹಂತದ, ಮತ್ತು ಸಿ

435
00:37:05,600 --> 00:37:08,030
ಅಂತಿಮ ಮೂಲ ಮಾಡಲು ಎಂದು,

436
00:37:08,030 --> 00:37:13,190
ಮತ್ತು ಆದ್ದರಿಂದ 1 ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ನಮ್ಮ ಒಟ್ಟು ಎಣಿಕೆ ತರುವುದನ್ನು.

437
00:37:13,190 --> 00:37:18,140
ಎಲ್ಲರೂ ನಿಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಅನೇಕ ಮರಗಳು ಜೊತೆ ಸ್ಟಾರ್ಟ್ ಔಟ್ ಹೇಗೆ ನೋಡಿ ಇಲ್ಲ

438
00:37:18,140 --> 00:37:22,520
ಮತ್ತು 1 ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು? ಸರಿ. ಕೂಲ್.

439
00:37:25,530 --> 00:37:28,110
>> ನಾವು ಪಫ್ ಫಾರ್ ಮಾಡಲು ಬೇಕು?

440
00:37:28,110 --> 00:37:37,110
ನಾವು ಏನು ಮಾಡಬೇಕು ಎಂದು ಯಾವಾಗಲೂ, ಅವರು ನಮಗೆ ಇನ್ಪುಟ್ ಬಲ ರೀತಿಯ ನೀಡಿ ಖಾತ್ರಿ ಇದೆ

441
00:37:37,110 --> 00:37:39,090
ನಾವು ವಾಸ್ತವವಾಗಿ ಪ್ರೊಗ್ರಾಮನ್ನು ಇದರಿಂದ.

442
00:37:39,090 --> 00:37:43,130
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವರು ತಮ್ಮ ಮೊದಲ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟನ್ನು ನಂತರ ನಮಗೆ ನೀಡುವ ಎಂದು ನೀನು

443
00:37:43,130 --> 00:37:53,440
2: ನಾವು ಇಳಿಸು ಮತ್ತು ಒತ್ತಡ ನಿವಾರಣೆಯಾಗಲ್ಪಡುತ್ತದೆ ಕಡತದ ಔಟ್ಪುಟ್ ಬಯಸುವ ಕಡತ.

444
00:37:53,440 --> 00:38:00,410
ಆದರೆ ಒಮ್ಮೆ ನಾವು, ಅವರು ಮೌಲ್ಯಗಳ ಸರಿಯಾದ ಪ್ರಮಾಣವನ್ನು ನಮಗೆ ಪಾಸ್ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

445
00:38:00,410 --> 00:38:05,820
ನಾವು ಇನ್ಪುಟ್ ಹಫ್ ಕಡತ ಅಥವಾ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೇನೆ.

446
00:38:05,820 --> 00:38:10,420
ಮತ್ತು ನಂತರ ಒಮ್ಮೆ ನಾವು, ನಂತರ ನಮ್ಮ ಮರದ ನಿರ್ಮಿಸಲು ಬಯಸುವ, ಅದು ಒಂದು ಕಡತ ಹಫ್ ಎಂದು ಖಾತರಿ

447
00:38:10,420 --> 00:38:20,940
ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ ವ್ಯಕ್ತಿ ನಿರ್ಮಿಸಿದ ಮರದ ಹೊಂದುವಂತಹ ಇಂತಹ ಮರ ನಿರ್ಮಿಸಲು.

448
00:38:20,940 --> 00:38:25,840
ನಾವು ಮರದ ನಿರ್ಮಿಸಲು ನಂತರ, ನಂತರ ನಾವು 0 ಸೆ ಮತ್ತು ಅವು ಹಾದುಹೋಗುವ 1 ಸೆ, ವ್ಯವಹರಿಸಲು ಮಾಡಬಹುದು

449
00:38:25,840 --> 00:38:29,590
ಅದು ಒಂದೇ, ಏಕೆಂದರೆ, ನಮ್ಮ ಮರ ಉದ್ದಕ್ಕೂ ಆ ಅನುಸರಿಸಿ

450
00:38:29,590 --> 00:38:33,510
ನಂತರ, ಆ ಸಂದೇಶವನ್ನು ಬರೆಯಲು ಅಕ್ಷರಗಳನ್ನು ಮತ್ತೆ ಬಿಟ್ಗಳು ಅರ್ಥೈಸುತ್ತಾರೆ.

451
00:38:33,510 --> 00:38:35,880
ಮತ್ತು ನಂತರ ಕೊನೆಯಲ್ಲಿ ನಾವು ಇಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಏಕೆಂದರೆ

452
00:38:35,880 --> 00:38:38,110
ನಾವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಹೊಂದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ

453
00:38:38,110 --> 00:38:41,330
ಮತ್ತು ನಾವು ಮುಕ್ತ ಎಲ್ಲವೂ.

454
00:38:42,820 --> 00:38:46,430
>> ಸರಿಯಾದ ಬಳಕೆಯ ಖಚಿತಪಡಿಸುವುದು ಈಗ ನಮಗೆ ಹಳೆಯ Hat ಹೊಂದಿದೆ.

455
00:38:46,430 --> 00:38:51,980
ನಾವು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಇದು ಹೊಗಳಿಕೆ ಫೈಲ್ ಹೆಸರು ಎಂದು ಹೋಗುತ್ತದೆ,

456
00:38:51,980 --> 00:38:56,010
ಮತ್ತು ನಾವು, ಒಂದು ಔಟ್ಪುಟ್ ಸೂಚಿಸಿ

457
00:38:56,010 --> 00:39:01,580
ಆದ್ದರಿಂದ ಪಠ್ಯ ಫೈಲ್ ಇದು puffed ಔಟ್ಪುಟ್, ಕಡತ ಹೆಸರು.

458
00:39:03,680 --> 00:39:08,820
ಆ ಬಳಕೆಯು ಇಲ್ಲಿದೆ. ಮತ್ತು ಈಗ ನಾವು ಇನ್ಪುಟ್ huffed ಅಥವಾ ಖಚಿತಪಡಿಸಲು ಬಯಸುವ.

459
00:39:08,820 --> 00:39:16,420
ಯೋಚಿಸುವಾಗ, ನಮಗೆ ಎಂದು ವಿತರಣೆ ಕೋಡ್ ರಲ್ಲಿ ಏನು ಎಂದು

460
00:39:16,420 --> 00:39:21,570
ಒಂದು ಕಡತ huffed ಅಥವಾ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ?

461
00:39:21,570 --> 00:39:26,910
Huffeader ಬಗ್ಗೆ huffile.c ಮಾಹಿತಿ ಇರಲಿಲ್ಲ.

462
00:39:26,910 --> 00:39:33,430
ನಾವು ಪ್ರತಿ ಹಫ್ ಫೈಲ್ ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ಅದನ್ನು ಸಂಬಂಧಿಸಿದ Huffeader ಹೊಂದಿದೆ ತಿಳಿದಿದೆ

463
00:39:33,430 --> 00:39:37,240
ಪ್ರತಿ ಚಿಹ್ನೆಯ ಆವರ್ತನಗಳ ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು

464
00:39:37,240 --> 00:39:39,570
ಹಾಗೆಯೇ ಒಂದು checksum ಮಾಹಿತಿ.

465
00:39:39,570 --> 00:39:43,180
ನಮಗೆ ತಿಳಿದಿರುವುದು, ಆದರೆ ನಾವು, dump.c ಒಂದು ಪೀಕ್ ತೆಗೆದುಕೊಂಡಿತು

466
00:39:43,180 --> 00:39:49,120
ಇದರಲ್ಲಿ ಒಂದು ಹಫ್ ಫೈಲ್ ಆಗಿ ಓದುವ.

467
00:39:49,120 --> 00:39:53,990
ಹೀಗೆ ಮಾಡಲು, ಇದು ನಿಜವಾಗಿಯೂ huffed ಅಥವಾ ಎಂದು ಪರಿಶೀಲಿಸಲು ಹೊಂದಿತ್ತು.

468
00:39:53,990 --> 00:40:03,380
ಆದ್ದರಿಂದ ಬಹುಶಃ ನಮ್ಮ puff.c. ಒಂದು ರಚನೆ ಎಂದು dump.c ಬಳಸಬಹುದಿತ್ತು

469
00:40:03,380 --> 00:40:12,680
ಬ್ಯಾಕ್ pset 4 ನಾವು RGB ಮೂರು ರಲ್ಲಿ ನಕಲು ಫೈಲ್ copy.c ಪಡೆದಾಗ

470
00:40:12,680 --> 00:40:14,860
ಮತ್ತು ನಾವು, ವೊಡುನಿಟ್ ಮತ್ತು ಗಣಕತೆರೆ ಆ ತಿಳಿಯುತ್ತದೆ

471
00:40:14,860 --> 00:40:20,390
ಹಾಗೆಯೇ, ನೀವು ಏನು ಮಾಡಬಹುದು ಕೇವಲ CP dump.c puff.c ನಂತಹ ಆಜ್ಞೆಯನ್ನು ಇದೆ

472
00:40:20,390 --> 00:40:23,600
ಅಲ್ಲಿಯೇ ಕೋಡ್ ಕೆಲವು ಬಳಸಿ.

473
00:40:23,600 --> 00:40:28,210
ಆದಾಗ್ಯೂ, ಇದು ಒಂದು ಪ್ರಕ್ರಿಯೆಯ ಮಾಹಿತಿ ನೇರ ಎಂದು ಹಿಂದಿರುಗಬಹುದೆಂದು

474
00:40:28,210 --> 00:40:33,010
puff.c ನಿಮ್ಮ dump.c ಅನುವಾದ ಫಾರ್,

475
00:40:33,010 --> 00:40:36,160
ಆದರೆ ಕನಿಷ್ಠ ಆರಂಭಿಸಲು ಎಲ್ಲೋ ನೀವು ನೀಡುತ್ತದೆ

476
00:40:36,160 --> 00:40:40,540
ಇನ್ಪುಟ್ ವಾಸ್ತವವಾಗಿ huffed ಅಥವಾ ಖಚಿತಪಡಿಸಲು ಹೇಗೆ

477
00:40:40,540 --> 00:40:43,240
ಹಾಗೆಯೇ ಕೆಲವು ಸಂಗತಿಗಳು.

478
00:40:45,930 --> 00:40:50,250
ನಾವು ಸರಿಯಾದ ಬಳಕೆಯ ಖಾತರಿ ಮತ್ತು ಇನ್ಪುಟ್ huffed ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಖಾತ್ರಿಪಡಿಸಿದೆ.

479
00:40:50,250 --> 00:40:53,570
ನಾವು ನಮ್ಮ ಸರಿಯಾದ ದೋಷ ತಪಾಸಣೆ ಮಾಡಿದ ಮಾಡಿದ ಪ್ರತಿ ಸಮಯ,

480
00:40:53,570 --> 00:41:01,520
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಇರುವ ವೇಳೆ, ಹಿಂದಿರುಗಿದ ಮತ್ತು ಕೆಲವು ವೈಫಲ್ಯ ಉಂಟಾದರೆ ಕಾರ್ಯ ತೊರೆದು.

481
00:41:01,520 --> 00:41:07,170
>> ಈಗ ನಾವು ಬಯಸುವ ವಾಸ್ತವಿಕ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ಆಗಿದೆ.

482
00:41:08,840 --> 00:41:12,640
ನಾವು ಫಾರೆಸ್ಟ್ ನೋಡಿದರೆ, 2 ಮುಖ್ಯ ಕಾರ್ಯಗಳು ಇವೆ

483
00:41:12,640 --> 00:41:15,800
ನಾವು ಅತ್ಯಂತ ಪರಿಚಿತ ಆಗಲು ಬಯಸುವ ಹೋಗಿ ನೀವು.

484
00:41:15,800 --> 00:41:23,870
ಇಲ್ಲ ಬೂಲಿಯನ್ ಕಾರ್ಯ ಸಸ್ಯದ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿನ ಒಂದು ಅಲ್ಲದ 0 ಆವರ್ತನ ಮರ ಸಸ್ಯಗಳು.

485
00:41:23,870 --> 00:41:29,250
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಕಾಡು ಮತ್ತು ಒಂದು ಮರದ ಒಂದು ಪಾಯಿಂಟರ್ ಒಂದು ದಿಕ್ಸೂಚಕ ಹಾದುಹೋಗುತ್ತವೆ.

486
00:41:32,530 --> 00:41:40,340
ತ್ವರಿತ ಪ್ರಶ್ನೆ: ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಮಾಡಿದಾಗ ಎಷ್ಟು ಕಾಡುಗಳ ನೀವು ಹೊಂದಿರುವಿರಿ?

487
00:41:44,210 --> 00:41:46,650
ನಮ್ಮ ಅರಣ್ಯ ಹಕ್ಕು, ನಮ್ಮ ಕ್ಯಾನ್ವಾಸ್ ಹಾಗೆ?

488
00:41:46,650 --> 00:41:50,800
ನಾವು ಕೇವಲ 1 ಅರಣ್ಯ ಹೊಂದಿರುವ ನೀನು, ಆದರೆ ಅನೇಕ ಮರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಎಂದು ನೀನು.

489
00:41:50,800 --> 00:41:57,590
ನೀವು ಸಸ್ಯ ಕರೆ ಆದ್ದರಿಂದ ಮೊದಲು, ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ಅರಣ್ಯ ಮಾಡಲು ಬಯಸುವ ಎಂದು ನೀನು.

490
00:41:57,590 --> 00:42:04,430
ನೀವು ಒಂದು ಅರಣ್ಯ ಮಾಡಬಹುದು ಹೇಗೆ forest.h ಕುರಿತು ಒಂದು ಆಜ್ಞೆಯನ್ನು ಆ ಇಲ್ಲ.

491
00:42:04,430 --> 00:42:09,270
ನೀವು ಮರದ ಸಸ್ಯಗಳಿಗೆ ಮಾಡಬಹುದು. ನಾವು ಹೇಗೆ ಗೊತ್ತು.

492
00:42:09,270 --> 00:42:11,590
ಮತ್ತು ನಂತರ ನೀವು, ಕಾಡು ಮರದ ಆಯ್ಕೆ ಮಾಡಬಹುದು

493
00:42:11,590 --> 00:42:17,540
ಕಡಿಮೆ ತೂಕದ ಒಂದು ಮರ ತೆಗೆದು ಮತ್ತು ನಿಮ್ಮನ್ನು ಪಾಯಿಂಟರ್ ನೀಡುವ.

494
00:42:17,540 --> 00:42:23,090
ನಾವು ಉದಾಹರಣೆಗಳು ನಾವೇ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ ಯೋಚಿಸುವಾಗ,

495
00:42:23,090 --> 00:42:27,980
ನಾವು ಬರೆಯುವ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸರಳವಾಗಿ ಕೇವಲ ಕೊಂಡಿಗಳು ಸೇರಿಸಲಾಗಿದೆ.

496
00:42:27,980 --> 00:42:31,680
ಆದರೆ ಇಲ್ಲಿ ಬದಲಿಗೆ ಕೇವಲ, ಲಿಂಕ್ಗಳನ್ನು ಸೇರಿಸಿ

497
00:42:31,680 --> 00:42:40,630
ಆ ನೋಡ್ಗಳ 2 ತೆಗೆದು ನಂತರ ಮತ್ತೊಂದು ಮೂಲಕ ಬದಲಿಗೆ ನೀವು ಹೆಚ್ಚು ತಿಳಿಯುತ್ತಾರೆ.

498
00:42:40,630 --> 00:42:44,200
ಉಂಟಾಗದಂತೆ ಮತ್ತು ನಾಟಿ ಪರಿಭಾಷೆಯಲ್ಲಿ ಎಂದು ವ್ಯಕ್ತಪಡಿಸಲು,

499
00:42:44,200 --> 00:42:48,840
ನೀವು 2 ಮರಗಳು ಉಂಟಾಗದಂತೆ ಮತ್ತು ನಂತರ ಮತ್ತೊಂದು ಮರವನ್ನು ನೆಟ್ಟು ನೀವು

500
00:42:48,840 --> 00:42:54,060
ನೀವು ಮಕ್ಕಳಿಗೆ ಎಂದು ಆಯ್ಕೆ ಆ 2 ಮರಗಳನ್ನು ಹೊಂದಿದೆ.

501
00:42:57,950 --> 00:43:05,280
ಹಫ್ಮನ್ ನ ಮರದ ನಿರ್ಮಿಸಲು, ನೀವು ಸಲುವಾಗಿ ಚಿಹ್ನೆಗಳು ಮತ್ತು ತರಂಗಾಂತರಗಳನ್ನು ನಲ್ಲಿ ಓದಬಹುದು

502
00:43:05,280 --> 00:43:10,790
Huffeader ನೀವು ಆ ನೀಡುತ್ತದೆ ಏಕೆಂದರೆ,

503
00:43:10,790 --> 00:43:14,250
ನೀವು ಆವರ್ತನಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ.

504
00:43:14,250 --> 00:43:19,660
ಆದ್ದರಿಂದ ನೀವು ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಅದನ್ನು 0 ಜೊತೆ ಏನು ನಿರ್ಲಕ್ಷಿಸಿ

505
00:43:19,660 --> 00:43:23,760
ನಾವು ಕೊನೆಯಲ್ಲಿ 256 ಎಲೆಗಳು ಬಯಸುವ ಕಾರಣ.

506
00:43:23,760 --> 00:43:27,960
ನಾವು ಕೇವಲ ಪಾತ್ರಗಳು ಎಂದು ಎಲೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಬಯಸುವ

507
00:43:27,960 --> 00:43:31,600
ಎಂದು ವಾಸ್ತವವಾಗಿ ಕಡತ ಬಳಸಲಾಗುತ್ತದೆ.

508
00:43:31,600 --> 00:43:37,590
ನೀವು ಆ ಚಿಹ್ನೆಗಳಲ್ಲಿ ಓದಲು, ಮತ್ತು 0 ಆವರ್ತನಗಳನ್ನು ಹೊಂದಿರುವ ಆ ಸಂಕೇತಗಳ ಪ್ರತಿ ಮಾಡಬಹುದು

509
00:43:37,590 --> 00:43:40,440
ಆ ಮರಗಳು ಮುಂದುವರೆಸುತ್ತೇವೆ.

510
00:43:40,440 --> 00:43:45,990
ನೀವು ಏನು ಮಾಡಬಹುದು, ನೀವು 0 ಆವರ್ತನ ಸಂಕೇತ ಓದಲು ಪ್ರತಿ ಸಮಯ

511
00:43:45,990 --> 00:43:50,660
ನೀವು ಅರಣ್ಯ ಆ ಮರದ ಸಸ್ಯಗಳಿಗೆ ಮಾಡಬಹುದು.

512
00:43:50,660 --> 00:43:56,620
ನೀವು ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ಸಸ್ಯಗಳಿಗೆ ಒಮ್ಮೆ ಒಡಹುಟ್ಟಿದವರ ಆ ಮರಗಳನ್ನು ಸೇರಿ, ಮಾಡಬಹುದು

513
00:43:56,620 --> 00:44:01,130
ಆದ್ದರಿಂದ, ನಾಟಿ ಮತ್ತು ನೀವು ಆಯ್ಕೆ ಅಲ್ಲಿ ಉಂಟಾಗದಂತೆ 2 ಮತ್ತು ನಂತರ PLANT 1 ಹಿಂದಕ್ಕೆ ಹೋಗಿ

514
00:44:01,130 --> 00:44:05,820
ಅಲ್ಲಿ 1 ನೀವು ಸಸ್ಯ ನೀವು ಆಯ್ಕೆ ಎಂದು 2 ಮಕ್ಕಳ ಮೂಲ ಎಂದು.

515
00:44:05,820 --> 00:44:11,160
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅಂತಿಮ ಪರಿಣಾಮವಾಗಿ ನಿಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಒಂದು ಮರದ ಏರಲಿದೆ.

516
00:44:16,180 --> 00:44:18,170
ನೀವು ನಿಮ್ಮ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು ಹೇಗೆ.

517
00:44:18,170 --> 00:44:21,850
>> ಇಲ್ಲಿ ತಪ್ಪು ಹೋಗಿ ಎಂದು ಅನೇಕ ವಿಷಯಗಳನ್ನು

518
00:44:21,850 --> 00:44:26,580
ಏಕೆಂದರೆ ನಾವು ಹೊಸ ಮರಗಳು ಮಾಡುವ ಹಾಗೆ ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ವಿಷಯಗಳನ್ನು ವ್ಯವಹರಿಸುವ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ.

519
00:44:26,580 --> 00:44:30,450
ನಾವು ಪಾಯಿಂಟರ್ಸ್ ವ್ಯವಹರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಮೊದಲು,

520
00:44:30,450 --> 00:44:36,580
ನಾವು malloc'd ಬಂದಾಗಲೆಲ್ಲಾ ನಾವು ನಮಗೆ ನಲ್ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸಿದರು.

521
00:44:36,580 --> 00:44:42,770
ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಹಲವಾರು ಹಂತಗಳನ್ನು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇರುವಂತೆ ಹೋಗುವ

522
00:44:42,770 --> 00:44:45,920
ಅಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವಿಫಲರಾಗಬಹುದಾದ.

523
00:44:45,920 --> 00:44:51,310
ನೀವು ಏನು ಮಾಡಲು ಬಯಸುವ, ನೀವು ಆ ದೋಷಗಳು ನಿರ್ವಹಿಸುವ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ ಆಗಿದೆ

524
00:44:51,310 --> 00:44:54,580
ಮತ್ತು ವಿಶೇಷ ಇದು, ಆಕರ್ಷಕವಾಗಿ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೇಳುತ್ತಾರೆ

525
00:44:54,580 --> 00:45:00,280
ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸುವ ಹೊಂದಿದೆ ಏಕೆ ಅವುಗಳನ್ನು ಹೇಳುವ ಬಳಕೆದಾರನಿಗೆ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಇಷ್ಟ

526
00:45:00,280 --> 00:45:03,050
ನಂತರ ಕೂಡಲೇ ಅದನ್ನು ತ್ಯಜಿಸಿದರು.

527
00:45:03,050 --> 00:45:09,490
ಈ ದೋಷ ನಿರ್ವಹಣೆ ಮಾಡಲು, ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ನೆನಪಿಡಿ

528
00:45:09,490 --> 00:45:12,160
ಒಂದು ವೈಫಲ್ಯ ಎಂಬುದನ್ನು ಪ್ರತಿಯೊಂದು ಸಮಯ.

529
00:45:12,160 --> 00:45:14,660
ನೀವು ಒಂದು ಹೊಸ ಪಾಯಿಂಟರ್ ಮಾಡುತ್ತಿದ್ದೀಯ ಪ್ರತಿಯೊಂದು ಸಮಯ

530
00:45:14,660 --> 00:45:17,040
ನೀವು ಯಶಸ್ವಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

531
00:45:17,040 --> 00:45:20,320
ನಾವು ಹೊಸ ಪಾಯಿಂಟರ್ ಮತ್ತು malloc ಒದಗಿಸಿ ಇದೆ ಮಾಡಲು ಯಾವ ಮೊದಲು,

532
00:45:20,320 --> 00:45:22,380
ನಂತರ ನಾವು ಪಾಯಿಂಟರ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಎಂದು ಪರಿಶೀಲಿಸಿ ಎಂದು.

533
00:45:22,380 --> 00:45:25,670
ಆದ್ದರಿಂದ, ನೀವು ಹಾಗೆ ಕೇವಲ ಮಾಡಬಹುದು ಅಲ್ಲಿ ಕೆಲವು ನಿದರ್ಶನಗಳು ಇರುವಂತೆ ಹೋಗುವ

534
00:45:25,670 --> 00:45:28,610
ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಕ್ರಿಯೆ ಎಂದು ನೀವು

535
00:45:28,610 --> 00:45:33,100
ಮತ್ತು ಆ ಕಾರ್ಯವನ್ನು ಒಳಗೆ ಆ mallocing ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂದು ಒಂದಾಗಿದೆ.

536
00:45:33,100 --> 00:45:39,110
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಕೋಡ್ ಕಾರ್ಯಗಳನ್ನು ಕೆಲವು ಮತ್ತೆ ನೋಡಿದರೆ,

537
00:45:39,110 --> 00:45:42,260
ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಬೂಲಿಯನ್ ಕ್ರಿಯೆಗಳು.

538
00:45:42,260 --> 00:45:48,480
ಅಮೂರ್ತ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು foo ಎಂಬ ಬೂಲಿಯನ್ ಫಂಕ್ಷನ್ ವೇಳೆ,

539
00:45:48,480 --> 00:45:54,580
ಮೂಲತಃ, ನಾವು, foo ಮಾಡುತ್ತದೆ ಕೆಲಸದಲ್ಲಿರುವಾಗ ಜೊತೆಗೆ ನೀವು ಭಾವಿಸಬಹುದು

540
00:45:54,580 --> 00:45:57,210
ಇದು ಒಂದು ಬೂಲಿಯನ್ ಕಾರ್ಯ ರ ಇದು ಸರಿ ಅಥವಾ ತಪ್ಪು ಹಿಂದಿರುಗಿಸುತ್ತದೆ -

541
00:45:57,210 --> 00:46:01,300
ವೇಳೆ ನಿಜವಾದ ಯಶಸ್ಸು, ತಪ್ಪು ಇಲ್ಲದಿದ್ದರೆ.

542
00:46:01,300 --> 00:46:06,270
ನಾವು foo ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ನಿಜವಾದ ಅಥವಾ ಸುಳ್ಳು ಎಂದು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ.

543
00:46:06,270 --> 00:46:10,400
ಇದು ಸುಳ್ಳು ಆಗಿದ್ದರೆ, ನಾವು ಸಂದೇಶವನ್ನು ರೀತಿಯ ಮುದ್ರಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಅರ್ಥ

544
00:46:10,400 --> 00:46:14,390
ತದನಂತರ ಪ್ರೋಗ್ರಾಂ ತ್ಯಜಿಸಿದರು.

545
00:46:14,390 --> 00:46:18,530
ನಾವು ಮಾಡಲು ಬಯಸುವ foo ಆಫ್ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ.

546
00:46:18,530 --> 00:46:23,310
Foo ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆಗ ನಾವು ದೋಷ ರೀತಿಯ ಎದುರಿಸಿದೆ ತಿಳಿದಿದೆ

547
00:46:23,310 --> 00:46:25,110
ಮತ್ತು ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸುವ ಅವಶ್ಯಕತೆ.

548
00:46:25,110 --> 00:46:35,600
ಇದನ್ನು ಮಾಡಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ನಿಜವಾದ ಕಾರ್ಯ ಸ್ವತಃ ನಿಮ್ಮ ಪರಿಸ್ಥಿತಿ ಅಲ್ಲಿ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದೆ.

549
00:46:35,600 --> 00:46:39,320
Foo X ರಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಸೇ.

550
00:46:39,320 --> 00:46:43,390
ನಾವು ಒಂದು ಸ್ಥಿತಿ ಎಂದು ಹೊಂದಿವೆ (foo (x)).

551
00:46:43,390 --> 00:46:50,900
Foo ಪಾಲಿಸಲು ಕೊನೆಯಲ್ಲಿ ಇದು ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಮೂಲತಃ, ಎಂದು, ಅಂದರೆ

552
00:46:50,900 --> 00:46:57,390
ಕಾರ್ಯ foo ​​ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಏಕೆಂದರೆ ನಾವು ಈ ಮಾಡಬಹುದು

553
00:46:57,390 --> 00:47:00,500
ಇಡೀ ಪರಿಸ್ಥಿತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಸಲುವಾಗಿ.

554
00:47:00,500 --> 00:47:06,500
ಆದ್ದರಿಂದ ಆ ಕಾರ್ಯ ನಿಜವಾದ ಮರಳಿ ಯಶಸ್ವಿ ವೇಳೆ ನೀವು ಏನಾದರೂ ಮಾಡಬಹುದು ಹೇಗೆ.

555
00:47:06,500 --> 00:47:11,800
ಆದರೆ ನೀವು ದೋಷ ಪರಿಶೀಲನೆ ಇರುವಾಗ, ನಿಮ್ಮ ಕಾರ್ಯವನ್ನು ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಬಿಟ್ಟು ಬಯಸುವ.

556
00:47:11,800 --> 00:47:16,090
ನೀವು ಏನು ಮಾಡಬಹುದು ಕೇವಲ ಸೇರಿಸಿ ಒಂದು == ಸುಳ್ಳು ಅಥವಾ ಇದು ಮುಂದೆ ಒಂದು ಬ್ಯಾಂಗ್ ಸೇರಿಸಿ

557
00:47:16,090 --> 00:47:21,010
ತದನಂತರ ನೀವು (! foo) ವೇಳೆ ಹೊಂದಿರುತ್ತವೆ.

558
00:47:21,010 --> 00:47:29,540
ಸೂಕ್ತ ದೇಹದ ಒಳಗೆ ನೀವು ದೋಷ ನಿಭಾಯಿಸುವ ಎಲ್ಲಾ ಹೊಂದಿರುತ್ತದೆ

559
00:47:29,540 --> 00:47:36,940
ಆದ್ದರಿಂದ "ಈ ಮರದ ರಚಿಸಲಾಗಲಿಲ್ಲ", ಹಾಗೆ ನಂತರ 1 ಅಥವಾ ಸ್ವಲ್ಪ ಹಿಂತಿರುಗಿ.

560
00:47:36,940 --> 00:47:43,340
ಅದು ಏನು, ಆದರೂ, foo ಸುಳ್ಳು ಮರಳಿದರು ಸಹ ಎಂದು ಹೊಂದಿದೆ -

561
00:47:43,340 --> 00:47:46,980
Foo ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಸೇ.

562
00:47:46,980 --> 00:47:51,060
ನಂತರ ನೀವು ಮತ್ತೆ foo ಕರೆಯಲು ಹೊಂದಿಲ್ಲ. ಒಂದು ಸಾಮಾನ್ಯ ತಪ್ಪುಗ್ರಹಿಕೆಯಾಗಿದೆ ಇಲ್ಲಿದೆ.

563
00:47:51,060 --> 00:47:54,730
ನಿಮ್ಮ ಸ್ಥಿತಿಯನ್ನು ಏಕೆಂದರೆ, ಇದು ಈಗಾಗಲೇ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದ,

564
00:47:54,730 --> 00:47:59,430
ನೀವು ಮರದ ಅಥವಾ ಆ ತರಹದ್ದನ್ನು ಮಾಡುವ ಬಳಸುತ್ತಿದ್ದರೆ ನೀವು ಈಗಾಗಲೇ ಪರಿಣಾಮವಾಗಿ ಹೊಂದಿವೆ

565
00:47:59,430 --> 00:48:01,840
ಅಥವಾ ಸಸ್ಯ ಅಥವಾ ಪಿಕ್ ಅಥವಾ ಏನೋ.

566
00:48:01,840 --> 00:48:07,460
ಇದು ಈಗಾಗಲೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ. ಇದು ಈಗಾಗಲೇ ಕಾರ್ಯರೂಪಕ್ಕೆ ನ.

567
00:48:07,460 --> 00:48:10,730
ಆದ್ದರಿಂದ ಸ್ಥಿತಿಯಂತೆ ಬೂಲಿಯನ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಉಪಯುಕ್ತವಾಗಿರುವ

568
00:48:10,730 --> 00:48:13,890
ಏಕೆಂದರೆ ಅಥವಾ ನಿಜವಾಗಿಯೂ ಲೂಪ್ ದೇಹದ ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ,

569
00:48:13,890 --> 00:48:18,030
ಅದು ಹೇಗಾದರೂ ಕಾರ್ಯ ನಿರ್ವಹಿಸುವಾಗ.

570
00:48:22,070 --> 00:48:27,330
>> ಕೊನೆಯ ಹಂತದ ನಮ್ಮ ಎರಡನೇ ಕಡತಕ್ಕೆ ಸಂದೇಶ ಬರೆಯಲು ಇದೆ.

571
00:48:27,330 --> 00:48:33,070
ಒಮ್ಮೆ ನಾವು ಹಫ್ಮನ್ ಟ್ರೀಯನ್ನು ರಚಿಸುವುದು, ನಂತರ ಫೈಲ್ ಸಂದೇಶವನ್ನು ಬರೆಯಲು ಬಹಳ ನೇರವಾಗಿದೆ.

572
00:48:33,070 --> 00:48:39,260
ಅದು 0 ಸೆ ಮತ್ತು 1 ಅನುಸರಿಸಲು ಈಗ ಬಹಳ ನೇರ ಇಲ್ಲಿದೆ.

573
00:48:39,260 --> 00:48:45,480
ಮತ್ತು ಆದ್ದರಿಂದ ಸಂಪ್ರದಾಯದಂತೆ ನಾವು ಹಫ್ಮನ್ ವೃಕ್ಷದಲ್ಲಿ 0 ಸೆ ಬಿಟ್ಟು ಸೂಚಿಸುವಲ್ಲಿ ತಿಳಿದಿದೆ

574
00:48:45,480 --> 00:48:48,360
ಮತ್ತು 1 ಹಕ್ಕು ಸೂಚಿಸುತ್ತವೆ.

575
00:48:48,360 --> 00:48:53,540
ನೀವು 0 ಪಡೆಯಲು ನೀವು ಬಿಟ್ ಬಿಟ್ ಓದಲು ಆದ್ದರಿಂದ ವೇಳೆ, ಪ್ರತಿ ಬಾರಿ

576
00:48:53,540 --> 00:48:59,100
ನೀವು 1 ಓದಲು ಪ್ರತಿ ಬಾರಿ ನಂತರ ಎಡ ಶಾಖೆ ಅನುಸರಿಸಿ, ಮತ್ತು ನೀವು

577
00:48:59,100 --> 00:49:02,100
ನೀವು ಬಲ ಶಾಖೆ ಅನುಸರಿಸಲು ನೀನು.

578
00:49:02,100 --> 00:49:07,570
ನೀವು ಎಲೆ ಹಿಟ್ ತನಕ ಮುಂದುವರಿಯಲು ನೀನು

579
00:49:07,570 --> 00:49:11,550
ಎಲೆಗಳು ಶಾಖೆಗಳನ್ನು ಕೊನೆಯಲ್ಲಿರಬೇಕು ಹೋಗುವ ಕಾರಣ.

580
00:49:11,550 --> 00:49:16,870
ನಾವು ಒಂದು ಎಲೆ ಅಥವಾ ಹಿಟ್ ಎಂಬುದನ್ನು ನಾವು ಹೇಗೆ ಹೇಳಬಹುದು?

581
00:49:19,800 --> 00:49:21,690
ನಾವು ಮೊದಲು ಹೇಳಿದರು.

582
00:49:21,690 --> 00:49:24,040
[ವಿದ್ಯಾರ್ಥಿ] ಪಾಯಿಂಟರ್ಸ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ. >> ಹೌದು.

583
00:49:24,040 --> 00:49:32,220
ಎಡ ಮತ್ತು ಬಲ ಎರಡೂ ಮರಗಳು ಪಾಯಿಂಟರ್ಸ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದರೆ ನಾವು ಎಲೆ ಹೊಡೆಯಲು ನೀವು ನಮಗೆ.

584
00:49:32,220 --> 00:49:34,110
ಪರಿಪೂರ್ಣ.

585
00:49:34,110 --> 00:49:40,320
ನಾವು ನಮ್ಮ ಹಫ್ ಫೈಲ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದಲು ಬಯಸುವ ತಿಳಿದಿದೆ.

586
00:49:43,870 --> 00:49:51,220
ನಾವು dump.c ಮೊದಲು ಕಂಡಿತು ಎಂದು, ಅವರು ಏನು ಅವರು ಹಫ್ ಫೈಲ್ ಆಗಿ ಬಿಟ್ ಬಿಟ್ ಓದಲು ಆಗಿದೆ

587
00:49:51,220 --> 00:49:54,560
ಮತ್ತು ಆ ಬಿಟ್ಗಳು ಬಗ್ಗೆ ಔಟ್ ಮುದ್ರಿತ.

588
00:49:54,560 --> 00:49:58,430
ನಾವು ಏನು ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ. ನಾವು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಹೊಂದಿರುವ ವಿಷಯ ಏನು ಎಂದು ನೀನು.

589
00:49:58,430 --> 00:50:03,620
ಆದರೆ ನಾವು ಮಾಡಬಹುದು ನಾವು ಬಿಟ್ ಗೆ ಓದುವ ಕೋಡ್ ಆ ಬಿಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಹೊಂದಿದೆ.

590
00:50:03,620 --> 00:50:10,250
ಇಲ್ಲಿ ನಾವು ಇದ್ದೇವೆ ಎಂದು ಪ್ರಸ್ತುತ ಬಿಟ್ ಪ್ರತಿನಿಧಿಸುವ ಪೂರ್ಣಾಂಕ ಬಿಟ್ ಹೊಂದಿವೆ.

591
00:50:10,250 --> 00:50:15,520
ನೀವು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಈ ಕಡತದಲ್ಲಿ ಬಿಟ್ಗಳು ಎಲ್ಲಾ iterating ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ.

592
00:50:15,520 --> 00:50:21,270
ಆ ಆಧಾರದ ಮೇಲೆ, ನಂತರ ನೀವು iterator ರೀತಿಯ ಬೇಕು ಎಂದು ನೀನು

593
00:50:21,270 --> 00:50:26,760
ನಿಮ್ಮ ಮರದ ಹಾದುಹೋಗಬೇಕಾದರೆ.

594
00:50:26,760 --> 00:50:31,460
ತದನಂತರ, ಬಿಟ್ 0 ಅಥವಾ 1 ಎಂಬುದನ್ನು ಆಧರಿಸಿದೆ

595
00:50:31,460 --> 00:50:36,920
ನೀವು ಎಡಕ್ಕೆ ಎಂದು iterator ಚಲಿಸುವಂತೆ ಅಥವಾ ಬಲಕ್ಕೆ ಇದು ಚಲಿಸಬೇಕೆಂದಿರುವ ಎಂದು ನೀನು

596
00:50:36,920 --> 00:50:44,080
ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ನೀವು ಎಲೆ ಹಿಟ್ ರವರೆಗೆ, ಆದ್ದರಿಂದ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ನೀವು ನೀವು ಆ ನೋಡ್ ರವರೆಗೆ

597
00:50:44,080 --> 00:50:48,260
ಯಾವುದೇ ಗ್ರಂಥಿಗಳು ಬೆಟ್ಟು ಮಾಡುವುದಿಲ್ಲ.

598
00:50:48,260 --> 00:50:54,300
ಏಕೆ ನಾವು ಹಫ್ಮನ್ ಫೈಲ್ ಆದರೆ ಮೋರ್ಸ್ ಕೋಡ್ ಈ ಮಾಡಬಹುದು?

599
00:50:54,300 --> 00:50:56,610
ಮೋರ್ಸ್ ಕೋಡ್ ದ್ವಂದ್ವಾರ್ಥತೆಯನ್ನು ಒಂದು ಬಿಟ್ ಇರುವುದರಿಂದ.

600
00:50:56,610 --> 00:51:04,440
ನಾವು ಕಾದು ಓಹ್, ಹಾಗೆ ಇರಬಹುದು, ನಾವು ಹಾದಿಯಲ್ಲಿ ಪತ್ರದಲ್ಲಿ ಹಿಟ್ ಮಾಡಿದ, ಆದ್ದರಿಂದ ಬಹುಶಃ ಇದು ನಮ್ಮ ಪತ್ರ

601
00:51:04,440 --> 00:51:08,150
ನಾವು ಸ್ವಲ್ಪ ಮುಂದೆ ಮುಂದುವರೆಯಿತು ವೇಳೆ, ನಂತರ ಮತ್ತೊಂದು ಪತ್ರ ತಾಗುವ ಆದರೆ.

602
00:51:08,150 --> 00:51:13,110
ಆದರೆ, ಹಫ್ಮನ್ ಎನ್ಕೋಡಿಂಗ್ ನಡೆಯುತ್ತಿಲ್ಲ ಹಿಂದಿರುಗಬಹುದೆಂದು

603
00:51:13,110 --> 00:51:17,540
ಆದ್ದರಿಂದ ನಾವು ನೀನು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಹೊಡೆಯಲು ಎಂದು ಖಚಿತವಾಗಿರಿ ಮಾಡಬಹುದು

604
00:51:17,540 --> 00:51:23,480
ಆ ನೋಡ್ ನ ಎಡ ಮತ್ತು ಬಲ ಮಕ್ಕಳು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಎಂದು ಆಗಿದೆ.

605
00:51:28,280 --> 00:51:32,350
>> ಅಂತಿಮವಾಗಿ, ನಾವು ನಮ್ಮ ಮೆಮೊರಿ ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುತ್ತೇನೆ.

606
00:51:32,350 --> 00:51:37,420
ನಾವು ವ್ಯವಹರಿಸುವಾಗ ನಾವು ಎರಡೂ ಹತ್ತಿರದ ಹಫ್ ಕಡತ ಬಯಸುವ

607
00:51:37,420 --> 00:51:41,940
ಹಾಗೆಯೇ ನಮ್ಮ ಕಾಡಿನಲ್ಲಿ ಮರಗಳ ಎಲ್ಲಾ ತೆಗೆದು.

608
00:51:41,940 --> 00:51:46,470
ನಿಮ್ಮ ಅನುಷ್ಠಾನದ ಆಧಾರದ ಮೇಲೆ, ನೀವು ಬಹುಶಃ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಕರೆಯಲು ಬಯಸುತ್ತೇನೆ ಎಂದು ನೀನು

609
00:51:46,470 --> 00:51:49,780
ಬದಲಿಗೆ ವಾಸ್ತವವಾಗಿ ಮರಗಳು ನಿಮ್ಮ ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗುವ.

610
00:51:49,780 --> 00:51:53,430
ನೀವು ಯಾವುದೇ ತಾತ್ಕಾಲಿಕ ಮರಗಳು ಮಾಡಿದರು ಆದರೆ, ಆ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುವಿರಿ.

611
00:51:53,430 --> 00:51:59,060
ನೀವು ಉತ್ತಮ ನಿಮ್ಮ ಕೋಡ್ ತಿಳಿಯಲು, ನೀವು ಮೆಮೊರಿ ನೀಡಲು ನೀವು ಅಲ್ಲಿ ನಿಮಗೆ.

612
00:51:59,060 --> 00:52:04,330
ಮತ್ತು ನೀವು ಹೋಗಿ ಹಾಗಿದ್ದಲ್ಲಿ, malloc ಫಾರ್ F'ing ಸಹ ಕಂಟ್ರೋಲ್ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ

613
00:52:04,330 --> 00:52:08,330
ನೋಡಿದ ಬಂದಾಗಲೆಲ್ಲಾ ನೀವು malloc ಮತ್ತು ಆ ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು

614
00:52:08,330 --> 00:52:10,190
ಆದರೆ ಕೇವಲ, ನಿಮ್ಮ ಕೋಡ್ ಮೂಲಕ ಹೋಗುವ

615
00:52:10,190 --> 00:52:14,260
ನೀವು ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮಾಡಿರಬಹುದು ಅಲ್ಲಿ ಅರ್ಥ.

616
00:52:14,260 --> 00:52:21,340
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಕೇವಲ "ಒಂದು ಕಡತದ ಕೊನೆಯಲ್ಲಿ ನಾನು ನನ್ನ ಕಾಡಿನ ಮೇಲೆ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ", ಹೇಳಬಹುದು

617
00:52:21,340 --> 00:52:23,850
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಉಚಿತ, ಆ ಸ್ಮರಣೆಯ ತೆರವುಗೊಳಿಸಿ ಎಂದು,

618
00:52:23,850 --> 00:52:28,310
"ಆಗ ನಾನು ಕೂಡ ಕಡತವನ್ನು ಮುಚ್ಚಲು ಮತ್ತು ನಂತರ ನನ್ನ ಪ್ರೋಗ್ರಾಂನಿಂದ ಹೊರನಡೆ ಹೋಗುವ ಇದೆ ಪಡೆಯಲಿದ್ದೇನೆ."

619
00:52:28,310 --> 00:52:33,810
ಆದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕ್ವಿಟ್ಸ್ ಎಂದು ಮಾತ್ರ ಸಮಯ?

620
00:52:33,810 --> 00:52:37,880
ಇಲ್ಲ, ಏಕೆಂದರೆ ಕೆಲವೊಮ್ಮೆ ಸಂಭವಿಸಿದ ದೋಷವೊಂದು ಇದ್ದಿರಬೇಕು.

621
00:52:37,880 --> 00:52:42,080
ಬಹುಶಃ ನಾವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲಾಗಲಿಲ್ಲ ಅಥವಾ ಮತ್ತೊಂದು ಮರ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ

622
00:52:42,080 --> 00:52:49,340
ಅಥವಾ ದೋಷ ರೀತಿಯ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಡೆದಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿದರು.

623
00:52:49,340 --> 00:52:56,710
ದೋಷ ಸಂಭವಿಸಿದ ನಂತರ ನಾವು ಹಿಂದಿರುಗಿ ತ್ಯಜಿಸಿದರು.

624
00:52:56,710 --> 00:53:02,040
ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಯಾವುದೇ ಸಾಧ್ಯವಾದಷ್ಟು ಸಮಯ ಬಿಟ್ಟು ಆಗುವುದಿಲ್ಲ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ

625
00:53:02,040 --> 00:53:06,980
ನೀವು ನಿಮ್ಮ ಮೆಮೊರಿಯನ್ನು ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುತ್ತೇನೆ.

626
00:53:06,980 --> 00:53:13,370
ಇದು ಕೇವಲ ನಿಮ್ಮ ಕೋಡ್ ಬಿಟ್ಟು ಪ್ರಮುಖ ಕಾರ್ಯ ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿರಬೇಕು ಹಿಂದಿರುಗಬಹುದೆಂದು.

627
00:53:13,370 --> 00:53:20,780
ನಿಮ್ಮ ಕೋಡ್ ಸಮರ್ಥವಾಗಿ ಅಕಾಲಿಕವಾಗಿ ಮರಳಿ ಎಂದು ಪ್ರತಿ ಉದಾಹರಣೆಗಾಗಿ ಹಿಂದಕ್ಕೆ ನೋಡಲು ಬಯಸುವ

628
00:53:20,780 --> 00:53:25,070
ತದನಂತರ ಉಚಿತ ಏನೇ ಮೆಮೊರಿ ಅರ್ಥವಿಲ್ಲ.

629
00:53:25,070 --> 00:53:30,830
ನೀವು ಅರಣ್ಯ ಮಾಡಲು ಮತ್ತು ತಪ್ಪು ಮರಳಿದರು ಎಂದು ತಿಳಿಸಿದ.

630
00:53:30,830 --> 00:53:34,230
ನಂತರ ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ಅರಣ್ಯ ತೆಗೆದುಹಾಕಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ

631
00:53:34,230 --> 00:53:37,080
ನೀವು ಇನ್ನೂ ಅರಣ್ಯ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ.

632
00:53:37,080 --> 00:53:42,130
ಆದರೆ ಕೋಡ್ ಪ್ರತಿಯೊಂದು ಹಂತದಲ್ಲಿ ನೀವು ಅಕಾಲಿಕವಾಗಿ ಹಿಂದಿರುಗಲು ಇರಬಹುದು ಅಲ್ಲಿ

633
00:53:42,130 --> 00:53:46,160
ನೀವು ಯಾವುದೇ ಸಂಭಾವ್ಯ ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

634
00:53:46,160 --> 00:53:50,020
>> ನಾವು ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ವ್ಯವಹರಿಸುವ ಮತ್ತು ಸಂಭವನೀಯ ಸೋರಿಕೆಯನ್ನು ಹೊಂದಿರುವ ಮಾಡಿದಾಗ,

635
00:53:50,020 --> 00:53:55,440
ನಮ್ಮ ತೀರ್ಪು ಮತ್ತು ನಮ್ಮ ಲಾಜಿಕ್ ಅನ್ನು ಮಾತ್ರ ಬಯಸುವ

636
00:53:55,440 --> 00:54:01,850
ಆದರೆ ನಾವು ಸರಿಯಾಗಿ ಅಥವಾ ನಮ್ಮ ಮೆಮೊರಿ ಎಲ್ಲ ಬಿಡುಗಡೆ ಎಂಬುದನ್ನು ದೃಢೀಕರಿಸಲು Valgrind ಬಳಸಿ.

637
00:54:01,850 --> 00:54:09,460
ನೀವು ಪಫ್ ಮೇಲೆ Valgrind ರನ್ ಮತ್ತು ನಂತರ ನೀವು ಸಹ ಇದು ಹಾದುಹೋಗಲು ಹೊಂದಿವೆ

638
00:54:09,460 --> 00:54:14,020
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಲ ಸಂಖ್ಯೆ Valgrind ಗೆ.

639
00:54:14,020 --> 00:54:18,100
ನೀವು ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಉತ್ಪಾದನೆಯ ಸ್ವಲ್ಪ ರಹಸ್ಯ ಹೊಂದಿದೆ.

640
00:54:18,100 --> 00:54:21,630
, ನಾವು ಸ್ಪೆಲ್ಲರ್ ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಸ್ವಲ್ಪ ನೆತ್ತಿಗೇರಿದೆ ಮಾಡಿದ್ದೀರಿ, ಆದರೆ ಇನ್ನೂ ಸ್ವಲ್ಪ ಹೆಚ್ಚಿನ ಸಹಾಯ ಬೇಕೇ

641
00:54:21,630 --> 00:54:26,450
ಆದ್ದರಿಂದ, ಸೋರಿಕೆ ಪರಿಶೀಲಿಸಿ = ಪೂರ್ಣ ರೀತಿಯಲ್ಲಿ ಕೆಲವು ಧ್ವಜಗಳು ಅದನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ

642
00:54:26,450 --> 00:54:32,040
ಎಂದು ಬಹುಶಃ ನಮಗೆ Valgrind ಕೆಲವು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ಔಟ್ಪುಟ್ ನೀಡುತ್ತದೆ.

643
00:54:32,040 --> 00:54:39,040
>> ನಂತರ ನೀವು ಡೀಬಗ್ ಮಾಡಿದಾಗ ಇನ್ನೊಂದು ಉಪಯುಕ್ತ ಸಲಹೆ ವ್ಯತ್ಯಾಸ ಆಜ್ಞೆಯ.

644
00:54:39,040 --> 00:54:48,520
ನೀವು, ಹಫ್ ಸಿಬ್ಬಂದಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರವೇಶಿಸಲು ರನ್ ಒಂದು ಪಠ್ಯ ಕಡತವನ್ನು ಮೇಲೆ, ಮಾಡಬಹುದು

645
00:54:48,520 --> 00:54:55,400
ತದನಂತರ ನಿರ್ದಿಷ್ಟ ಎಂದು, ಒಂದು ದ್ವಿಮಾನ ಕಡತ, ಅವಳಿ ಹಫ್ ಕಡತ ಅದನ್ನು ಔಟ್ಪುಟ್.

646
00:54:55,400 --> 00:54:59,440
ನಂತರ ಆ ದ್ವಿಮಾನ ಫೈಲ್ ನಿಮ್ಮ ಸ್ವಂತ ಪಫ್ ರನ್, ವೇಳೆ

647
00:54:59,440 --> 00:55:03,950
ನಂತರ ಆದ್ದರಿಂದ ನಿಮ್ಮ outputted ಪಠ್ಯ ಕಡತ ಒಂದೇ ಹಾಕುತ್ತದೆ

648
00:55:03,950 --> 00:55:08,200
ನೀವು ಜಾರಿಗೆ ಮೂಲ ಒಂದರಿಂದ

649
00:55:08,200 --> 00:55:15,150
ಇಲ್ಲಿ ನಾನು ಉದಾಹರಣೆಯಾಗಿ hth.txt ಬಳಸಿಕೊಂಡು ನಾನು, ಮತ್ತು ನಿಮ್ಮ ವಿಶೇಷ ಸುಮಾರು ಮಾತಾಡಿಕೊಂಡರು ಒಂದಾಗಿದೆ.

650
00:55:15,150 --> 00:55:21,040
ಎಂದು ಅಕ್ಷರಶಃ HTH ತದನಂತರ ಹೊಸಸಾಲು ಇಲ್ಲಿದೆ.

651
00:55:21,040 --> 00:55:30,970
ಆದರೆ ಖಂಡಿತವಾಗಿಯೂ ಹಿಂಜರಿಯಬೇಡಿ ಮತ್ತು ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಮುಂದೆ ಉದಾಹರಣೆಗಳು ಬಳಸಲು ಸಲಹೆ ಮಾಡಲಾಗುತ್ತದೆ

652
00:55:30,970 --> 00:55:32,620
ನಿಮ್ಮ ಪಠ್ಯ ಕಡತ.

653
00:55:32,620 --> 00:55:38,110
>> ನೀವು decompressing ನಂತರ ಬಹುಶಃ ಕುಗ್ಗಿಸಿ ಒಂದು ಶಾಟ್ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಮಾಡಬಹುದು

654
00:55:38,110 --> 00:55:41,600
ಯುದ್ಧ ಮತ್ತು ಶಾಂತಿ ನಿಮಗೆ ಸ್ಪೆಲ್ಲರ್ ಬಳಸಲಾಗುವ ಕಡತಗಳನ್ನು ಕೆಲವು

655
00:55:41,600 --> 00:55:46,710
ಅಥವಾ ಜೇನ್ ಆಸ್ಟೆನ್ ಅಥವಾ ಸ್ವಲ್ಪ - ತಂಪಾದ ರೀತಿಯ ಎಂದು - ಅಥವಾ ಆಸ್ಟಿನ್ ಪವರ್ಸ್,

656
00:55:46,710 --> 00:55:51,880
ನಾವು ಅದನ್ನು ದೊಡ್ಡ ಕಡತಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ರೀತಿಯ ಕೆಳಗೆ ಬರುವುದಿಲ್ಲ ಏಕೆಂದರೆ

657
00:55:51,880 --> 00:55:55,590
ನಾವು ಇಲ್ಲಿ ಮುಂದಿನ ಉಪಕರಣವನ್ನು, ls-l ಬಳಸಿದರೆ.

658
00:55:55,590 --> 00:56:01,150
ನಾವು ಮೂಲತಃ ನಮ್ಮ ಪ್ರಸ್ತುತ ಕೋಶದಲ್ಲಿ ಎಲ್ಲಾ ವಿಷಯಗಳ ಪಟ್ಟಿ ಇದು LS, ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

659
00:56:01,150 --> 00:56:07,860
ಧ್ವಜ-L ಸಾಗುವ ವಾಸ್ತವವಾಗಿ ಆ ಕಡತಗಳ ಗಾತ್ರಕ್ಕೆ ತೋರಿಸುತ್ತದೆ.

660
00:56:07,860 --> 00:56:12,690
ನೀವು pset ನಿರ್ದಿಷ್ಟಪಡಿಸುವಿಕೆಯನ್ನು ಮೂಲಕ ಹೋಗಿ, ಅದು ವಾಸ್ತವವಾಗಿ, ಬೈನರಿ ಕಡತವನ್ನು ರಚಿಸುವ ಮೂಲಕ ನಿಮಗೆ ಪರಿಚಯಿಸುತ್ತದೆ

661
00:56:12,690 --> 00:56:16,590
ಅದು huffing, ಮತ್ತು ನೀವು ಸಣ್ಣ ಕಡತಗಳನ್ನು ಎಂದು ನೋಡಿ

662
00:56:16,590 --> 00:56:23,910
ಅದನ್ನು ಕುಗ್ಗಿಸಿ ಮತ್ತು ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲಾ ಭಾಷಾಂತರಿಸುವುದು ಸ್ಪೇಸ್ ವೆಚ್ಚ

663
00:56:23,910 --> 00:56:26,980
ಆ ರೀತಿಯ ಎಲ್ಲಾ ಆವರ್ತನಗಳ ಮತ್ತು ವಸ್ತುಗಳ ನಿಜವಾದ ಲಾಭ ಮೀರಿಸುತ್ತದೆ

664
00:56:26,980 --> 00:56:30,000
ಮೊದಲ ಸ್ಥಳದಲ್ಲಿ ಕಡತ ಕುಗ್ಗಿಸಿ ನ.

665
00:56:30,000 --> 00:56:37,450
ನೀವು ಕೆಲವು ಮುಂದೆ ಪಠ್ಯ ಕಡತಗಳನ್ನು ಅದನ್ನು ರನ್ ಆದರೆ, ನಂತರ ನೀವು ಪ್ರಯೋಜನ ಪಡೆದುಕೊಳ್ಳಲು ಆರಂಭಿಸುವ ವೀಕ್ಷಿಸಬಹುದು

666
00:56:37,450 --> 00:56:40,930
ಆ ಫೈಲ್ಗಳನ್ನು ಕುಗ್ಗಿಸಿ ರಲ್ಲಿ.

667
00:56:40,930 --> 00:56:46,210
>> ತದನಂತರ ಅಂತಿಮವಾಗಿ, ನಾವು ಖಂಡಿತವಾಗಿಯೂ ತುಂಬಾ HANDY ಬರುತ್ತವೆ ಹೋಗುವ ಇದು ನಮ್ಮ ಹಳೆಯ PAL GDB ಹೊಂದಿರುತ್ತವೆ.

668
00:56:48,360 --> 00:56:55,320
>> ನಾವು ಮರಗಳು ಮಾಡುವ ಬಹುಶಃ ಹಫ್ ಮರಗಳು ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾಡಬೇಡಿ

669
00:56:55,320 --> 00:56:58,590
ಅಥವಾ Huff'n ಪಫ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

670
00:57:00,680 --> 00:57:02,570
ಸರಿ. ನಾನು ಸ್ವಲ್ಪ ಕಾಲ ಸುಮಾರು ಇರುವೆ.

671
00:57:02,570 --> 00:57:06,570
>> ಧನ್ಯವಾದಗಳು, ಎಲ್ಲರೂ. ಈ ದರ್ಶನ 6 ಆಗಿತ್ತು. ಮತ್ತು ಅದೃಷ್ಟ ಉತ್ತಮ.

672
00:57:08,660 --> 00:57:10,000
>> [CS50.TV]