1
00:00:00,000 --> 00:00:00,530

2
00:00:00,530 --> 00:00:03,070
>> ಸ್ಪೀಕರ್ 1: ನ ನೀಡಲು ಅವಕಾಶ
ಈ ಪರಿಹಾರ ಪ್ರಯತ್ನಿಸಿ.

3
00:00:03,070 --> 00:00:07,130
ಆದ್ದರಿಂದ ನಮ್ಮ ನೋಡೋಣ ಅವಕಾಶ
Struct ನೋಡ್ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ.

4
00:00:07,130 --> 00:00:11,040
ಇಲ್ಲಿ, ನಾವು ಹೊಂದಿರುವ ನೀನು ನೋಡಿ ಒಂದು
Bool ಪದಗಳ ಮತ್ತು struct ನೋಡ್ ಸ್ಟಾರ್

5
00:00:11,040 --> 00:00:12,990
ಮಕ್ಕಳು ವರ್ಣಮಾಲೆಯ ಆವರಣ.

6
00:00:12,990 --> 00:00:18,720
ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ನೀವು ಚಕಿತಗೊಳಿಸುತ್ತದೆ ಇರಬಹುದು,
ಏಕೆ ವರ್ಣಮಾಲೆಯ ಹ್ಯಾಶ್ 27 ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ?

7
00:00:18,720 --> 00:00:22,540
ಸರಿ, ನಮಗೆ ನೀನು ನೆನಪು
ಅಪಾಸ್ಟ್ರಫಿ ನಿರ್ವಹಣೆ, ಹೀಗಿರುವ

8
00:00:22,540 --> 00:00:25,610
ವಿಶೇಷ ಸ್ವಲ್ಪ ಎಂದು ವಿಶೇಷವೇನು
ಈ ಕಾರ್ಯಕ್ರಮದ ಉದ್ದಕ್ಕೂ ಸಂದರ್ಭದಲ್ಲಿ.

9
00:00:25,610 --> 00:00:28,780
>> ಸರಿ, ಈಗ ನೆನಪು ಹೇಗೆ ಒಂದು
Trie ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

10
00:00:28,780 --> 00:00:33,420
ನಾವು ಪದ ಬೆಕ್ಕುಗಳು ಸೂಚಿ ನೀವು ಹೇಳುವ,
ನಂತರ ನಮ್ಮ trie ಮೂಲದಿಂದ,

11
00:00:33,420 --> 00:00:36,670
ನಾವು ಮಕ್ಕಳು ನೋಡಲು ನೀನು
ರಚನೆಯ, ಮತ್ತು ನಾವು ನೋಡಲು ನೀನು

12
00:00:36,670 --> 00:00:42,250
ಅಕ್ಷರದ ಅನುರೂಪವಾಗಿದೆ ಸೂಚ್ಯಂಕ
ಸಿ ಆದ್ದರಿಂದ ಸೂಚ್ಯಂಕ ಎರಡು ಎಂದು.

13
00:00:42,250 --> 00:00:46,400
ಆದ್ದರಿಂದ, ನಮಗೆ ನೀಡುತ್ತದೆ ನೀಡಿದ
ಒಂದು ಹೊಸ ನೋಡ್, ಮತ್ತು ನಂತರ ನಾವು ಮಾಡುತ್ತೇವೆ

14
00:00:46,400 --> 00:00:47,880
ಆ ನೋಡ್ ಕೆಲಸ.

15
00:00:47,880 --> 00:00:51,830
>> ಆ ನೋಡ್ ನೀಡಿದ, ನಾವು ಮತ್ತೊಮ್ಮೆ ಆರ್
ಮಕ್ಕಳ ರಚನೆಯ ನೋಡಲು ಹೋಗುವ,

16
00:00:51,830 --> 00:00:56,170
ಮತ್ತು ನಾವು ಸೂಚ್ಯಂಕ ಶೂನ್ಯ ನೋಡಲು ನೀನು
ಬೆಕ್ಕು ಒಂದು ಸಂಬಂಧಿಸಿರುತ್ತದೆ.

17
00:00:56,170 --> 00:01:01,240
ಆದ್ದರಿಂದ ನಾವು ಎಂದು ನೋಡ್ ಹೋಗಲು ನೀನು,
ಮತ್ತು ಆ ನೋಡ್ ನೀಡಿದ, ನಾವು ನೀನು

18
00:01:01,240 --> 00:01:05,170
ಅನುರೂಪವಾಗಿದೆ ಸೂಚ್ಯಂಕ ನೋಡಲು
ಟಿ ಮತ್ತು ನೋಡ್ನಲ್ಲಿ ಸ್ಥಳಾಂತರಗೊಳ್ಳುವ, ಗೆ

19
00:01:05,170 --> 00:01:09,590
ಅಂತಿಮವಾಗಿ, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಕಂಡಿದ್ದೇನೆ
ನಮ್ಮ ಪದ ಕ್ಯಾಟ್ ಮೂಲಕ, ಮತ್ತು ಈಗ bool

20
00:01:09,590 --> 00:01:15,020
ಪದಗಳ ಎಂಬುದನ್ನು ಹೇಳಲಾಗುವ
ಈ ಪದ ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ.

21
00:01:15,020 --> 00:01:17,530
>> ಆದ್ದರಿಂದ ನಾವು ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ ಬೇಕು?

