1
00:00:00,000 --> 00:00:12,350
>> [ಸಂಗೀತ]

2
00:00:12,350 --> 00:00:13,050
>> ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್.

3
00:00:13,050 --> 00:00:13,640
ನಾನು ರಾಬ್ ಮನುಷ್ಯ.

4
00:00:13,640 --> 00:00:16,210
ಮತ್ತು ಇದನ್ನು ಪರಿಹಾರ ಹೊರಬಂದರು.

5
00:00:16,210 --> 00:00:20,070
ಇಲ್ಲಿ ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು
ಸಾಮಾನ್ಯ ಟೇಬಲ್.

6
00:00:20,070 --> 00:00:24,090
ನಾವು ನೋಡಿ ಎಂದು ನಮ್ಮ Struct ನೋಡ್ನ
ಟೇಬಲ್ ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.

7
00:00:24,090 --> 00:00:28,710
ಆದ್ದರಿಂದ ಒಂದು ಚಾರ್ ಪದ ಹೋಗುವುದಿಲ್ಲ
ಗಾತ್ರ ಉದ್ದ + 1 ರಚನೆಯ.

8
00:00:28,710 --> 00:00:32,259
+ 1 ಮರೆಯಬೇಡಿ ರಿಂದ ಗರಿಷ್ಠ
ನಿಘಂಟು ಪದ 45

9
00:00:32,259 --> 00:00:33,130
ಪಾತ್ರಗಳು.

10
00:00:33,130 --> 00:00:37,070
ನಂತರ ನಾವು ಒಂದು ಹೆಚ್ಚುವರಿ ಅಗತ್ಯವಿದೆ ನೀನು
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಶೂನ್ಯ ಪಾತ್ರದ.

11
00:00:37,070 --> 00:00:40,870
>> ತದನಂತರ ಪ್ರತಿ ನಮ್ಮ hashtable
ಬಕೆಟ್ ಶೇಖರಿಸಿಡಲು ಹೋಗುತ್ತದೆ ಒಂದು

12
00:00:40,870 --> 00:00:42,320
ನೋಡ್ಗಳ ಲಿಂಕ್ ಪಟ್ಟಿ.

13
00:00:42,320 --> 00:00:44,420
ನಾವು ಇಲ್ಲಿ ತನಿಖೆಯನ್ನು ರೇಖೀಯ ಮಾಡುತ್ತಿಲ್ಲವಾದರೂ.

14
00:00:44,420 --> 00:00:48,430
ಆದ್ದರಿಂದ ಸಲುವಾಗಿ ಮುಂದಿನ ಲಿಂಕ್
ಬಕೆಟ್ ಅಂಶ, ನಾವು ಒಂದು ಅಗತ್ಯವಿದೆ

15
00:00:48,430 --> 00:00:50,390
struct ನೋಡ್ * ಮುಂದಿನ.

16
00:00:50,390 --> 00:00:51,110
ಸರಿ.

17
00:00:51,110 --> 00:00:53,090
ಆದ್ದರಿಂದ ಒಂದು ನೋಡ್ ಕಾಣುತ್ತದೆ.

18
00:00:53,090 --> 00:00:56,180
>> ಈಗ ಇಲ್ಲಿ ಘೋಷಣೆಯಾಗಿದೆ
ನಮ್ಮ hashtable ಆಫ್.

19
00:00:56,180 --> 00:00:59,640
ಇದು 16.834 ಬಕೆಟ್ ವಿಶೇಷವೇನು.

20
00:00:59,640 --> 00:01:01,910
ಆದರೆ ಸಂಖ್ಯೆ ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

21
00:01:01,910 --> 00:01:05,450
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಹೊಂದಿರುವ ನೀನು
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ hashtable ಗಾತ್ರ, ಇದು

22
00:01:05,450 --> 00:01:07,000
ಶೂನ್ಯ ಆರಂಭಿಸುತ್ತಾರೆ ಹೋಗುತ್ತದೆ.

23
00:01:07,000 --> 00:01:10,760
ಮತ್ತು ಹೇಗೆ ಕಾಪಾಡುವುದು ವಿಶೇಷವೇನು
ಅನೇಕ ಪದಗಳನ್ನು ನಮ್ಮ ನಿಘಂಟು ಇವೆ.

24
00:01:10,760 --> 00:01:13,710
>> ಆದ್ದರಿಂದ ಲೋಡ್ ಅವಲೋಕಿಸೋಣ.

25
00:01:13,710 --> 00:01:16,390
ಎಂದು ಲೋಡ್ ಗಮನಿಸಿ, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

26
00:01:16,390 --> 00:01:20,530
ಇದು ಯಶಸ್ವಿಯಾಗಿ ವೇಳೆ ನೀವು ನಿಜವಾದ ಮರಳಿ
ಲೋಡ್, ಮತ್ತು ಸುಳ್ಳು ಇಲ್ಲದಿದ್ದರೆ.

27
00:01:20,530 --> 00:01:23,990
ಮತ್ತು ಇದು, ಒಂದು const ಚಾರ್ * ನಿಘಂಟು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ನಿಘಂಟು ಇದು

28
00:01:23,990 --> 00:01:25,280
ನಾವು ತೆರೆಯಲು ಬಯಸುವ.

29
00:01:25,280 --> 00:01:27,170
ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ನಾವು ಮಾಡಲು ನೀನು.

30
00:01:27,170 --> 00:01:29,500
>> ನಾವು fopen ನೀನು
ಓದುವ ನಿಘಂಟು.

31
00:01:29,500 --> 00:01:31,680
ಮತ್ತು ನಾವು ಮಾಡಬೇಕು ನೀನು
ಅದು ಯಶಸ್ವಿಯಾಯಿತು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

32
00:01:31,680 --> 00:01:35,920
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿದರು ಹಾಗಿದ್ದರೆ, ನಾವು ಮಾಡಲಿಲ್ಲ
ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ತೆರೆಯಲು.

33
00:01:35,920 --> 00:01:37,440
ನಾವು ತಪ್ಪು ಹಿಂದಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ.

34
00:01:37,440 --> 00:01:41,580
ಆದರೆ ಯಶಸ್ವಿಯಾಗಿ ಮಾಡಿದರು ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಮುಕ್ತ, ನಾವು ಓದಲು ಬಯಸುವ

35
00:01:41,580 --> 00:01:42,400
ನಿಘಂಟು.

36
00:01:42,400 --> 00:01:46,450
ನಾವು ಕೆಲವು ಹೇಗೆ ರವರೆಗೆ ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು
ಈ ಕುಣಿಕೆಯಿಂದ ಹೊರಗೆ ಮುರಿಯಲು ಕಾರಣ,

37
00:01:46,450 --> 00:01:47,570
ನಾವು ನೋಡುತ್ತಾರೆ ಇದು.

38
00:01:47,570 --> 00:01:48,920
ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು.

39
00:01:48,920 --> 00:01:51,780
>> ಈಗ ನಾವು ನೀನು
ಒಂದು ನೋಡ್ malloc.

40
00:01:51,780 --> 00:01:54,020
ಮತ್ತು ಸಹಜವಾಗಿ ನಾವು ಅಗತ್ಯವಿದೆ
ಗಾಳಿಗೆ ಮತ್ತೆ ಪರಿಶೀಲಿಸಿ.

41
00:01:54,020 --> 00:01:58,680
ಆದ್ದರಿಂದ mallocing ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ವೇಳೆ, ನಂತರ
ನಾವು ನಾವು ಯಾವುದೇ ನೋಡ್ ಇಳಿಸುವುದನ್ನು ಬಯಸುವ

42
00:01:58,680 --> 00:02:02,590
ಮೊದಲು malloc ಗೆ ಏನಾಯಿತು, ಮುಚ್ಚಿ
ನಿಘಂಟು ಸುಳ್ಳು ಹಿಂತಿರುಗಿ.

43
00:02:02,590 --> 00:02:06,830
ಆದರೆ ನಿರ್ಲಕ್ಷಿಸಿ, ಊಹಿಸಿಕೊಂಡು ನಾವು
ಯಶಸ್ವಿಯಾದರು, ನಾವು fscanf ಬಳಸಲು ಬಯಸುವ

44
00:02:06,830 --> 00:02:12,400
ಒಂದೇ ಒಂದು ಪದ ಓದಲು ನಮ್ಮ
ನಮ್ಮ ನೋಡ್ ಡಿಕ್ಷನರಿ.

45
00:02:12,400 --> 00:02:17,940
ಆದ್ದರಿಂದ ಪ್ರವೇಶ> ಪದ ನೆನಪು ಚಾರ್
+ 1 ಗಾತ್ರ LENGHTH ಪದ ಬಫರ್

46
00:02:17,940 --> 00:02:20,300
ನಾವು ಸೈನ್ ಪದ ಶೇಖರಿಸಿಡಲು ನೀನು

47
00:02:20,300 --> 00:02:25,070
>> ಆದ್ದರಿಂದ fscanf ಎಲ್ಲಿಯವರೆಗೆ, 1 ಮರಳಲು ಹೋಗುತ್ತದೆ
ಇದು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಯಶಸ್ವಿಯಾಗಿ ಎಂದು

48
00:02:25,070 --> 00:02:26,750
ಕಡತದಿಂದ ಪದ ಓದಲು.

