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

2
00:00:00,530 --> 00:00:03,070
>> SPEAKER 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
Well, మేము అవసరం చూడాలని గుర్తుంచుకోవాలి
అపాస్టిఫియర్ పట్టుకోవడం తీసుకెళ్ళేవారు

8
00:00:22,540 --> 00:00:25,610
ఒక ప్రత్యేక కొంతవరకు చేస్తాడు
ఈ కార్యక్రమం అంతా కేసు.

9
00:00:25,610 --> 00:00:28,780
>> OK, ఇప్పుడు, గుర్తు ఒక
Trie వాస్తవానికి పనిచేస్తుంది.

10
00:00:28,780 --> 00:00:33,420
యొక్క మేము పదం పిల్లులు ఇండెక్సింగ్ చేస్తున్నారు అనుకోండి,
అప్పుడు మా Tri-ఇ యొక్క మూల నుండి,

11
00:00:33,420 --> 00:00:36,670
మేము పిల్లలు చూడండి చూడాలని
శ్రేణి మరియు మేము చూడండి చూడాలని

12
00:00:36,670 --> 00:00:42,250
అక్షరం అనుగుణంగా ఆ సూచిక
C. కాబట్టి ఆ సూచిక రెండు ఉంటుంది.

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
Well, పదం విపత్తు
మా నిఘంటువులో లో ఉంది, కానీ

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
విజయవంతంగా సూచికలు ద్వారా చూడండి
సి-A-T మరియు నోడ్ చేరుకోవడానికి, కానీ ఆ

26
00:01:34,880 --> 00:01:39,760
విపత్తు సంభవించింది ఎందుకంటే
సి-A-T దారిలో నోడ్స్ సృష్టించడానికి అన్ని

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
ఇది మేము మా Tri-ఇ పైన ఉంది
ద్వారా 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
పూర్తిగా జీరో.

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
iterate కర్సర్ను స్టార్
మా Tri-ఇ ద్వారా.

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
కాబట్టి తిరిగి మునుపటి p సెట్లు గుర్తు,
సి మైనస్ ఒక మాకు ఇవ్వాలని అన్నారు

77
00:04:23,090 --> 00:04:27,470
అక్షర సి యొక్క స్థానాన్ని ఉంటే
సి లేఖ A ఈ అభీష్టం

78
00:04:27,470 --> 00:04:28,770
మాకు ఇండెక్స్ సున్నా ఇస్తాయి.

79
00:04:28,770 --> 00:04:32,180
లేఖ B కోసం, ఇచ్చి
కాబట్టి మాకు ఇండెక్స్ 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
మా కర్సర్ iterate ఉంటుంది
బిడ్డకు డౌన్.

93
00:05:19,030 --> 00:05:23,390
ఇప్పుడు, ఈ తో ప్రారంభించడానికి శూన్య కాకుంటే,
అప్పుడు కర్సర్ iterate చేయవచ్చు

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
మళ్ళీ సి-A-T కోసం నోడ్స్.

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
ఈ సి అక్కడ పరిస్థితి
సి కొత్త లైన్ అక్కడ బాక్ స్లాష్ 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
మేము పాయింట్ మా కర్సర్ రీసెట్ చేయాలనుకుంటున్నారా
మళ్ళీ Tri-ఇ ప్రారంభానికి.

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
పాత్ర, కొత్త నోడ్స్ నిర్మించడానికి
మా Tri-ఇ మరియు ప్రతి పదం కోసం

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
విజయవంతంగా నిఘంటువు లోడ్
మా Tri-ఇ లోకి.

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
మేము ఇక్కడ చూసే ముందు వలె,
మేము iterate కర్సర్ ఉపయోగించడానికి వెళుతున్న

126
00:07:14,270 --> 00:07:16,010
మా Tri-ఇ ద్వారా.

127
00:07:16,010 --> 00:07:20,650
ఇప్పుడు, ఇక్కడ, మేము iterate చూడాలని
మా మొత్తం పదంపైన.

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 కొనసాగించవచ్చు
మా Tri-ఇ డౌన్.

141
00:08:09,050 --> 00:08:13,320
ఒకవేళ, ఈ పదం కాదు
బహుశా మా Tri-ఇ లో నుండి ఉంటే అది

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
మాకు, మా ఫంక్షన్ కోసం పని
Unloader అని అన్నారు.

164
00:09:33,390 --> 00:09:35,830
ఏ Unloader చేయబోవడం?

165
00:09:35,830 --> 00:09:40,640
మేము ఆ Unloader అన్నారు ఇక్కడ చూడండి
పిల్లల అన్ని వద్ద మీద iterate

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
కదలడం, కాబట్టి స్వయంగా దించుతున్న చేయవచ్చు.

171
00:09:58,830 --> 00:10:04,550
కాబట్టి ఈ పునరావృతంగా దించుతున్న ఉంటుంది
మొత్తం Tri-ఇ, మరియు ఆ ఒకసారి

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