22
00:01:17,530 --> 00:01:21,680
ಅಲ್ಲದೆ, ಹೀಗಾದರೆ ಪದ ಮಹಾದುರಂತ
ನಮ್ಮ ನಿಘಂಟು, ಆದರೆ

23
00:01:21,680 --> 00:01:24,120
ಪದ ಬೆಕ್ಕು ಅಲ್ಲ?

24
00:01:24,120 --> 00:01:29,030
ಆದ್ದರಿಂದ ಪದ ಬೆಕ್ಕು ವೇಳೆ ನೋಡಲು ಕಾಣುವ
ನಮ್ಮ ನಿಘಂಟು, ನಾವು ನೀನು

25
00:01:29,030 --> 00:01:34,880
ಯಶಸ್ವಿಯಾಗಿ ಸೂಚ್ಯಂಕಗಳು ಮೂಲಕ ನೋಡಲು
ಸಿ ಎ ಟಿ ಮತ್ತು ಒಂದು ನೋಡ್ ತಲುಪಲು, ಆದರೆ ಆ

26
00:01:34,880 --> 00:01:39,760
ದುರಂತದ ಸಂಭವಿಸಿದ ಮಾತ್ರ ಏಕೆಂದರೆ
ಸಿ ಎ ಟಿ ದಾರಿಯಲ್ಲಿ ಗ್ರಂಥಿಗಳು ರಚಿಸಲು ಎಲ್ಲಾ

27
00:01:39,760 --> 00:01:41,250
ಪದದ ಕೊನೆಯಲ್ಲಿ ದಾರಿ.

28
00:01:41,250 --> 00:01:46,520
ಆದ್ದರಿಂದ bool ಪದಗಳ ಎಂಬುದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
ಈ ನಿರ್ದಿಷ್ಟ ಸ್ಥಳ ವಾಸ್ತವವಾಗಿ

29
00:01:46,520 --> 00:01:48,370
ಒಂದು ಪದ ಸೂಚಿಸುತ್ತದೆ.

30
00:01:48,370 --> 00:01:52,920
>> ಸರಿ, ಈಗ ನಾವು ತಿಳಿದಿರುವ ಏನು ಒಂದು
Trie ನೋಡೋಣ, ರೀತಿ ಹೋಗುತ್ತದೆ

31
00:01:52,920 --> 00:01:54,800
ಲೋಡ್ ಕಾರ್ಯ.

32
00:01:54,800 --> 00:01:58,670
ಆದ್ದರಿಂದ ಲೋಡ್ ಒಂದು bool ಮರಳಲು ಹೋಗುತ್ತದೆ
ಎಂಬುದನ್ನು ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅಥವಾ

33
00:01:58,670 --> 00:02:03,020
ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ಲೋಡ್ ನಿಘಂಟು ಮತ್ತು
ಈ ನಿಘಂಟು ಏರಲಿದೆ

34
00:02:03,020 --> 00:02:04,520
ನಾವು ಲೋಡ್ ಬಯಸುವ.

35
00:02:04,520 --> 00:02:08,310
ನಾವು ಮಾಡಲು ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ಮುಕ್ತ
ಓದುವ ಎಂದು ನಿಘಂಟು ಅಪ್.

36
00:02:08,310 --> 00:02:12,060
ನಾವು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು,
ಆದ್ದರಿಂದ ನಿಘಂಟು ಅಲ್ಲ

37
00:02:12,060 --> 00:02:15,280
ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು, ಇದು ಹಿಂತಿರುಗುವುದು
ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೀನು

38
00:02:15,280 --> 00:02:16,340
ತಪ್ಪು ಹಿಂತಿರುಗಿ.

39
00:02:16,340 --> 00:02:21,290
ಆದರೆ ಭಾವಿಸಿದರೂ ಇದು ಯಶಸ್ವಿಯಾಗಿ
ತೆರೆಯಿತು, ನಾವು ವಾಸ್ತವವಾಗಿ ಓದಬಹುದು

40
00:02:21,290 --> 00:02:22,310
ನಿಘಂಟು ಮೂಲಕ.

41
00:02:22,310 --> 00:02:24,940
>> ನಾವು ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ಮಾಡಲು ಬಯಸುವ ನಾವು ಈ ಹೊಂದಿವೆ ಇದೆ

42
00:02:24,940 --> 00:02:26,560
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮೂಲ.

43
00:02:26,560 --> 00:02:30,250
ಈಗ, ಮೂಲ ನೋಡ್ ಸ್ಟಾರ್ ಏರಲಿದೆ.

44
00:02:30,250 --> 00:02:33,830
ಇದು ನಾವು ನೀವು ನಮ್ಮ trie ಅಗ್ರ ಇಲ್ಲಿದೆ
ಮೂಲಕ iterating ಮಾಡಲು ಹೋಗುತ್ತಿದ್ದೇನೆ.

45
00:02:33,830 --> 00:02:38,200
ನಾವು ಬಯಸುವ ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ಹಾಗೆ ನಮ್ಮ ಮೂಲ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಆಗಿದೆ.

46
00:02:38,200 --> 00:02:42,040
>> ನಾವು calloc ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ
ಮೂಲತಃ ಅದೇ ಕಾರ್ಯ,