49
00:02:26,750 --> 00:02:30,460
ದೋಷ ಎರಡೂ ಸಂಭವಿಸಿದಲ್ಲಿ, ಅಥವಾ ನಾವು
ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಲು, ಇದು

50
00:02:30,460 --> 00:02:31,950
1 ಹಿಂತಿರುಗುವುದಿಲ್ಲ.

51
00:02:31,950 --> 00:02:35,180
ಇದು, 1 ಮರಳಲು ಇದು ಸಂದರ್ಭದಲ್ಲಿ
ನಾವು ಅಂತಿಮವಾಗಿ ಔಟ್ ಮುರಿಯಲು ನೀನು

52
00:02:35,180 --> 00:02:37,280
ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್.

53
00:02:37,280 --> 00:02:42,770
ಆದ್ದರಿಂದ ನಾವು ನೋಡಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಒಮ್ಮೆ
ಒಂದು ಪದ ಓದಲು

54
00:02:42,770 --> 00:02:48,270
ಪ್ರವೇಶ> ಪದ, ಆಗ ನೀನು
ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಳಸಿ ಪದ.

55
00:02:48,270 --> 00:02:49,580
>> ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ
ಹ್ಯಾಶ್ ಕ್ರಿಯೆ.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿಲ್ಲ
ಈ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು.

58
00:02:55,610 --> 00:02:59,460
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ಈ ಹ್ಯಾಶ್ ಎಳೆದ
ಇಂಟರ್ನೆಟ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

59
00:02:59,460 --> 00:03:04,010
ನೀವು ಗುರುತಿಸಲು ಅಗತ್ಯವಿದೆ ಮಾತ್ರ ವಿಷಯ
ಈ ಒಂದು const ಚಾರ್ * ಪದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

60
00:03:04,010 --> 00:03:08,960
ಆದ್ದರಿಂದ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ತೆಗೆದುಕೊಳ್ಳುವ, ಮತ್ತು
ಔಟ್ಪುಟ್ ಒಂದು ಇಂಟ್ ರುಜುಮಾಡದ ಹಿಂದಿರುಗಿದ.

61
00:03:08,960 --> 00:03:12,360
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇಲ್ಲಿದೆ, ಇದು
ಒಂದು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನೀವು ನೀಡುತ್ತದೆ

62
00:03:12,360 --> 00:03:14,490
hashtable ಒಳಗೆ ಸೂಚ್ಯಂಕ.

63
00:03:14,490 --> 00:03:18,530
>> ನಾವು NUM_BUCKETS ಮೂಲಕ moding ನೀವು ಗಮನಿಸಬಹುದು,
ಆದ್ದರಿಂದ ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು

64
00:03:18,530 --> 00:03:21,730
ವಾಸ್ತವವಾಗಿ hashtable ಒಳಗೆ ಸೂಚ್ಯಂಕ
ಮತ್ತು ಮಾಡುತ್ತದೆ ಮೀರಿ ಸೂಚ್ಯಂಕ

65
00:03:21,730 --> 00:03:24,320
ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು.

66
00:03:24,320 --> 00:03:28,060
ಆ ಕ್ರಿಯೆಯ ಆದ್ದರಿಂದ, ನಾವು ನೀನು ನೀಡಿದ
ನಾವು ಓದುವ ಪದ ಹ್ಯಾಶ್

67
00:03:28,060 --> 00:03:29,390
ನಿಘಂಟು.

68
00:03:29,390 --> 00:03:31,700
ನಂತರ ನಾವು ಬಳಸಲು ನೀನು
ಸೇರಿಸಲು ಹ್ಯಾಶ್

69
00:03:31,700 --> 00:03:33,750
hashtable ಪ್ರವೇಶ.

70
00:03:33,750 --> 00:03:38,520
>> ಈಗ hashtable ಹ್ಯಾಶ್ ಪ್ರಸ್ತುತ
ಕೋಷ್ಟಕದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ.

71
00:03:38,520 --> 00:03:41,410
ಮತ್ತು ಇದು ತುಂಬಾ ಸಂಭಾವ್ಯ
ಇದು ಕೇವಲ ಶೂನ್ಯ ಎಂದು.

72
00:03:41,410 --> 00:03:44,960
ನಾವು ನಮ್ಮ ನಮೂದನ್ನು ಸೇರಿಸಲು ಬಯಸುವ
ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ.

73
00:03:44,960 --> 00:03:48,600
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಪ್ರಸ್ತುತ ಮಾಡಲಿಕ್ಕೆ
ಏನು hashtable ಪ್ರವೇಶ ಬಿಂದು

74
00:03:48,600 --> 00:03:50,380
ಪ್ರಸ್ತುತ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

75
00:03:50,380 --> 00:03:53,310
ನಂತರ ನಾವು, ಶೇಖರಿಸಿಡಲು ನೀನು
ನಲ್ಲಿ hashtable ರಲ್ಲಿ

76
00:03:53,310 --> 00:03:55,350
ಹ್ಯಾಶ್, ಪ್ರಸ್ತುತ ಪ್ರವೇಶ.

77
00:03:55,350 --> 00:03:59,320
ಆದ್ದರಿಂದ ಈ ಎರಡು ಸಾಲುಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸೇರಿಸಲು
ಆರಂಭದಲ್ಲಿ ಪ್ರವೇಶ

78
00:03:59,320 --> 00:04:02,260
ಎಂದು ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ
hashtable ರಲ್ಲಿ.

79
00:04:02,260 --> 00:04:04,900
>> ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ತಿಳಿದಿರುವಂತೆ
ನಾವು ಮತ್ತೊಂದು ಪದ ಕಂಡು

80
00:04:04,900 --> 00:04:07,790
ನಿಘಂಟು, ಮತ್ತು ನಾವು ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು.

81
00:04:07,790 --> 00:04:13,960
ನಾವು ನಡೆಸುವ ಎಂದು fscanf ರವರೆಗೆ
ಅಂತಿಮವಾಗಿ ಅಲ್ಲದ 1 ಏನೋ ಮರಳಿದರು

82
00:04:13,960 --> 00:04:16,950
ಪಾಯಿಂಟ್ ನೆನಪು
ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ.

83
00:04:16,950 --> 00:04:19,459
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಒಂದು ನಮೂದನ್ನು malloced.

84
00:04:19,459 --> 00:04:21,329
ನಾವು ಏನೋ ಓದಲು ಪ್ರಯತ್ನಿಸಿದ
ನಿಘಂಟು ನಿಂದ.

85
00:04:21,329 --> 00:04:23,910
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಮಾಡಲಿಲ್ಲ
ರಲ್ಲಿ ನಿಘಂಟು ಏನನ್ನೋ,

86
00:04:23,910 --> 00:04:26,650
ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ ಸಂದರ್ಭದಲ್ಲಿ
ನಾವು ವಾಸ್ತವವಾಗಿ ಆರಂಭವಾಯಿತು ಎಂದಿಗೂ ಎಂದು

87
00:04:26,650 --> 00:04:29,140
hashtable, ಮತ್ತು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು.

88
00:04:29,140 --> 00:04:32,750
>> ನಾವು ಭೇದಿಸಿ ಒಮ್ಮೆ ನಾವು ನೋಡಿ ಅಗತ್ಯವಿದೆ, ಹಾಗೂ,
ನಾವು ಏಕೆಂದರೆ ಅಲ್ಲಿ ಮುರಿದಿದ್ದಾರೆ

89
00:04:32,750 --> 00:04:34,360
ದೋಷ ಕಡತದಿಂದ ಓದುವ?

90
00:04:34,360 --> 00:04:37,120
ಅಥವಾ ನಾವು ಮುರಿದಿದ್ದಾರೆ ಏಕೆಂದರೆ ನಾವು
ಕಡತದ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿತು?

91
00:04:37,120 --> 00:04:39,480
ದೋಷ ನಂತರ, ಇಲ್ಲದಿದ್ದರೆ
ನಾವು ತಪ್ಪು ಮರಳಲು ಬಯಸುವ.

92
00:04:39,480 --> 00:04:40,930
ಲೋಡ್ ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ಏಕೆಂದರೆ.

93
00:04:40,930 --> 00:04:43,890
ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಾವು ಇಳಿಸುವುದನ್ನು ಬಯಸುವ
ಎಲ್ಲಾ ನಾವು ಓದಲು ಪದಗಳನ್ನು, ಮತ್ತು

94
00:04:43,890 --> 00:04:45,670
ನಿಘಂಟು ಕಡತ ಮುಚ್ಚಿ.

95
00:04:45,670 --> 00:04:48,740
>> ನಾವು ಯಶಸ್ವಿಯಾಗಲು ಮಾಡಲಿಲ್ಲ ಭಾವಿಸಿಕೊಂಡು, ನಂತರ ನಾವು
ಇನ್ನೂ ನಿಘಂಟು ಮುಚ್ಚಲು ಅಗತ್ಯ

96
00:04:48,740 --> 00:04:53,040
ಫೈಲ್, ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಿಜವಾದ ಹಿಂತಿರುಗಿ ರಿಂದ ನಾವು
ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ಲೋಡ್.

97
00:04:53,040 --> 00:04:54,420
ಮತ್ತು ಲೋಡ್ ಅದು.

98
00:04:54,420 --> 00:04:59,020
ಈಗ, ಒಂದು ಲೋಡ್ hashtable ನೀಡಿದ ಪರಿಶೀಲಿಸಿ
ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.

99
00:04:59,020 --> 00:05:03,140
ಆದ್ದರಿಂದ ಇದು, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಪರಿಶೀಲಿಸಿ
ಜಾರಿಗೆ ಎಂಬುದನ್ನು ಹೋಗುವ

100
00:05:03,140 --> 00:05:07,530
ಚಾರ್ * ಪದದ, ಎಂಬುದನ್ನು ಜಾರಿಗೆ
ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ನಿಘಂಟು ಹೊಂದಿದೆ.

101
00:05:07,530 --> 00:05:09,890
, ಇದು ನಿಘಂಟು ಆದ್ದರಿಂದ ವೇಳೆ
ಇದು ನಮ್ಮ hashtable ವೇಳೆ,

102
00:05:09,890 --> 00:05:11,170
ನಾವು ನಿಜವಾದ ಹಿಂತಿರುಗುವುದು.

103
00:05:11,170 --> 00:05:13,380
ಇದು ಅಲ್ಲ, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗುವುದು.

104
00:05:13,380 --> 00:05:17,740
>> ಈ ಪದವನ್ನು ಜಾರಿಗೆ ನೀಡಿದ ನಾವು
ಪದ ಹ್ಯಾಶ್ ಹೋಗುವ.

105
00:05:17,740 --> 00:05:22,110
ಈಗ ಗುರುತಿಸಲು ಪ್ರಮುಖ ವಿಷಯ
ಲೋಡ್ ನಾವು ತಿಳಿದಿದ್ದು ಆ ಎಲ್ಲಾ

106
00:05:22,110 --> 00:05:23,820
ನಾವು ಸಣ್ಣಾಕ್ಷರದ ನೀನು ಪದಗಳನ್ನು.

107
00:05:23,820 --> 00:05:25,820
ಆದರೆ ಇಲ್ಲಿ ನಾವು ಖಚಿತವಾಗಿ ಇಲ್ಲ.

108
00:05:25,820 --> 00:05:29,510
ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ನೋಡೋಣ ವೇಳೆ,
ವಾಸ್ತವವಾಗಿ ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ

109
00:05:29,510 --> 00:05:32,700
ಕಡಿಮೆ ಕವಚವನ್ನು ಪ್ರತಿ ಪಾತ್ರ
ಪದದ.

110
00:05:32,700 --> 00:05:37,940
ಆದ್ದರಿಂದ ಲೆಕ್ಕಿಸದೆ ಬಂಡವಾಳದ
ಪದ, ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಮರಳುವುದು

111
00:05:37,940 --> 00:05:42,270
ಏನೇ ಅದೇ ಸೂಚ್ಯಂಕ
ಬಂಡವಾಳೀಕರಣ ಇದು ಎಂದು ಎಂದು, ಆಗಿದೆ

112
00:05:42,270 --> 00:05:45,280
ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಸಣ್ಣ ಮರಳಿದರು
ಪದ ಆವೃತ್ತಿ.

113
00:05:45,280 --> 00:05:46,600
ಆಲ್ರೈಟ್.

114
00:05:46,600 --> 00:05:49,790
ನಮ್ಮ ಸೂಚ್ಯಂಕ ಇಲ್ಲಿದೆ
ಈ ಪದ hashtable.

115
00:05:49,790 --> 00:05:52,940
>> ಈಗ ಲೂಪ್ ಈ ಹೋಗುತ್ತದೆ
ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಮರಳಿ

116
00:05:52,940 --> 00:05:55,000
ಆ ಸೂಚ್ಯಂಕ ಆಗಿತ್ತು.

117
00:05:55,000 --> 00:05:59,610
ನಾವು ಪ್ರವೇಶ ಆರಂಭಿಸುವಲ್ಲಿ ಗಮನಕ್ಕೆ
ಸೂಚ್ಯಂಕ ತೋರಿಸಲು.

118
00:05:59,610 --> 00:06:02,750
ನಾವು ಮುಂದುವರಿಯಲು ನೀನು
ಪ್ರವೇಶ! = ನಲ್ ಮಾಡುವಾಗ.

119
00:06:02,750 --> 00:06:07,770
ಮತ್ತು ನೆನಪಿಡಿ ಎಂದು ಪಾಯಿಂಟರ್ ಅಪ್ಡೇಟ್
ಮುಂದಿನ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಪ್ರವೇಶ = ಪ್ರವೇಶ>.

120
00:06:07,770 --> 00:06:14,400
ಆದ್ದರಿಂದ ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಬಿಂದು ಹೊಂದಿವೆ
ಲಿಂಕ್ ಪಟ್ಟಿ ಮುಂದಿನ ಐಟಂ.

121
00:06:14,400 --> 00:06:19,250
>> ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನಮೂದು,
ನಾವು strcasecmp ಬಳಸಲು ನೀನು.

122
00:06:19,250 --> 00:06:20,330
ಇದು strcomp ಅಲ್ಲ.

123
00:06:20,330 --> 00:06:23,780
ಮತ್ತೊಮ್ಮೆ, ನಾವು ಬಯಸುವ ಏಕೆಂದರೆ
ತೋರದಂತೆ ವಿಷಯಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಲು.

124
00:06:23,780 --> 00:06:27,870
ನಾವು ಹೋಲಿಸಲು strcasecmp ಬಳಸಲು
ಈ ಮೂಲಕ ರವಾನಿಸಲಾಗಿದೆ ಎಂದು ಪದ

125
00:06:27,870 --> 00:06:31,860
ಪದ ವಿರುದ್ಧ ಕಾರ್ಯ
ಈ ನಮೂದನ್ನು ರಲ್ಲಿ ಆಗಿದೆ.

126
00:06:31,860 --> 00:06:35,570
ಇದು ಶೂನ್ಯ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇರಲಿಲ್ಲ ಅರ್ಥ
ನಾವು ಬಯಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಂದ್ಯದಲ್ಲಿ,

127
00:06:35,570 --> 00:06:36,630
ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

128
00:06:36,630 --> 00:06:39,590
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಕಂಡು
ನಮ್ಮ hashtable ಪದ.

129
00:06:39,590 --> 00:06:43,040
>> ಪಂದ್ಯದಲ್ಲಿ ಇರಲಿಲ್ಲ, ಆಗ ನಾವು ಆರ್
ಮತ್ತೆ ಲೂಪ್ ಹೋಗುವ ಮತ್ತು ನೋಡಲು

130
00:06:43,040 --> 00:06:43,990
ಮುಂದಿನ ಪ್ರವೇಶ.

131
00:06:43,990 --> 00:06:47,640
ನಾವು ಹಾಗೆಯೇ ಇಲ್ಲ ಆವರ್ತಿಸುವ ಮುಂದುವರಿಸುತ್ತೇವೆ
ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನಮೂದುಗಳು.

132
00:06:47,640 --> 00:06:50,160
ನಾವು ಮುರಿಯಲು ಏನಾಗುತ್ತದೆ
ಲೂಪ್ ಈ ಔಟ್?

133
00:06:50,160 --> 00:06:55,110
ನಾವು ಒಂದು ನಮೂದನ್ನು ಕಾಣಲಿಲ್ಲ ಅರ್ಥ
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಪದ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ

134
00:06:55,110 --> 00:07:00,220
ನಾವು ಸೂಚಿಸಲು ತಪ್ಪು ಹಿಂತಿರುಗಿ ನಮ್ಮ
hashtable ಈ ಪದ ಹೊಂದಿರುವುದಿಲ್ಲ.

135
00:07:00,220 --> 00:07:02,540
ಮತ್ತು ಒಂದು ಚೆಕ್.

136
00:07:02,540 --> 00:07:04,790
>> ಆದ್ದರಿಂದ ಗಾತ್ರದಲ್ಲಿ ಅವಲೋಕಿಸೋಣ.

137
00:07:04,790 --> 00:07:06,970
ಈಗ ಗಾತ್ರ ಬಹಳ ಸರಳ ಎಂದು ಹೋಗುತ್ತದೆ.

138
00:07:06,970 --> 00:07:11,080
ರಿಂದ ಪ್ರತಿ ಪದಕ್ಕೆ, ಲೋಡ್ ನೆನಪು
ನಾವು ಜಾಗತಿಕ ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು, ಕಂಡು

139
00:07:11,080 --> 00:07:12,880
ವೇರಿಯಬಲ್ hashtable ಗಾತ್ರ.

140
00:07:12,880 --> 00:07:16,480
ಆದ್ದರಿಂದ ಗಾತ್ರ ಕಾರ್ಯ ಕೇವಲ ಹೋಗುತ್ತದೆ
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮರಳಲು.

141
00:07:16,480 --> 00:07:18,150
ಮತ್ತು ಅಷ್ಟೇ.

142
00:07:18,150 --> 00:07:22,300
>> ಈಗ ಅಂತಿಮವಾಗಿ, ನಾವು ಇಳಿಸುವುದನ್ನು ಅಗತ್ಯವಿದೆ
ನಿಘಂಟು ಎಲ್ಲವೂ ಮಾಡಲಾಗುತ್ತದೆ ಒಮ್ಮೆ.

143
00:07:22,300 --> 00:07:25,340
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಏನು ಮಾಡೋಣ?

144
00:07:25,340 --> 00:07:30,440
ಇಲ್ಲಿಯೇ ಮೇಲೆ ಲೂಪ್ ನೀವು
ನಮ್ಮ ಟೇಬಲ್ ಎಲ್ಲಾ ಬಕೆಟ್.