47
00:02:42,040 --> 00:02:45,560
Malloc ಕಾರ್ಯ ಹೊರತುಪಡಿಸಿ ಇದು
ಎಂದು ಏನೋ ಮರಳಲು ಭರವಸೆ

48
00:02:45,560 --> 00:02:47,240
ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ zeroed.

49
00:02:47,240 --> 00:02:51,350
ನಾವು malloc ಬಳಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾವು ಅಗತ್ಯವಿದೆ
ರಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿ ನಮ್ಮ

50
00:02:51,350 --> 00:02:54,220
ನೋಡ್ ಮತ್ತು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
ಅವರು ಎಲ್ಲಾ ಶೂನ್ಯ ಆರ್.

51
00:02:54,220 --> 00:02:56,780
ಆದ್ದರಿಂದ calloc ನಮಗೆ ಹಾಗೆ ಕಾಣಿಸುತ್ತದೆ.

52
00:02:56,780 --> 00:03:00,390
>> ಈಗ, ಕೇವಲ malloc ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ
ಹಂಚಿಕೆ ವಾಸ್ತವವಾಗಿ ಎಂದು ಖಚಿತವಾಗಿ

53
00:03:00,390 --> 00:03:01,580
ಯಶಸ್ವಿ.

54
00:03:01,580 --> 00:03:04,060
ಈ ಶೂನ್ಯ ಹಿಂದಿರುಗಿದರು ವೇಳೆ, ನಾವು
ನಮ್ಮ ನಿಘಂಟು ಮುಚ್ಚಲು ಅಗತ್ಯ

55
00:03:04,060 --> 00:03:06,170
ಫೈಲ್ ಮತ್ತು ತಪ್ಪು ಹಿಂತಿರುಗಿ.

56
00:03:06,170 --> 00:03:11,040
ಆದ್ದರಿಂದ ಹಂಚಿಕೆ ಹೋಗಿದ್ದರೆ
ಯಶಸ್ವಿ, ನಾವು ಒಂದು ನೋಡ್ ಬಳಸಲು ನೀನು

57
00:03:11,040 --> 00:03:14,340
ತಿರುಗಿ ಕರ್ಸರ್ ನಟಿಸಲು
ನಮ್ಮ trie ಮೂಲಕ.

58
00:03:14,340 --> 00:03:17,950
ಆದ್ದರಿಂದ ನಮ್ಮ ಮೂಲ ಬದಲಿಸಲು ಹೋಗಿ ಎಂದಿಗೂ,
ಆದರೆ ನಾವು ಕರ್ಸರ್ ಬಳಸಲು ನೀನು

59
00:03:17,950 --> 00:03:20,770
ವಾಸ್ತವವಾಗಿ ನೋಡ್ನಿಂದ ನೋಡ್ಗೆ ಹೋಗಿ.

60
00:03:20,770 --> 00:03:25,000
>> ಸರಿ, ಆದ್ದರಿಂದ ಈ ಲೂಪ್, ನಾವು
, ಡಿಕ್ಷನರಿ ಕಡತ ಮೂಲಕ ಓದುವ

61
00:03:25,000 --> 00:03:26,965
ಮತ್ತು ನಾವು fgetc ನಲ್ಲಿ ಬಳಸುತ್ತಿರುವ.

62
00:03:26,965 --> 00:03:30,360
ಆದ್ದರಿಂದ fgetc ಒಂದೇ ದೋಚಿದ ಹೋಗುತ್ತದೆ
ಕಡತದಿಂದ ಪಾತ್ರ.

63
00:03:30,360 --> 00:03:33,430
ನಾವು ಧರಿಸುವುದನ್ನು ಮುಂದುವರಿಯಲು ನೀನು
ಪಾತ್ರಗಳು ನಾವು ತಲುಪಲು ಇಲ್ಲ

64
00:03:33,430 --> 00:03:37,540
ಕಡತದ ಕೊನೆಯಲ್ಲಿ, ಆದ್ದರಿಂದ ಇವೆ
ನಾವು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ ಎರಡು ಸಂದರ್ಭಗಳಲ್ಲಿ.

65
00:03:37,540 --> 00:03:41,640
ಮೊದಲ, ಪಾತ್ರದ ಮಾಡಿದರೆ
ಇದು ಹೊಸ ವೇಳೆ ಹೊಸ ಲೈನ್, ನಾವು ತಿಳಿಯಲು

66
00:03:41,640 --> 00:03:44,480
ಲೈನ್, ನಂತರ ನಾವು ನೀವು
ಒಂದು ಹೊಸ ಪದ ತೆರಳಿ.

67
00:03:44,480 --> 00:03:49,300
ಆದರೆ, ಇದು ಹೊಸ ಲೈನ್ ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಇಲ್ಲಿ, ನಾವು ಲೆಕ್ಕಾಚಾರ ಬಯಸುವ

68
00:03:49,300 --> 00:03:52,440
ಸೂಚ್ಯಂಕ ನಾವು ಒಳಗೆ ಸೂಚ್ಯಂಕ ನೀನು
ಮಕ್ಕಳ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಂದು

69
00:03:52,440 --> 00:03:53,890
ನಾವು ಮೊದಲು ನೋಡಿವೆ.

70
00:03:53,890 --> 00:03:57,950
>> ನಾನು ಮೊದಲು ಹೇಳಿದರು ಆದ್ದರಿಂದ ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ
ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ ಅಪಾಸ್ಟ್ರಫಿ.