145
00:07:30,440 --> 00:07:33,240
ಆದ್ದರಿಂದ NUM_BUCKETS ಬಕೆಟ್ ಇವೆ.

146
00:07:33,240 --> 00:07:37,410
ಮತ್ತು ಪ್ರತಿ ಲಿಂಕ್ ಪಟ್ಟಿ ನಮ್ಮ
hashtable, ನಾವು ಮೇಲೆ ಲೂಪ್ ನೀನು

147
00:07:37,410 --> 00:07:41,070
ಲಿಂಕ್ ಪಟ್ಟಿ ಸಮಗ್ರತೆಯು
ಪ್ರತಿ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಿದ.

148
00:07:41,070 --> 00:07:42,900
>> ಈಗ ನಾವು ಎಚ್ಚರಿಕೆಯಿಂದ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

149
00:07:42,900 --> 00:07:47,910
ಇಲ್ಲಿ ನಾವು ಒಂದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್
ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಸಂಗ್ರಹಿಸಲು

150
00:07:47,910 --> 00:07:49,730
ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಂಶ.

151
00:07:49,730 --> 00:07:52,140
ನಂತರ ನಾವು ಉಚಿತ ನೀನು
ಪ್ರಸ್ತುತ ಅಂಶ.

152
00:07:52,140 --> 00:07:55,990
ನಾವು ಈ ಮಾಡಲು ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ
ಕೇವಲ ಪ್ರಸ್ತುತ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

153
00:07:55,990 --> 00:07:59,180
ತದನಂತರ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ,
ಒಮ್ಮೆ ರಿಂದ ನಾವು ಬಿಡುಗಡೆ ಮಾಡಿದ,

154
00:07:59,180 --> 00:08:00,870
ಮೆಮೊರಿ ಅಮಾನ್ಯ ಆಗುತ್ತದೆ.

155
00:08:00,870 --> 00:08:04,990
>> ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಸುಮಾರು ಇರಿಸಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ
ಮುಂದಿನ ಅಂಶ, ನಾವು ಮುಕ್ತಗೊಳಿಸಲು

156
00:08:04,990 --> 00:08:08,360
ಪ್ರಸ್ತುತ ಅಂಶ, ಮತ್ತು ನಂತರ ನಾವು ಅಪ್ಡೇಟ್
ತೋರಿಸಲು ನಮ್ಮ ಪ್ರಸ್ತುತ ಅಂಶ

157
00:08:08,360 --> 00:08:09,550
ಮುಂದಿನ ಅಂಶ.

158
00:08:09,550 --> 00:08:12,800
ನಾವು ಅಂಶಗಳನ್ನು ಲೂಪ್ ಇವೆ ವಿಲ್
ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ.

159
00:08:12,800 --> 00:08:15,620
ನಾವು ಎಲ್ಲಾ ಸಂಬಂಧ ಹಾಗೆ ಮಾಡುತ್ತೇವೆ
hashtable ಪಟ್ಟಿಗಳನ್ನು.

160
00:08:15,620 --> 00:08:19,460
ನಾವು ಪೂರೈಸಿದ ಒಮ್ಮೆ, ನಾವು
ಸಂಪೂರ್ಣವಾಗಿ hashtable ಕೆಳಗಿಳಿಸಲಾಯಿತು, ಮತ್ತು

161
00:08:19,460 --> 00:08:20,190
ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

162
00:08:20,190 --> 00:08:23,200
ಆದ್ದರಿಂದ ಇಳಿಸುವುದನ್ನು ಫಾರ್ ಅಸಾಧ್ಯ
ಎಂದಾದರೂ ಸುಳ್ಳು ಮರಳಲು.

163
00:08:23,200 --> 00:08:26,470
ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ, ನಾವು
ಕೇವಲ ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

164
00:08:26,470 --> 00:08:29,000
>> ಈ ಪರಿಹಾರ ಪ್ರಯತ್ನಿಸಬಹುದು ಲೆಟ್.

165
00:08:29,000 --> 00:08:33,070
ಆದ್ದರಿಂದ ನಮ್ಮ ನೋಡೋಣ ಅವಕಾಶ
struct ನೋಡ್ ರೀತಿ ಕಾಣಿಸುತ್ತದೆ.

166
00:08:33,070 --> 00:08:36,220
ಇಲ್ಲಿ ನಾವು ಒಂದು bool ಮಾಡಲಿಕ್ಕೆ ನೋಡಿ
ಪದ ಮತ್ತು struct ನೋಡ್ * ಮಕ್ಕಳು

167
00:08:36,220 --> 00:08:37,470
ಬ್ರಾಕೆಟ್ ಆಲ್ಫಾಬೆಟ್.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
ನೀವು ಇರಬಹುದು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ಚಕಿತಗೊಳಿಸುತ್ತದೆ, ಏಕೆ ವರ್ಣಮಾಲೆಯಾಗಿದೆ

170
00:08:42,020 --> 00:08:44,660
ಎಡ್ 27 ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ?

171
00:08:44,660 --> 00:08:47,900
ಸರಿ, ನಮಗೆ ನೀನು ನೆನಪು
ಅಪಾಸ್ಟ್ರಫಿ ನಿರ್ವಹಣೆ ಎಂದು.

172
00:08:47,900 --> 00:08:51,910
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಆಫ್ ಎಂದು ವಿಶೇಷವೇನು
ಈ ಕಾರ್ಯಕ್ರಮದ ಉದ್ದಕ್ಕೂ ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ.

173
00:08:51,910 --> 00:08:54,710
>> ಈಗ ನೆನಪು ಹೇಗೆ ಒಂದು trie
ವಾಸ್ತವವಾಗಿ ಕೆಲಸ.

174
00:08:54,710 --> 00:08:59,380
ನಾವು ಪದ ಸೂಚಿ ನೀವು ಹೇಳುವ
"ಬೆಕ್ಕುಗಳು." ನಂತರ trie ಆಫ್ ಮೂಲದಿಂದ,

175
00:08:59,380 --> 00:09:02,610
ನಾವು ಮಕ್ಕಳು ನೋಡಲು ನೀನು
ರಚನೆಯ, ಮತ್ತು ನಾವು ನೋಡಲು ನೀನು

176
00:09:02,610 --> 00:09:08,090
ಅಕ್ಷರದ ಅನುರೂಪವಾಗಿದೆ ಸೂಚ್ಯಂಕ
2 ಸೂಚಿಸಲಾಗಿದೆ ಎಂದು ಸಿ ಆದ್ದರಿಂದ.

177
00:09:08,090 --> 00:09:11,530
ಆದ್ದರಿಂದ ನೀಡಿದ ಎಂದು, ಎಂದು ತಿನ್ನುವೆ
ನಮಗೆ ಹೊಸ ನೋಡ್ ನೀಡುತ್ತದೆ.

178
00:09:11,530 --> 00:09:13,820
ನಂತರ ನಾವು ನೋಡ್ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ.

179
00:09:13,820 --> 00:09:17,770
>> ಆ ನೋಡ್ ನೀಡಿದ, ನಾವು ಮತ್ತೊಮ್ಮೆ ಆರ್
ಮಕ್ಕಳ ರಚನೆಯ ನೋಡಲು ಹೋಗುವ.

180
00:09:17,770 --> 00:09:22,110
ನಾವು ಸೂಚ್ಯಂಕ ಶೂನ್ಯ ನೋಡಲು ನೀನು
ಬೆಕ್ಕು ಒಂದು ಸಂಬಂಧಿಸಿರುತ್ತದೆ.

181
00:09:22,110 --> 00:09:27,170
ಆದ್ದರಿಂದ ನಾವು ಎಂದು ನೋಡ್ ಹೋಗಲು ನೀನು,
ಮತ್ತು ಆ ನೋಡ್ ನೀಡಿದ ನಾವು ನೀನು

182
00:09:27,170 --> 00:09:31,090
ಕೊನೆಯಲ್ಲಿ ನೋಡಲು ಇದು ಅನುಗುಣವಾಗಿದೆ ಇಲ್ಲಿದೆ
ಟಿ ಮತ್ತು ನೋಡ್ನಲ್ಲಿ ಸ್ಥಳಾಂತರಗೊಳ್ಳುವ, ಗೆ

183
00:09:31,090 --> 00:09:35,530
ಅಂತಿಮವಾಗಿ, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಕಂಡಿದ್ದೇನೆ
ಮೂಲಕ ನಮ್ಮ ಪದ "ಬೆಕ್ಕು." ಈಗ bool

184
00:09:35,530 --> 00:09:40,960
ಪದ ಎಂಬುದನ್ನು ಹೇಳಲಾಗುವ
ಈ ಪದ ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ.

185
00:09:40,960 --> 00:09:43,470
>> ಆದ್ದರಿಂದ ನಾವು ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ ಬೇಕು?

186
00:09:43,470 --> 00:09:47,700
ಜೊತೆಗೆ ಯಾವ ಪದದ "ಮಹಾದುರಂತ"
ನಮ್ಮ ನಿಘಂಟು, ಆದರೆ

187
00:09:47,700 --> 00:09:50,150
ಪದ "ಬೆಕ್ಕು" ಅಲ್ಲ?

188
00:09:50,150 --> 00:09:54,580
ಆದ್ದರಿಂದ ಮತ್ತು ನೋಡಿದರೆ ವೇಳೆ ಪದ "ಬೆಕ್ಕು"
ನಮ್ಮ ನಿಘಂಟು ರಲ್ಲಿ, ನಾವು ಇದೆ

189
00:09:54,580 --> 00:09:59,970
ಯಶಸ್ವಿಯಾಗಿ ಮೂಲಕ ನೋಡಲು ಹೋಗುವ
ಪ್ರದೇಶದಲ್ಲಿ ನೋಡ್ನಲ್ಲಿ ಸೂಚ್ಯಂಕಗಳು ಸಿ ಎ ಟಿ.

190
00:09:59,970 --> 00:10:04,290
ಆದರೆ ಏಕೈಕ ಕಾರಣ ಮಹಾದುರಂತ
ದಾರಿಯಲ್ಲಿ ಗ್ರಂಥಿಗಳು ರಚಿಸಲು ಸಂಭವಿಸಿದ

191
00:10:04,290 --> 00:10:07,190
ಸಿ ಎ ಟಿ ರಿಂದ, ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ
ಪದದ ಕೊನೆಯಲ್ಲಿ.

192
00:10:07,190 --> 00:10:12,020
ಆದ್ದರಿಂದ, bool ಪದ ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ
ಈ ನಿರ್ದಿಷ್ಟ ಸ್ಥಳ

193
00:10:12,020 --> 00:10:14,310
ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ ಸೂಚಿಸುತ್ತದೆ.

194
00:10:14,310 --> 00:10:15,140
>> ಸರಿ.

195
00:10:15,140 --> 00:10:19,310
ಈಗ ನಾವು trie, ಎಂಬುದನ್ನು ತಿಳಿದಿರುವುದರಿಂದ
ನೋಡಲು ಹೋಗುವ, ನ ನೋಡೋಣ

196
00:10:19,310 --> 00:10:20,730
ಕಾರ್ಯ ಲೋಡ್.

197
00:10:20,730 --> 00:10:24,610
ಆದ್ದರಿಂದ ಲೋಡ್ ಒಂದು bool ಮರಳಲು ಹೋಗುತ್ತದೆ
ಎಂಬುದನ್ನು ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅಥವಾ

198
00:10:24,610 --> 00:10:26,720
ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ನಿಘಂಟು ಲೋಡ್.

199
00:10:26,720 --> 00:10:30,460
ಈ ನಿಘಂಟು ಏರಲಿದೆ
ನಾವು ಲೋಡ್ ಬಯಸುವ.

200
00:10:30,460 --> 00:10:33,930
>> ನಾವು ಆರ್ ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ ಮುಕ್ತ
ಓದುವ ಎಂದು ನಿಘಂಟು ಅಪ್.

201
00:10:33,930 --> 00:10:36,160
ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು
ನಾವು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

202
00:10:36,160 --> 00:10:39,580
ನಿಘಂಟು ಅಲ್ಲ ಆದ್ದರಿಂದ ವೇಳೆ
ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು, ಇದು ಹಿಂತಿರುಗುವುದು

203
00:10:39,580 --> 00:10:42,400
ಶೂನ್ಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು
ತಪ್ಪು ಮರಳಲು ಹೋಗುತ್ತದೆ.

204
00:10:42,400 --> 00:10:47,230
ಆದರೆ ಭಾವಿಸಿದರೂ ಇದು ಯಶಸ್ವಿಯಾಗಿ
ತೆರೆಯಿತು, ನಾವು ವಾಸ್ತವವಾಗಿ ಓದಬಹುದು

205
00:10:47,230 --> 00:10:48,220
ನಿಘಂಟು ಮೂಲಕ.

206
00:10:48,220 --> 00:10:50,880
>> ನಾವು ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ಮಾಡಲು ಬಯಸುವ ನಾವು ಈ ಹೊಂದಿವೆ ಇದೆ

207
00:10:50,880 --> 00:10:52,500
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮೂಲ.

208
00:10:52,500 --> 00:10:56,190
ಈಗ ಮೂಲ * ಒಂದು ನೋಡ್ ಏರಲಿದೆ.

209
00:10:56,190 --> 00:10:59,760
ಇದು ನಾವು ನೀವು ನಮ್ಮ trie ಅಗ್ರ ಇಲ್ಲಿದೆ
ಮೂಲಕ iterating ಮಾಡಲು ಹೋಗುತ್ತಿದ್ದೇನೆ.

210
00:10:59,760 --> 00:11:02,660
ನಾವು ನೀನು ಎಷ್ಟು ಮೊದಲನೆಯದಾಗಿ
ಮಾಡಲು ಬಯಸುವ ನಿಯೋಜಿಸಿ ಆಗಿದೆ

211
00:11:02,660 --> 00:11:04,140
ನಮ್ಮ ಮೂಲ ಮೆಮೊರಿ.

212
00:11:04,140 --> 00:11:07,980
ನಾವು calloc, ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ
ಮೂಲತಃ ಅದೇ ಕಾರ್ಯ,

213
00:11:07,980 --> 00:11:11,500
malloc ಕಾರ್ಯ ಹೊರತುಪಡಿಸಿ ಇದು
ಎಂದು ಏನೋ ಮರಳಲು ಭರವಸೆ

214
00:11:11,500 --> 00:11:13,180
ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ zeroed.

215
00:11:13,180 --> 00:11:17,290
ನಾವು malloc ಬಳಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾವು ಅಗತ್ಯವಿದೆ
ರಲ್ಲಿ ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿ ನಮ್ಮ

216
00:11:17,290 --> 00:11:20,160
ನೋಡ್, ಮತ್ತು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
ಅವರು ಎಲ್ಲಾ ಶೂನ್ಯ ಆರ್.

217
00:11:20,160 --> 00:11:22,710
ಆದ್ದರಿಂದ calloc, ನಮಗೆ ಹಾಗೆ ಕಾಣಿಸುತ್ತದೆ.

218
00:11:22,710 --> 00:11:26,330
>> ಈಗ ಕೇವಲ malloc ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ
ಹಂಚಿಕೆ ವಾಸ್ತವವಾಗಿ ಎಂದು ಖಚಿತವಾಗಿ

219
00:11:26,330 --> 00:11:27,520
ಯಶಸ್ವಿ.

220
00:11:27,520 --> 00:11:29,990
ಈ ಶೂನ್ಯ ಹಿಂದಿರುಗಿದರು ವೇಳೆ, ನಾವು
ಮುಚ್ಚಿ ಅಥವಾ ನಿಘಂಟು ಅಗತ್ಯವಿದೆ

221
00:11:29,990 --> 00:11:32,100
ಫೈಲ್ ಸುಳ್ಳು ಹಿಂತಿರುಗಿ.

222
00:11:32,100 --> 00:11:36,835
ಆದ್ದರಿಂದ ಹಂಚಿಕೆ ಹೋಗಿದ್ದರೆ
ಯಶಸ್ವಿ, ನಾವು * ಒಂದು ನೋಡ್ ಬಳಸಲು ನೀನು

223
00:11:36,835 --> 00:11:40,270
ನಮ್ಮ trie ಮೂಲಕ ಮರಳಿ ಕರ್ಸರ್.

224
00:11:40,270 --> 00:11:43,890
ಆದ್ದರಿಂದ ನಮ್ಮ ಬೇರುಗಳು ಬದಲಿಸಲು ಹೋಗಿ ಎಂದಿಗೂ,
ಆದರೆ ನಾವು ಕರ್ಸರ್ ಬಳಸಲು ನೀನು

225
00:11:43,890 --> 00:11:47,875
ವಾಸ್ತವವಾಗಿ ನೋಡ್ನಿಂದ ನೋಡ್ಗೆ ಹೋಗಿ.

226
00:11:47,875 --> 00:11:50,940
>> ಆದ್ದರಿಂದ ಈ ಲೂಪ್ ನಾವು ಓದುತ್ತಿದ್ದಲ್ಲಿ
ನಿಘಂಟು ಕಡತ ಮೂಲಕ.

227
00:11:50,940 --> 00:11:53,670
ನಾವು fgetc ಬಳಸುತ್ತಿರುವ.

228
00:11:53,670 --> 00:11:56,290
Fgetc ಒಂದೇ ದೋಚಿದ ಹೋಗುತ್ತದೆ
ಕಡತದಿಂದ ಪಾತ್ರ.

229
00:11:56,290 --> 00:11:59,370
ನಾವು ಧರಿಸುವುದನ್ನು ಮುಂದುವರಿಯಲು ನೀನು
ಪಾತ್ರಗಳು ನಾವು ತಲುಪಲು ಇಲ್ಲ

230
00:11:59,370 --> 00:12:01,570
ಕಡತದ ಕೊನೆಯಲ್ಲಿ.

231
00:12:01,570 --> 00:12:03,480
>> ನಾವು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ ಎರಡು ಪ್ರಕರಣಗಳು ಇವೆ.

232
00:12:03,480 --> 00:12:06,610
ಮೊದಲ, ವೇಳೆ ಪಾತ್ರ
ಹೊಸ ಲೈನ್ ಅಲ್ಲ.

233
00:12:06,610 --> 00:12:10,450
ಆದ್ದರಿಂದ ನಾವು ನಂತರ, ಹೊಸ ಲೈನ್ ಎಂದು ತಿಳಿಯಲು
ನಾವು ಒಂದು ಹೊಸ ಪದ ತೆರಳಿ ಬಗ್ಗೆ ಆರ್.