71
00:03:57,950 --> 00:04:01,040
ನಾವು ತ್ರಯಾತ್ಮಕ ಆಯೋಜಕರು ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ
ಇಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾವು ಓದಲು ನೀನು

72
00:04:01,040 --> 00:04:05,500
ಈ ನಾವು ಓದಲು ಪಾತ್ರ ವೇಳೆ
ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ನೀನು

73
00:04:05,500 --> 00:04:11,740
ವರ್ಣಮಾಲೆಯ ಮೈನಸ್ ಸಮಾನವಾಗಿರುತ್ತದೆ ಸೂಚ್ಯಂಕ ಸೆಟ್
1, ಸೂಚ್ಯಂಕ 26 ಇರುತ್ತದೆ.

74
00:04:11,740 --> 00:04:15,190
ಎಲ್ಸ್ ಇದು ಅಪಾಸ್ಟ್ರಫಿ ಅಲ್ಲ ವೇಳೆ,
ನಾವು ಇಂಡೆಕ್ಸ್ ಹೊರಟಿರುವೆ

75
00:04:15,190 --> 00:04:17,820
ಸಿ ಮೈನಸ್ ಒಂದು ಸಮಾನವಾಗಿರುತ್ತದೆ.

76
00:04:17,820 --> 00:04:23,090
ಆದ್ದರಿಂದ ಹಿಂದಿನ ಪು ಸೆಟ್ ನೆನಪಿಡಿ,
ಸಿ ಮೈನಸ್ ಒಂದು ನಮಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ

77
00:04:23,090 --> 00:04:27,470
ವರ್ಣಮಾಲೆಯ ಸಿ ಸ್ಥಾನವನ್ನು, ವೇಳೆ
ಸಿ ಅಕ್ಷರದ ಎ, ಈ ವಿಲ್

78
00:04:27,470 --> 00:04:28,770
ನಮಗೆ ಸೂಚ್ಯಂಕ ಶೂನ್ಯ ನೀಡಿ.

79
00:04:28,770 --> 00:04:32,180
ಅಕ್ಷರದ ಬಿ, ಇದು ನೀಡುತ್ತದೆ
ಹೀಗೆ ನಮಗೆ ಸೂಚ್ಯಂಕ 1, ಮತ್ತು.

80
00:04:32,180 --> 00:04:37,070
>> ಆದ್ದರಿಂದ ಈ ನಮಗೆ ಒಳಗೆ ಸೂಚ್ಯಂಕ ನೀಡುತ್ತದೆ
ನಾವು ಬಯಸುವ ಮಕ್ಕಳಿಗೆ ರಚನೆಯ.

81
00:04:37,070 --> 00:04:42,540
ಈಗ, ಈ ಸೂಚ್ಯಂಕ ಪ್ರಸ್ತುತ ಶೂನ್ಯ ವೇಳೆ
ಮಕ್ಕಳ ರಚನೆಯ ಅರ್ಥ

82
00:04:42,540 --> 00:04:47,470
ಒಂದು ನೋಡ್ ಪ್ರಸ್ತುತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ
ಮಾರ್ಗ, ಆದ್ದರಿಂದ ನಾವು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ ಒಂದು

83
00:04:47,470 --> 00:04:49,220
ಎಂದು ಪಾಥ್ ನೋಡ್.

84
00:04:49,220 --> 00:04:50,610
ನಾವು ಇಲ್ಲಿ ಏನು ಇಲ್ಲಿದೆ.

85
00:04:50,610 --> 00:04:54,650
ನಾವು, ಮತ್ತೆ, calloc ಬಳಸಲು ನೀನು
ಕಾರ್ಯ ನಾವು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ

86
00:04:54,650 --> 00:05:00,130
ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಔಟ್ ಸೊನ್ನೆಗೆ, ಮತ್ತು ನಾವು,
ಮತ್ತೆ ಆ calloc ಪರಿಶೀಲಿಸಬೇಕು

87
00:05:00,130 --> 00:05:01,300
ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

88
00:05:01,300 --> 00:05:04,760
Calloc ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ವೇಳೆ, ನಂತರ ನಾವು ಅಗತ್ಯವಿದೆ
ಎಲ್ಲವೂ ಅನ್ಲೋಡ್, ಮುಚ್ಚಿ ನಮ್ಮ

89
00:05:04,760 --> 00:05:06,880
ನಿಘಂಟು, ಮತ್ತು ತಪ್ಪು ಹಿಂತಿರುಗಿ.

90
00:05:06,880 --> 00:05:14,110
>> ಆದ್ದರಿಂದ ನಂತರ, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಈ ನಮಗೆ ಹೊಸ ಮಗುವಿನ ರಚಿಸುತ್ತದೆ

91
00:05:14,110 --> 00:05:16,000
ನಂತರ ನಾವು ಆ ಮಗುವಿನ ಹೋಗುತ್ತದೆ.

92
00:05:16,000 --> 00:05:19,030
ನಮ್ಮ ಕರ್ಸರ್ ಮರಳಿ ಕಾಣಿಸುತ್ತದೆ
ಮಗು ಕೆಳಗೆ.