234
00:12:10,450 --> 00:12:15,240
ಆದರೆ, ಇದು ಹೊಸ ಲೈನ್ ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಇಲ್ಲಿ ನಾವು ಲೆಕ್ಕಾಚಾರ ಬಯಸುವ

235
00:12:15,240 --> 00:12:18,380
ಸೂಚ್ಯಂಕ ನಾವು ಒಳಗೆ ಸೂಚ್ಯಂಕ ನೀನು
ಮಕ್ಕಳ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಂದು

236
00:12:18,380 --> 00:12:19,810
ನಾವು ಮೊದಲು ನೋಡಿವೆ.

237
00:12:19,810 --> 00:12:23,880
>> ಆದ್ದರಿಂದ, ನಾನು ಮೊದಲೇ ಹೇಳಿದ ಹಾಗೆ, ನಾವು ಅಗತ್ಯವಿದೆ
ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ ಅಪಾಸ್ಟ್ರಫಿ.

238
00:12:23,880 --> 00:12:26,220
ನಾವು ತ್ರಯಾತ್ಮಕ ಬಳಸುತ್ತಿರುವ ಗಮನಿಸಿ
ಇಲ್ಲಿ ಆಯೋಜಕರು.

239
00:12:26,220 --> 00:12:29,580
ನಾವು ವೇಳೆ, ಈ ಓದಲು ನೀನು
ನಾವು ಓದಲು ಪಾತ್ರ ಒಂದು ಆಗಿತ್ತು

240
00:12:29,580 --> 00:12:35,330
ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ಹೊರಟಿರುವೆ
ಸೂಚ್ಯಂಕ = "ವರ್ಣಮಾಲೆ" -1, ಇದು ತಿನ್ನುವೆ

241
00:12:35,330 --> 00:12:37,680
ಸೂಚ್ಯಂಕ 26 ಎಂದು.

242
00:12:37,680 --> 00:12:41,130
>> ಎಲ್ಸ್ ಇದು ಅಪಾಸ್ಟ್ರಫಿ ಅಲ್ಲ ವೇಳೆ, ಇಲ್ಲ
ನಾವು ಸೂಚ್ಯಂಕ ಹೊರಟಿರುವೆ

243
00:12:41,130 --> 00:12:43,760
ಸಿ ಸಮಾನವಾಗಿರುತ್ತದೆ - ಒಂದು.

244
00:12:43,760 --> 00:12:49,030
ಆದ್ದರಿಂದ ಮತ್ತೆ ಹಿಂದೆ ಸೆಟ್ ನೆನಪು,
ಸಿ - ಒಂದು ನಮಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ

245
00:12:49,030 --> 00:12:53,410
ಸಿ ವರ್ಣಮಾಲೆ ಸ್ಥಾನಗಳಿಗೆ ಆದ್ದರಿಂದ
ಸಿ ಈ ತಿನ್ನುವೆ, ಅಕ್ಷರದ ಎ

246
00:12:53,410 --> 00:12:54,700
ನಮಗೆ ಸೂಚ್ಯಂಕ ಶೂನ್ಯ ನೀಡಿ.

247
00:12:54,700 --> 00:12:58,120
ಅಕ್ಷರದ ಬಿ, ಇದು ನೀಡುತ್ತದೆ
ಹೀಗೆ ನಮಗೆ ಸೂಚ್ಯಂಕ 1, ಮತ್ತು.

248
00:12:58,120 --> 00:13:03,010
>> ಆದ್ದರಿಂದ ಈ ನಮಗೆ ಒಳಗೆ ಸೂಚ್ಯಂಕ ನೀಡುತ್ತದೆ
ನಾವು ಬಯಸುವ ಮಕ್ಕಳಿಗೆ ರಚನೆಯ.

249
00:13:03,010 --> 00:13:08,890
ಈಗ ಈ ಸೂಚ್ಯಂಕ ಪ್ರಸ್ತುತ ಶೂನ್ಯ ವೇಳೆ
ಮಕ್ಕಳು, ಅಂದರೆ ಒಂದು ನೋಡ್

250
00:13:08,890 --> 00:13:11,830
ಪ್ರಸ್ತುತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ
ಎಂದು ಮಾರ್ಗವನ್ನು.

251
00:13:11,830 --> 00:13:15,160
ನಾವು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ
ಆ ಮಾರ್ಗವನ್ನು ಒಂದು ನೋಡ್.

252
00:13:15,160 --> 00:13:16,550
ನಾವು ಇಲ್ಲಿ ಮಾಡುತ್ತೇನೆ ಇಲ್ಲಿದೆ.

253
00:13:16,550 --> 00:13:20,690
>> ನಾವು ಮತ್ತೆ calloc, ಬಳಸಲು ನೀನು
ಕಾರ್ಯ, ನಾವು ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ

254
00:13:20,690 --> 00:13:22,880
ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಔಟ್ ಸೊನ್ನೆಗೆ.

255
00:13:22,880 --> 00:13:27,240
ನಾವು ಮತ್ತೆ ಪರಿಶೀಲಿಸಬೇಕು
ಎಂದು calloc, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

256
00:13:27,240 --> 00:13:30,700
Calloc, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ವೇಳೆ, ನಂತರ ನಾವು ಅಗತ್ಯವಿದೆ
ಎಲ್ಲವೂ ಅನ್ಲೋಡ್, ಮುಚ್ಚಿ ನಮ್ಮ

257
00:13:30,700 --> 00:13:32,820
ನಿಘಂಟು, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ.

258
00:13:32,820 --> 00:13:40,050
ಆದ್ದರಿಂದ ನಂತರ, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಈ ನಮಗೆ ಹೊಸ ಮಗುವಿನ ರಚಿಸುತ್ತದೆ.

259
00:13:40,050 --> 00:13:41,930
ನಂತರ ನಾವು ಮಗುವಿನ ಹೋಗುತ್ತದೆ.

260
00:13:41,930 --> 00:13:44,960
ನಮ್ಮ ಕರ್ಸರ್ ಮರಳಿ ಕಾಣಿಸುತ್ತದೆ
ಮಗು ಕೆಳಗೆ.

261
00:13:44,960 --> 00:13:49,330
>> ಈಗ ಈ ಆರಂಭಿಸಲು ಶೂನ್ಯ ಅಲ್ಲ ವೇಳೆ,
ನಂತರ ಕರ್ಸರ್ ಕೇವಲ ಮರಳಿ ಮಾಡಬಹುದು

262
00:13:49,330 --> 00:13:52,590
ವಾಸ್ತವವಾಗಿ ಇಲ್ಲದೆ ಆ ಮಗು ಕೆಳಗೆ
ಏನು ನಿಗದಿಪಡಿಸಬೇಕಾಗುತ್ತದೆ ಹೊಂದಿರುವ.

263
00:13:52,590 --> 00:13:56,730
ಈ ನಾವು ಮೊದಲ ಸಂಭವಿಸಿದ ಪ್ರಕರಣದಲ್ಲಿ
ಪದ ನಿಯೋಜಿಸಿ "ಬೆಕ್ಕು." ಮತ್ತು

264
00:13:56,730 --> 00:14:00,330
ನಾವು ನಿಯೋಜಿಸಿ ಹೋದಾಗ ಅರ್ಥ
"ಮಹಾದುರಂತ" ನಾವು ರಚಿಸಬೇಕಾಗಿದೆ ಇಲ್ಲ

265
00:14:00,330 --> 00:14:01,680
ಮತ್ತೆ ಸಿ ಎ ಟಿ ಗ್ರಂಥಿಗಳು.

266
00:14:01,680 --> 00:14:04,830
ಅವರು ಈಗಾಗಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

267
00:14:04,830 --> 00:14:06,080
>> ಬೇರೆ ಈ ಎಂದರೇನು?

268
00:14:06,080 --> 00:14:10,480
ಈ ಸಿ ಆಗಿತ್ತು ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ
ಸಿ ಹೊಸ ಲೈನ್ ಅಲ್ಲಿ backslash N,.

269
00:14:10,480 --> 00:14:13,710
ಈ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಅರ್ಥ
ಒಂದು ಪದ ಪೂರ್ಣಗೊಂಡಿತು.

270
00:14:13,710 --> 00:14:16,860
ಈಗ ನಾವು ಬಯಸುತ್ತೀರಿ ನಾವು
ಯಶಸ್ವಿಯಾಗಿ ಪದ ಪೂರ್ಣಗೊಂಡಿತು?

271
00:14:16,860 --> 00:14:21,100
ನಾವು ಈ ಪದ ಕ್ಷೇತ್ರ ಬಳಸಲು ನೀನು
ನಮ್ಮ struct ನೋಡ್ ಒಳಗೆ.

272
00:14:21,100 --> 00:14:23,390
ನಾವು ನಿಜವಾದ ಎಂದು ಹೊಂದಿಸಲು ಬಯಸುವ.

273
00:14:23,390 --> 00:14:27,150
ಆದ್ದರಿಂದ ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಈ ನೋಡ್
ಯಶಸ್ವಿ ಸೂಚಿಸುತ್ತದೆ

274
00:14:27,150 --> 00:14:29,250
ಪದ, ನಿಜವಾದ ಪದ.

275
00:14:29,250 --> 00:14:30,940
>> ಈಗ ನಿಜವಾದ ಸೆಟ್.