93
00:05:19,030 --> 00:05:23,390
ಈಗ, ಈ ಆರಂಭಿಸಲು ಶೂನ್ಯ ಅಲ್ಲ ವೇಳೆ,
ನಂತರ ಕರ್ಸರ್ ಕೇವಲ ಮರಳಿ ಮಾಡಬಹುದು

94
00:05:23,390 --> 00:05:26,650
ವಾಸ್ತವವಾಗಿ ಇಲ್ಲದೆ ಆ ಮಗು ಕೆಳಗೆ
ಏನು ನಿಗದಿಪಡಿಸಬೇಕಾಗುತ್ತದೆ ಹೊಂದಿರುವ.

95
00:05:26,650 --> 00:05:30,790
ಈ ನಾವು ಮೊದಲ ಸಂಭವಿಸಿದ ಪ್ರಕರಣದಲ್ಲಿ
ಪದ ಬೆಕ್ಕು ನಿಯೋಜಿಸಿ, ಮತ್ತು

96
00:05:30,790 --> 00:05:34,390
ನಾವು ನಿಯೋಜಿಸಿ ಹೋದಾಗ ಅರ್ಥ
ದುರಂತದ, ನಾವು ರಚಿಸಲು ಅಗತ್ಯವಿಲ್ಲ

97
00:05:34,390 --> 00:05:35,720
ಮತ್ತೆ ಸಿ ಎ ಟಿ ಗ್ರಂಥಿಗಳು.

98
00:05:35,720 --> 00:05:37,620
ಅವರು ಈಗಾಗಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

99
00:05:37,620 --> 00:05:40,140
>> ಸರಿ, ಆದ್ದರಿಂದ ಈ ಎಲ್ಸ್ ಎಂದರೇನು?

100
00:05:40,140 --> 00:05:44,600
ಈ ಸಿ ಆಗಿತ್ತು ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ
ಸಿ ಹೊಸ ಲೈನ್ ಅಲ್ಲಿ backslash N,.

101
00:05:44,600 --> 00:05:47,780
ಈ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅರ್ಥ
ಒಂದು ಪದ ಪೂರ್ಣಗೊಂಡಿತು.

102
00:05:47,780 --> 00:05:51,020
ಈಗ, ನಾವು ಏನು ಬಯಸುತ್ತೀರಿ ನಾವು
ಯಶಸ್ವಿಯಾಗಿ ಪದ ಪೂರ್ಣಗೊಂಡಿತು?

103
00:05:51,020 --> 00:05:55,250
ನಾವು ಈ ಪದ ಕ್ಷೇತ್ರ ಬಳಸಲು ನೀನು
ನಮ್ಮ struct ನೋಡ್ ಒಳಗೆ.

104
00:05:55,250 --> 00:06:00,570
>> ನಾವು ನಿಜವಾದ ಎಂದು ಹೊಂದಿಸಲು ಬಯಸುವ, ಆದ್ದರಿಂದ
ಈ ನೋಡ್ ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಒಂದು

105
00:06:00,570 --> 00:06:03,320
ಯಶಸ್ವಿ ಪದ ನಿಜವಾದ ಪದ.

106
00:06:03,320 --> 00:06:05,050
ಈಗ, ಟ್ರೂ ಸೆಟ್.

107
00:06:05,050 --> 00:06:09,210
ನಾವು ಬಿಂದುವಿಗೆ ನಮ್ಮ ಕರ್ಸರ್ ಮರುಹೊಂದಿಸಲು
ಮತ್ತೆ trie ಆರಂಭದಲ್ಲಿ ಗೆ.

108
00:06:09,210 --> 00:06:13,510
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ನಿಘಂಟು ಹೆಚ್ಚಿಸಲು
ನಾವು ಮತ್ತೊಂದು ಪದ ಕಂಡು ಗಾತ್ರ ರಿಂದ.

109
00:06:13,510 --> 00:06:16,450
>> ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ನಡೆಸುವ ನೀನು
ಎಂದು, ಅದಕ್ಕೆ ಅಕ್ಷರ ಓದುವ

110
00:06:16,450 --> 00:06:21,960
ಮೀ, ಹೊಸ ಗ್ರಂಥಿಗಳು ನಿರ್ಮಿಸುವ
ನಮ್ಮ trie ಮತ್ತು ಪ್ರತಿ ಪದಕ್ಕೆ

111
00:06:21,960 --> 00:06:26,810
ನಿಘಂಟು, ನಾವು ಅಂತಿಮವಾಗಿ ಸಿ ತಲುಪುವವರೆಗೆ
, ನಾವು ಮುರಿಯುವ ಸಂದರ್ಭದಲ್ಲಿ EOF, ಸಮನಾಗಿರುತ್ತದೆ

112
00:06:26,810 --> 00:06:28,100
ಫೈಲ್ ಔಟ್.

113
00:06:28,100 --> 00:06:31,110
ಈಗ, ಎರಡು ಸಂದರ್ಭಗಳಲ್ಲಿ ಅಡಿಯಲ್ಲಿ ಇವೆ
ನಾವು EOF ಹಿಟ್ ಇರಬಹುದು ಇದು.

114
00:06:31,110 --> 00:06:35,680
ದೋಷ ಇಲ್ಲದಿದ್ದರೆ ಮೊದಲ
ಇಲ್ಲದಿದ್ದರೆ ಕಡತ ಓದುವ, ಆದ್ದರಿಂದ