276
00:14:30,940 --> 00:14:35,150
ನಾವು ಬಿಂದುವಿಗೆ ನಮ್ಮ ಕರ್ಸರ್ ಮರುಹೊಂದಿಸಲು
ಮತ್ತೆ trie ಆರಂಭದಲ್ಲಿ ಗೆ.

277
00:14:35,150 --> 00:14:40,160
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ನಿಘಂಟು ಹೆಚ್ಚಿಸಲು
ಗಾತ್ರ, ನಾವು ಮತ್ತೊಂದು ಕೆಲಸ ಕಂಡು.

278
00:14:40,160 --> 00:14:43,230
ಆದ್ದರಿಂದ ನಾವು ಮಾಡುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು,
, ಪಾತ್ರದ ಅಕ್ಷರ ಓದುವ

279
00:14:43,230 --> 00:14:49,150
ನಮ್ಮ trie ಹೊಸ ಗ್ರಂಥಿಗಳು ನಿರ್ಮಿಸುವ ಮತ್ತು
ನಿಘಂಟು ರವರೆಗೆ ಪ್ರತಿ ಪದಕ್ಕೆ

280
00:14:49,150 --> 00:14:54,020
ನಾವು ಅಂತಿಮವಾಗಿ ಸಿ ತಲುಪಲು! = EOF, ಇದರಲ್ಲಿ
ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಕಡತ ಭೇದಿಸಿ.

281
00:14:54,020 --> 00:14:57,050
>> ಈಗ ಎರಡು ಸಂದರ್ಭಗಳಲ್ಲಿ ಅಡಿಯಲ್ಲಿ ಇವೆ
ನಾವು EOF ಹಿಟ್ ಇರಬಹುದು ಇದು.

282
00:14:57,050 --> 00:15:00,980
ದೋಷ ಇಲ್ಲದಿದ್ದರೆ ಮೊದಲ
ಕಡತ reading.

283
00:15:00,980 --> 00:15:03,470
ದೋಷವಿತ್ತು ಆದ್ದರಿಂದ, ನಾವು
ವಿಶಿಷ್ಟ ಮಾಡಬೇಕಾದ್ದು.

284
00:15:03,470 --> 00:15:06,460
ನಿಕಟ, ಎಲ್ಲವೂ ಅನ್ಲೋಡ್
ಕಡತ, ತಪ್ಪು ಹಿಂತಿರುಗಿ.

285
00:15:06,460 --> 00:15:09,810
, ದೋಷ ಇರಲಿಲ್ಲ ಭಾವಿಸಿದರೂ
ಕೇವಲ ನಾವು ವಾಸ್ತವವಾಗಿ ಕೊನೆಯಲ್ಲಿ ಹಿಟ್ ಅರ್ಥ

286
00:15:09,810 --> 00:15:13,750
ಕಡತ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮುಚ್ಚಲು
ಫೈಲ್ ಮತ್ತು ನಿಜವಾದ ಹಿಂತಿರುಗಿ ರಿಂದ ನಾವು

287
00:15:13,750 --> 00:15:17,330
ಯಶಸ್ವಿಯಾಗಿ ಲೋಡ್ ನಿಘಂಟು
ನಮ್ಮ trie ಒಳಗೆ.

288
00:15:17,330 --> 00:15:20,170
>> ಈಗ ಚೆಕ್ ಪರಿಶೀಲಿಸಿ ಅವಕಾಶ.

289
00:15:20,170 --> 00:15:25,156
ಚೆಕ್ ಕಾರ್ಯ ನೋಡುತ್ತಿರುವುದು, ನಾವು ನೋಡಿ
ಚೆಕ್ ಒಂದು bool ಮರಳಲು ಹೋಗುತ್ತದೆ.

290
00:15:25,156 --> 00:15:29,680
ಈ ಪದವು ಎಂದು ವೇಳೆ ಇದು ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ಅಂಗೀಕಾರವಾದ ನಮ್ಮ trie ಹೊಂದಿದೆ.

291
00:15:29,680 --> 00:15:32,110
ಇದು ಇಲ್ಲದಿದ್ದರೆ ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

292
00:15:32,110 --> 00:15:36,050
ಆದ್ದರಿಂದ ನೀವು ನಿರ್ಧರಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ
ಈ ಪದ ನಮ್ಮ trie ಹೊಂದಿದೆ?

293
00:15:36,050 --> 00:15:40,190
>> ನಾವು ಇಲ್ಲಿ ನೋಡಿ, ಮೊದಲಿನಂತೆ,
ನಾವು ಮರಳಿ ಕರ್ಸರ್ ಬಳಸಲು ನೀನು

294
00:15:40,190 --> 00:15:41,970
ನಮ್ಮ trie ಮೂಲಕ.

295
00:15:41,970 --> 00:15:46,600
ಈಗ ಇಲ್ಲಿ ನಾವು ತಿರುಗಿ ನೀನು
ನಮ್ಮ ಇಡೀ ಪದದ ಮೇಲೆ.

296
00:15:46,600 --> 00:15:50,620
ಆದ್ದರಿಂದ, ನಾವು ಕಳೆದ ಇವೆ ಪದ ಮೇಲೆ iterating
ನಾವು ನಿರ್ಧರಿಸಲು ನೀನು

297
00:15:50,620 --> 00:15:56,400
ಸೂಚ್ಯಂಕ ಮಕ್ಕಳು ರಚನೆಯ ಒಳಗೆ ಎಂದು
ಪದ ಬ್ರಾಕೆಟ್ ಐ ಅನುರೂಪವಾಗಿದೆ ಆದ್ದರಿಂದ ಈ

298
00:15:56,400 --> 00:15:59,670
ನಿಖರವಾಗಿ ರೀತಿ ಹೋಗುತ್ತದೆ
ಲೋಡ್, ಅಲ್ಲಿ ವೇಳೆ ಪದ [ನಾನು]

299
00:15:59,670 --> 00:16:03,310
ಅಪಾಸ್ಟ್ರಫಿ, ನಾವು ಬಯಸುವ ಇದೆ
ಸೂಚ್ಯಂಕ "ವರ್ಣಮಾಲೆ" ಬಳಸಲು - 1.

300
00:16:03,310 --> 00:16:05,350
ನಾವು ನಿರ್ಧರಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಆ
ನಾವು ಶೇಖರಿಸಿಡಲು ನೀನು ಅಲ್ಲಿ ಆಗಿದೆ

301
00:16:05,350 --> 00:16:07,100
ಅಪಾಸ್ಟ್ರಫಿಗಳನ್ನು.

302
00:16:07,100 --> 00:16:11,780
>> ಎಲ್ಸ್ ನಾವು ಎರಡು ಕಡಿಮೆ ಪದ ಬಳಸಲು ನೀನು
ಬ್ರಾಕೆಟ್ ಐ ಆ ಪದವು ರಿಮೆಂಬರ್

303
00:16:11,780 --> 00:16:13,920
ಅನಿಯಂತ್ರಿತ ಬಂಡವಾಳ ಹೊಂದಿವೆ.

304
00:16:13,920 --> 00:16:17,540
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ನಾವು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ
ವಸ್ತುಗಳ ಸಣ್ಣ ಆವೃತ್ತಿ ಬಳಸಿ.

305
00:16:17,540 --> 00:16:21,920
ಮತ್ತು ಆ 'ಒಂದು' ಗೆ ಒಮ್ಮೆ ರಿಂದ ಕಳೆಯಿರಿ
ಮತ್ತೆ ನಮಗೆ ವರ್ಣಮಾಲೆಯ ನೀಡಿ

306
00:16:21,920 --> 00:16:23,880
ಆ ಪಾತ್ರದ ಸ್ಥಾನವನ್ನು.

307
00:16:23,880 --> 00:16:27,680
ಆದ್ದರಿಂದ ನಮ್ಮ ಸೂಚ್ಯಂಕ ಎಂದು ವಿಶೇಷವೇನು
ಮಕ್ಕಳ ರಚನೆಯ ಒಳಗೆ.

308
00:16:27,680 --> 00:16:32,420
>> ಈಗ ವೇಳೆ ಮಕ್ಕಳಾದರು ಸೂಚ್ಯಂಕ
ರಚನೆಯ ಶೂನ್ಯ, ಎಂದು ನಾವು ಅರ್ಥ

309
00:16:32,420 --> 00:16:34,990
ಇನ್ನು ಮುಂದೆ iterating ಮುಂದುವರಿಸಬಹುದು
ನಮ್ಮ trie ಕೆಳಗೆ.

310
00:16:34,990 --> 00:16:38,870
ಆ ಕೇಸ್, ಈ ಪದ ಸಾಧ್ಯವಿಲ್ಲ
ಬಹುಶಃ ನಮ್ಮ trie ಎಂದು.

311
00:16:38,870 --> 00:16:42,340
ಇದು ಒಂದು ವೇಳೆ, ಆ ಕಾರಣ
ಒಂದು ಮಾರ್ಗವನ್ನು ಇಲ್ಲ ಎಂದು ಅರ್ಥ

312
00:16:42,340 --> 00:16:43,510
ಪದ ಕೆಳಗೆ.

313
00:16:43,510 --> 00:16:45,290
ಮತ್ತು ನೀವು ಶೂನ್ಯ ಎದುರಿಸಬಹುದು ಎಂದಿಗೂ.

314
00:16:45,290 --> 00:16:47,850
ಆದ್ದರಿಂದ ಶೂನ್ಯ ಎದುರಿಸುತ್ತಿದೆ, ನಾವು ತಪ್ಪು ಮರಳಲು.