115
00:06:35,680 --> 00:06:39,280
ದೋಷ, ನಾವು ವಿಶಿಷ್ಟ ಮಾಡಬೇಕಾದ್ದು
, ಎಲ್ಲವೂ ಅನ್ಲೋಡ್ ಕಡತ ಮುಚ್ಚಿ,

116
00:06:39,280 --> 00:06:40,520
ತಪ್ಪು ಹಿಂತಿರುಗಿ.

117
00:06:40,520 --> 00:06:43,870
, ದೋಷ ಇರಲಿಲ್ಲ ಭಾವಿಸಿದರೂ
ಕೇವಲ ನಾವು ವಾಸ್ತವವಾಗಿ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಅರ್ಥ

118
00:06:43,870 --> 00:06:47,820
ಕಡತ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮುಚ್ಚಲು
ಫೈಲ್ ನಿಜವಾದ ಲಾಭ ರಿಂದ ನಾವು

119
00:06:47,820 --> 00:06:51,010
ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ಲೋಡ್
ನಮ್ಮ trie ಒಳಗೆ.

120
00:06:51,010 --> 00:06:54,240
>> ಸರಿ, ಈಗ ಅವಕಾಶ ತಂದೆಯ
ಚೆಕ್ ಪರಿಶೀಲಿಸಿ.

121
00:06:54,240 --> 00:06:58,780
ಚೆಕ್ ಕಾರ್ಯ ನೋಡುತ್ತಿರುವುದು, ನಾವು ನೋಡಿ
ಚೆಕ್ ಒಂದು bool ಮರಳಲು ಹೋಗುತ್ತದೆ.

122
00:06:58,780 --> 00:07:03,740
ಈ ಪದವು ಎಂದು ವೇಳೆ ಇದು ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ಅಂಗೀಕಾರವಾದ ನಮ್ಮ trie ಹೊಂದಿದೆ.

123
00:07:03,740 --> 00:07:06,170
ಇದು ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

124
00:07:06,170 --> 00:07:10,110
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ನಿರ್ಧರಿಸಲು ಹೋಗುವ
ಈ ಪದ ನಮ್ಮ trie ಹೊಂದಿದೆ?

125
00:07:10,110 --> 00:07:14,270
ನಾವು ಇಲ್ಲಿ ನೋಡಿ, ಮೊದಲಿನಂತೆ,
ನಾವು ಮರಳಿ ಕರ್ಸರ್ ಬಳಸಲು ನೀನು

126
00:07:14,270 --> 00:07:16,010
ನಮ್ಮ trie ಮೂಲಕ.

127
00:07:16,010 --> 00:07:20,650
ಈಗ, ಇಲ್ಲಿ, ನಾವು ತಿರುಗಿ ನೀನು
ನಮ್ಮ ಇಡೀ ಪದದ ಮೇಲೆ.

128
00:07:20,650 --> 00:07:24,680
ಆದ್ದರಿಂದ ನಾವು ಪದ ಮೇಲೆ iterating
ಜಾರಿಗೆ, ನಾವು ನಿರ್ಧರಿಸಲು ನೀನು

129
00:07:24,680 --> 00:07:29,280
ಸೂಚ್ಯಂಕ ಮಕ್ಕಳ ರಚನೆಯ ಒಳಗೆ ಎಂದು
ಪದ ಬ್ರಾಕೆಟ್ ನಾನು ಅನುರೂಪವಾಗಿದೆ.

130
00:07:29,280 --> 00:07:34,150
ಆದ್ದರಿಂದ ಈ ನಿಖರವಾಗಿ ರೀತಿ ಹೋಗುತ್ತದೆ
ಲೋಡ್, ಅಲ್ಲಿ ಪದ ಬ್ರಾಕೆಟ್ ನಾನು ವೇಳೆ

131
00:07:34,150 --> 00:07:38,110
ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ಇಂಡೆಕ್ಸ್ ಬಳಸಲು ಬಯಸುವ
1 ಮೈನಸ್ ವರ್ಣಮಾಲೆಯ ನಾವು ನಿರ್ಧರಿಸುತ್ತದೆ ಏಕೆಂದರೆ

132
00:07:38,110 --> 00:07:41,160
ನಾವು ನೀನು ಅಲ್ಲಿ ಎಂದು
ಅಪಾಸ್ಟ್ರಫಿಗಳನ್ನು ಶೇಖರಿಸಿಡಲು.

133
00:07:41,160 --> 00:07:44,440
>> ಎಲ್ಸ್ ನಾವು tolower ಬಳಸಲು ನೀನು
ಪದ ಬ್ರಾಕೆಟ್ ನಾನು.

134
00:07:44,440 --> 00:07:48,270
ಆದ್ದರಿಂದ ಹೊಂದಬಹುದಾದ ಪದ ನೆನಪು ಅನಿಯಂತ್ರಿತ
ಬಂಡವಾಳ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು

135
00:07:48,270 --> 00:07:51,590
ನಾವು ಬಳಸುತ್ತಿರುವ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ
ವಸ್ತುಗಳ ಸಣ್ಣ ಆವೃತ್ತಿ.

136
00:07:51,590 --> 00:07:55,300
ತದನಂತರ ಆ ಸಣ್ಣ ಕಳೆ
ಒಂದು, ಮತ್ತೊಮ್ಮೆ, ನಮಗೆ ನೀಡಲು

137
00:07:55,300 --> 00:07:57,940
ವರ್ಣಮಾಲೆಯ ಸ್ಥಾನವನ್ನು
ಆ ಪಾತ್ರದ.

138
00:07:57,940 --> 00:08:01,740
ಆದ್ದರಿಂದ ನಮ್ಮ ಸೂಚ್ಯಂಕ ಎಂದು ವಿಶೇಷವೇನು
ಮಕ್ಕಳ ರಚನೆಯ ಒಳಗೆ.

139
00:08:01,740 --> 00:08:06,480
>> ಈಗ, ವೇಳೆ ಮಕ್ಕಳಾದರು ಸೂಚ್ಯಂಕ
ರಚನೆಯ ಶೂನ್ಯ, ಎಂದು ನಾವು ಅರ್ಥ

140
00:08:06,480 --> 00:08:09,050
ಇನ್ನು ಮುಂದೆ iterating ಮುಂದುವರಿಸಬಹುದು
ನಮ್ಮ trie ಕೆಳಗೆ.

141
00:08:09,050 --> 00:08:13,320
ಆ ಕೇಸ್, ಈ ಪದ ಸಾಧ್ಯವಿಲ್ಲ
ಬಹುಶಃ ನಮ್ಮ trie ಎಂದು ಏಕೆಂದರೆ ಇದು

142
00:08:13,320 --> 00:08:18,000
, ಒಂದು ಇಲ್ಲ ಎಂದು ಅರ್ಥ ಮಾಡಲಾಯಿತು
ದಾರಿಯನ್ನು ಆ ಪದ, ಮತ್ತು ನೀವು

143
00:08:18,000 --> 00:08:19,350
ಶೂನ್ಯ ಎದುರಿಸಬಹುದು ಎಂದಿಗೂ.

144
00:08:19,350 --> 00:08:21,910
ಆದ್ದರಿಂದ ಶೂನ್ಯ ಎದುರಿಸುತ್ತಿದೆ, ನಾವು ತಪ್ಪು ಮರಳಲು.

145
00:08:21,910 --> 00:08:23,810
ಪದ ನಿಘಂಟಿನಲ್ಲಿ ಇಲ್ಲ.

146
00:08:23,810 --> 00:08:28,200
ಇದು ಶೂನ್ಯ ವೇಳೆ, ನಂತರ ನಾವು ನೀನು
iterating ಮುಂದುವರಿಸಲು, ನಾವು ನೀನು

147
00:08:28,200 --> 00:08:33,150
ಎಂದು ತೋರಿಸಲು ನಮ್ಮ ಕರ್ಸರ್ ನವೀಕರಿಸಲು
ಎಂದು ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ನೋಡ್.

148
00:08:33,150 --> 00:08:36,659
>> ನಾವು ಉದ್ದಕ್ಕೂ ಮಾಡುವ ಇರಿಸಿಕೊಳ್ಳಲು
ಇಡೀ ಪದ.

149
00:08:36,659 --> 00:08:40,630
, ನಾವು ಶೂನ್ಯ ಹಿಟ್ ಎಂದಿಗೂ ಭಾವಿಸಿಕೊಂಡು ಅಂದರೆ
ನಾವು ಇಡೀ ಮೂಲಕ ಪಡೆಯಲು ಸಮರ್ಥರಾದರು

150
00:08:40,630 --> 00:08:44,840
ವಿಶ್ವದ ಮತ್ತು ನಮ್ಮ trie ಒಂದು ನೋಡ್ ಹೇಗೆ,
ಆದರೆ ನಾವು ಸಾಕಷ್ಟು ಇನ್ನೂ ಮಾಡಲಾಗುತ್ತದೆ ಇಲ್ಲ.

151
00:08:44,840 --> 00:08:46,350
ನಾವು ನಿಜವಾದ ಹಿಂತಿರುಗಿ ಬಯಸುವುದಿಲ್ಲ.

152
00:08:46,350 --> 00:08:51,400
ನಾವು ಕರ್ಸರ್ ದೋಷ ಪದ ಮರಳಲು ಬಯಸುವ
ಬೆಕ್ಕು ವೇಳೆ ರಿಂದ, ಮತ್ತೆ ನೆನಪು

153
00:08:51,400 --> 00:08:55,140
ನಮ್ಮ ನಿಘಂಟು ಮತ್ತು ದುರಂತವಾಗಿದೆ ರಲ್ಲಿ
ನಂತರ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಮೂಲಕ ಸಿಗುತ್ತದೆ

154
00:08:55,140 --> 00:08:59,810
ಪದ ಬೆಕ್ಕು, ಆದರೆ ಕರ್ಸರ್ ಪದ
ತಪ್ಪು ಮತ್ತು ನಿಜವಾದ ಮಾಡಲಾಗುವುದಿಲ್ಲ.

155
00:08:59,810 --> 00:09:04,990
ನಾವು ಸೂಚಿಸಲು ಕರ್ಸರ್ ಪದ ಮರಳಲು
ಎಂಬುದನ್ನು ಈ ನೋಡ್ ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ,

156
00:09:04,990 --> 00:09:06,530
ಮತ್ತು ಚೆಕ್ ಅದು.

157
00:09:06,530 --> 00:09:08,310
>> ಆದ್ದರಿಂದ ಗಾತ್ರ ಪರಿಶೀಲಿಸಿ ಅವಕಾಶ.