315
00:16:47,850 --> 00:16:49,840
ಪದ ನಿಘಂಟಿನಲ್ಲಿ ಇಲ್ಲ.

316
00:16:49,840 --> 00:16:53,660
ಇದು ಶೂನ್ಯ ವೇಳೆ, ನಂತರ ನಾವು
iterating ಮುಂದುವರಿಸಲು ಹೋಗುವ.

317
00:16:53,660 --> 00:16:57,220
>> ನಾವು ಅಲ್ಲಿ ಕರ್ಸರ್ ಔಟ್ ನೀನು
ನಿರ್ದಿಷ್ಟ ತೋರಿಸಲು

318
00:16:57,220 --> 00:16:59,760
ಎಂದು ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ನೋಡ್.

319
00:16:59,760 --> 00:17:03,150
ನಾವು ಉದ್ದಕ್ಕೂ ಮಾಡುವ ಇರಿಸಿಕೊಳ್ಳಲು
ಇಡೀ ಪದ, ಊಹಿಸಿಕೊಂಡು

320
00:17:03,150 --> 00:17:03,950
ನಾವು ಶೂನ್ಯ ಹಿಟ್ ಎಂದಿಗೂ.

321
00:17:03,950 --> 00:17:07,220
ನಾವು ಮೂಲಕ ಪಡೆಯಲು ಸಮರ್ಥರಾದರು ಅರ್ಥ
ಇಡೀ ಪದ ಮತ್ತು ಹೇಗೆ

322
00:17:07,220 --> 00:17:08,920
ನಮ್ಮ ಪ್ರಯತ್ನ ಒಂದು ನೋಡ್.

323
00:17:08,920 --> 00:17:10,770
ಆದರೆ ನಾವು ಸಾಕಷ್ಟು ಇನ್ನೂ ಮಾಡಲಾಗುತ್ತದೆ ಇಲ್ಲ.

324
00:17:10,770 --> 00:17:12,290
>> ನಾವು ನಿಜವಾದ ಮರಳಲು ಬಯಸುವುದಿಲ್ಲ.

325
00:17:12,290 --> 00:17:14,770
ನಾವು ಕರ್ಸರ್> ಪದ ಮರಳಲು ಬಯಸುವ.

326
00:17:14,770 --> 00:17:18,980
ಮತ್ತೆ ನೆನಪು ರಿಂದ, "ಬೆಕ್ಕು" ಅಲ್ಲವೇ
ನಮ್ಮ ನಿಘಂಟು ರಲ್ಲಿ, ಮತ್ತು "ಮಹಾದುರಂತ"

327
00:17:18,980 --> 00:17:22,935
, ನಾವು ಯಶಸ್ವಿಯಾಗಿ ನಾವು ಸಿಗುತ್ತದೆ ಇದೆ
ಮೂಲಕ ಪದ "ಬೆಕ್ಕು." ಆದರೆ ಕರ್ಸರ್

328
00:17:22,935 --> 00:17:25,760
ಪದ ಸುಳ್ಳು ಮತ್ತು ಸತ್ಯವಲ್ಲ ಎಂದು.

329
00:17:25,760 --> 00:17:30,930
ನಾವು ಸೂಚಿಸಲು ಕರ್ಸರ್ ಪದ ಮರಳಲು
ಎಂಬುದನ್ನು ಈ ನೋಡ್ ವಾಸ್ತವವಾಗಿ ಒಂದು ಪದ.

330
00:17:30,930 --> 00:17:32,470
ಮತ್ತು ಚೆಕ್ ಅದು.

331
00:17:32,470 --> 00:17:34,250
>> ಆದ್ದರಿಂದ ಗಾತ್ರ ಪರಿಶೀಲಿಸಿ ಅವಕಾಶ.

332
00:17:34,250 --> 00:17:37,350
ಆದ್ದರಿಂದ ಗಾತ್ರ ಬಹಳ ಸುಲಭ ಎಂದು ಹೋಗುತ್ತದೆ
ರಿಂದ ಲೋಡ್ ನೆನಪಿಡಿ, ನಾವು ಕೋರುತ್ತೇವೆ

333
00:17:37,350 --> 00:17:41,430
ಫಾರ್ ನಿಘಂಟು ಏರಿಕೆಯ ಗಾತ್ರ
ನಾವು ಎದುರಿಸುವ ಪ್ರತಿ ಪದ.

334
00:17:41,430 --> 00:17:45,350
ಆದ್ದರಿಂದ ಗಾತ್ರ ಕೇವಲ ಹೋಗುತ್ತದೆ
ನಿಘಂಟು ಗಾತ್ರ ಮರಳಿ.

335
00:17:45,350 --> 00:17:47,390
ಮತ್ತು ಅಷ್ಟೇ.

336
00:17:47,390 --> 00:17:50,590
>> ಆದ್ದರಿಂದ ಕೊನೆಯದಾಗಿ ನಾವು ಇಳಿಸುವುದನ್ನು ಮಾಡಿದ್ದಾರೆ.

337
00:17:50,590 --> 00:17:55,100
ಆದ್ದರಿಂದ ಇಳಿಸುವುದನ್ನು, ನಾವು ಬಳಸಲು ನೀನು ಒಂದು
ವಾಸ್ತವವಾಗಿ ಎಲ್ಲಾ ಮಾಡಲು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ

338
00:17:55,100 --> 00:17:56,530
ನಮಗೆ ಕೆಲಸ.

339
00:17:56,530 --> 00:17:59,340
ಆದ್ದರಿಂದ ನಮ್ಮ ಕಾರ್ಯ ಹೋಗುತ್ತದೆ
ಖಾಲಿಮಾಡುವಿಕೆಯು ಮೇಲೆ ಎಂದು.

340
00:17:59,340 --> 00:18:01,650
ಏನು ಖಾಲಿಮಾಡುವಿಕೆಯು ಮಾಡಲು ಹೋಗುತ್ತದೆ?

341
00:18:01,650 --> 00:18:06,580
ನಾವು ಖಾಲಿಮಾಡುವಿಕೆಯು ಹೋಗುತ್ತದೆ ಇಲ್ಲಿ ನೋಡಿ
ಮಕ್ಕಳ ಎಲ್ಲಾ ಮೇಲೆ ತಿರುಗಿ

342
00:18:06,580 --> 00:18:08,410
ಈ ನಿರ್ದಿಷ್ಟ ನೋಡ್.

343
00:18:08,410 --> 00:18:11,750
ಮತ್ತು ಮಗುವಿನ ನೋಡ್ ವೇಳೆ
ಶೂನ್ಯ, ನಾವು ನೀನು

344
00:18:11,750 --> 00:18:13,730
ಮಗುವಿನ ನೋಡ್ ಇಳಿಸುವುದನ್ನು.

345
00:18:13,730 --> 00:18:18,010
>> ಆದ್ದರಿಂದ ಈ ನೀವು ಪುನರಾವರ್ತಿತವಾಗಿ ಇಳಿಸುವುದನ್ನು ಆಗಿದೆ
ನಮ್ಮ ಮಕ್ಕಳು ಎಲ್ಲಾ.

346
00:18:18,010 --> 00:18:21,080
ನಾವು ಖಚಿತವಾಗಿ ನೀವು ಒಮ್ಮೆ ನಮ್ಮ ಮಕ್ಕಳು ಎಲ್ಲಾ
ಕೆಳಗಿಳಿಸಲಾಯಿತು ಮಾಡಲಾಗಿದೆ, ನಾವು

347
00:18:21,080 --> 00:18:25,210
ನಾವೇ ಮುಕ್ತಗೊಳಿಸಲು, ಆದ್ದರಿಂದ ಮಾಡಬಹುದು
ನಾವೇ ಇಳಿಸುವುದನ್ನು.

348
00:18:25,210 --> 00:18:29,460
ಈ ಪುನರಾವರ್ತಿತವಾಗಿ ಕೆಲಸ
ಇಡೀ trie, ಇಳಿಸುವುದನ್ನು.

349
00:18:29,460 --> 00:18:32,850
ತದನಂತರ ಆ ಮಾಡಲಾಗುತ್ತದೆ ಒಮ್ಮೆ,
ನಾವು ನಿಜವಾದ ಮರಳಬಹುದು.

350
00:18:32,850 --> 00:18:34,210
ಅನ್ಲೋಡ್ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಸಾಧ್ಯವಿಲ್ಲ.

351
00:18:34,210 --> 00:18:35,710
ನಾವು ವಿಷಯಗಳನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ಮಾಡುತ್ತಿದ್ದೇವೆ.

352
00:18:35,710 --> 00:18:38,870
ಹಾಗೆ ಒಮ್ಮೆ ನಾವು ಮುಕ್ತಗೊಳಿಸಿದ ಮುಗಿಸಿದ್ದೀರಿ
ಎಲ್ಲವೂ, ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

353
00:18:38,870 --> 00:18:40,320
ಮತ್ತು ಅಷ್ಟೇ.

354
00:18:40,320 --> 00:18:41,080
ನನ್ನ ಹೆಸರು ರಾಬ್ ಆಗಿದೆ.

355
00:18:41,080 --> 00:18:42,426
ಈ ಕಾಗುಣಿತ ಆಗಿತ್ತು.

356
00:18:42,426 --> 00:18:47,830
>> [ಸಂಗೀತ]