158
00:09:08,310 --> 00:09:11,410
ಆದ್ದರಿಂದ ಗಾತ್ರ ಬಹಳ ಸುಲಭ ಎಂದು ಹೋಗುತ್ತದೆ
ರಿಂದ ಲೋಡ್ ರಲ್ಲಿ ನೆನಪಿಡಿ, ನಾವು ಕೋರುತ್ತೇವೆ

159
00:09:11,410 --> 00:09:15,480
ಫಾರ್ ನಿಘಂಟು ಏರಿಕೆಯ ಗಾತ್ರ
ನಾವು ಎದುರಿಸುವ ಪ್ರತಿ ಪದ.

160
00:09:15,480 --> 00:09:20,820
ಆದ್ದರಿಂದ ಗಾತ್ರ ಕೇವಲ ಮರಳಲು ಹೋಗುತ್ತದೆ
ನಿಘಂಟು ಗಾತ್ರ, ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ.

161
00:09:20,820 --> 00:09:24,650
>> ಸರಿ, ಕೊನೆಯದಾಗಿ, ನಾವು ಅನ್ಲೋಡ್ ಹೊಂದಿವೆ.

162
00:09:24,650 --> 00:09:29,050
ಆದ್ದರಿಂದ ಅನ್ಲೋಡ್, ನಾವು ಬಳಸಲು ನೀನು ಒಂದು
ವಾಸ್ತವವಾಗಿ ಎಲ್ಲಾ ಮಾಡಲು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ

163
00:09:29,050 --> 00:09:33,390
ನಮಗೆ, ಆದ್ದರಿಂದ ನಮ್ಮ ಕಾರ್ಯ ಕೆಲಸ
ಖಾಲಿಮಾಡುವಿಕೆಯು ಎಂಬ ಏರಲಿದೆ.

164
00:09:33,390 --> 00:09:35,830
ಏನು ಖಾಲಿಮಾಡುವಿಕೆಯು ಮಾಡಲು ಹೋಗುತ್ತದೆ?

165
00:09:35,830 --> 00:09:40,640
ನಾವು ಖಾಲಿಮಾಡುವಿಕೆಯು ಹೋಗುತ್ತದೆ ಇಲ್ಲಿ ನೋಡಿ
ಮಕ್ಕಳ ಎಲ್ಲಾ ಮೇಲೆ ತಿರುಗಿ

166
00:09:40,640 --> 00:09:45,810
ಈ ನಿರ್ದಿಷ್ಟ ನೋಡ್, ಮತ್ತು ವೇಳೆ ಮಗು
ನೋಡ್ ಶೂನ್ಯ ಅಲ್ಲ, ನಾವು ನೀನು

167
00:09:45,810 --> 00:09:47,760
ಮಗುವಿನ ನೋಡ್ ಇಳಿಸುವುದನ್ನು.

168
00:09:47,760 --> 00:09:52,070
>> ಆದ್ದರಿಂದ ಈ ಪುನರಾವರ್ತಿತವಾಗಿ ಹೋಗುತ್ತದೆ
ನಮ್ಮ ಮಕ್ಕಳ ಎಲ್ಲಾ ಇಳಿಸುವುದನ್ನು.

169
00:09:52,070 --> 00:09:55,140
ನಾವು ಖಚಿತವಾಗಿ ನೀವು ಒಮ್ಮೆ ನಮ್ಮ ಮಕ್ಕಳು ಎಲ್ಲಾ
ಕೆಳಗಿಳಿಸಲಾಯಿತು ಮಾಡಲಾಗಿದೆ, ನಾವು

170
00:09:55,140 --> 00:09:58,830
ನಾವೇ ಮುಕ್ತಗೊಳಿಸಲು, ಆದ್ದರಿಂದ ourself ಇಳಿಸುವುದನ್ನು ಮಾಡಬಹುದು.

171
00:09:58,830 --> 00:10:04,550
ಆದ್ದರಿಂದ ಈ ಪುನರಾವರ್ತಿತವಾಗಿ ಇಳಿಸುವುದನ್ನು ಕಾಣಿಸುತ್ತದೆ
ಇಡೀ trie, ಮತ್ತು ನಂತರ ಒಮ್ಮೆ

172
00:10:04,550 --> 00:10:06,910
ಮಾಡಲಾಗುತ್ತದೆ, ನಾವು ನಿಜವಾದ ಮರಳಬಹುದು.

173
00:10:06,910 --> 00:10:09,770
ಅನ್ಲೋಡ್ ನಾವು, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಸಾಧ್ಯವಿಲ್ಲ
ಕೇವಲ ವಿಷಯಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ.

174
00:10:09,770 --> 00:10:12,985
ಹಾಗೆ ಒಮ್ಮೆ ನಾವು ಮುಕ್ತಗೊಳಿಸಿದ ಮುಗಿಸಿದ್ದೀರಿ
ಎಲ್ಲವೂ, ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

175
00:10:12,985 --> 00:10:14,380
ಮತ್ತು ಅಷ್ಟೇ.

176
00:10:14,380 --> 00:10:16,792
ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್, ಮತ್ತು ಈ
[ಕೇಳಿಸುವುದಿಲ್ಲ] ಆಗಿತ್ತು.

177
00:10:16,792 --> 00:10:21,888