1
00:00:00,000 --> 00:00:02,570
[Powered by Google Translate] [విభాగం 3 - అత్యంత సౌకర్యవంతమైన]

2
00:00:02,570 --> 00:00:05,070
[రాబ్ బౌడెన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:05,070 --> 00:00:07,310
>> [ఈ CS50 ఉంది. - CS50.TV]

4
00:00:07,310 --> 00:00:12,700
>> కాబట్టి మొదటి ప్రశ్న వింతగా పదాలతో కూడి ఉంది.

5
00:00:12,700 --> 00:00:17,480
GDB మీరు మరింత నిర్దిష్టంగా, ఒక కార్యక్రమం "డీబగ్", కానీ అనుమతిస్తుంది, మీరు ఏమి వీలు లేదు?

6
00:00:17,480 --> 00:00:22,590
నేను ఒక సమాధానం చేస్తాము, మరియు నేను, సరిగ్గా అంచనా లో ఏమి లేదు

7
00:00:22,590 --> 00:00:27,910
కాబట్టి నేను తరహాలో ఇది ఏదో ఊహించడం వెబ్ మీరు స్టెప్ బై స్టెప్ అనుమతిస్తుంది

8
00:00:27,910 --> 00:00:31,540
ఇది సంకర్షణ కార్యక్రమం ద్వారా వాక్ మార్పు వేరియబుల్స్, ఈ పనులను -

9
00:00:31,540 --> 00:00:34,270
ప్రధానంగా పూర్తిగా ప్రోగ్రామ్ యొక్క అమలు

10
00:00:34,270 --> 00:00:38,410
మరియు ప్రోగ్రామ్ యొక్క అమలు ఏ భాగం తనిఖీ.

11
00:00:38,410 --> 00:00:43,030
కాబట్టి ఆ లక్షణాలను మీరు విషయాలు డీబగ్ తెలియజేయండి.

12
00:00:43,030 --> 00:00:44,830
సరే.

13
00:00:44,830 --> 00:00:50,520
ఎందుకు బైనరీ శోధన వ్యూహం వేరు అవసరం లేదు?

14
00:00:50,520 --> 00:00:53,360
ఎవరు ఆ సమాధానం కోరుకుంటారు?

15
00:00:56,120 --> 00:01:00,070
[విద్యార్థి] ఇది వర్గీకరించరు ఉన్నట్లయితే అది పనిచేయదు ఎందుకంటే. >> అవును. [నవ్వు]

16
00:01:00,070 --> 00:01:04,910
అది వర్గీకరించరు అయితే, అది సగం లో విడిపోయినట్లు అసాధ్యం

17
00:01:04,910 --> 00:01:07,850
మరియు ఎడమ ఆ ప్రతిదీ తెలిసి తక్కువ మరియు కుడి ఇదేనా

18
00:01:07,850 --> 00:01:10,490
మధ్య విలువ కంటే ఎక్కువగా ఉంటుంది.

19
00:01:10,490 --> 00:01:12,790
కాబట్టి అది వేరు అవసరం.

20
00:01:12,790 --> 00:01:14,170
సరే.

21
00:01:14,170 --> 00:01:17,570
ఎందుకు స్క్వేర్డ్ n యొక్క O లో బబుల్ సార్ట్ ఉంది?

22
00:01:17,570 --> 00:01:23,230
ఎవరైనా మొదటి బబుల్ సార్ట్ సంబంధించిన ఒక శీఘ్ర ఉన్నత స్థాయి అవగాహన కల్పించేందుకు అనుకుంటుంది?

23
00:01:25,950 --> 00:01:33,020
[విద్యార్థి] మీరు ప్రాథమికంగా ప్రతి మూలకం ద్వారా వెళ్ళి మీరు మొదటి కొన్ని అంశాలను తనిఖీ.

24
00:01:33,020 --> 00:01:37,150
వారు మీరు వాటిని మార్పిడి పేరు లేదు, అప్పుడు మీరు తదుపరి కొన్ని అంశాలు మరియు మొదలైనవి తనిఖీ.

25
00:01:37,150 --> 00:01:40,770
మీరు అంత్య దశలో ఉంటాయో, అప్పుడు మీరు అతిపెద్ద మూలకం చివరిలో ఉంచుతారు తెలుసు,

26
00:01:40,770 --> 00:01:42,750
కాబట్టి మీరు ఒక మీరు ద్వారా వెళ్ళాలని కొనసాగించండి విస్మరించు

27
00:01:42,750 --> 00:01:48,490
మరియు ప్రతి మీరు ఏ మార్పులు వరకు ఒక మూలకం తక్కువ తనిఖీ చేయాలి. >> అవును.

28
00:01:48,490 --> 00:01:58,470
మీరు దాని వైపు శ్రేణి కుదుపు కాబట్టి అది పైకి మరియు ఎందుకంటే ఇది, బబుల్ సార్ట్ నిలువు అని

29
00:01:58,470 --> 00:02:03,100
అప్పుడు పెద్ద విలువలు దిగువ మునిగిపోతుంది మరియు చిన్న విలువలు అగ్ర బబుల్ అప్ రెడీ.

30
00:02:03,100 --> 00:02:05,210
అది దాని పేరు పొందింది ఎలా.

31
00:02:05,210 --> 00:02:08,220
మరియు అవును, మీరు ద్వారా వెళ్లండి.

32
00:02:08,220 --> 00:02:11,190
మీరు పెద్ద విలువ ఇచ్చిపుచ్చుకోవడంతో, అర్రే ద్వారా కొనసాగించడాన్ని

33
00:02:11,190 --> 00:02:14,040
దిగువ అతిపెద్ద విలువలు పొందడానికి.

34
00:02:14,040 --> 00:02:17,500
>> ఎందుకు అది స్క్వేర్డ్ n యొక్క O ఉంది?

35
00:02:18,690 --> 00:02:24,620
మొదటి, దాన్ని ఎవరైనా n ఓ స్క్వేర్డ్ వై చెప్పాలనుకోవడం లేదు?

36
00:02:24,620 --> 00:02:28,760
[విద్యార్థి] ప్రతి పరుగుల కోసం n సార్లు వెళుతుంది కాబట్టి.

37
00:02:28,760 --> 00:02:32,100
మీరు, మీరు డౌన్ అతిపెద్ద మూలకం అన్ని మార్గం తీసిన చేసిన అనుకోవచ్చు

38
00:02:32,100 --> 00:02:35,230
అప్పుడు మీరు అనేక అంశాలను వంటి కోసం ఆ మళ్లీ చేయాల్సిన. >> అవును.

39
00:02:35,230 --> 00:02:41,800
కాబట్టి పెద్ద O అంటే ఏ పెద్ద ఒమేగా ఏమిటి గుర్తుంచుకోండి.

40
00:02:41,800 --> 00:02:50,560
పెద్ద O నిజానికి అమలు ఎలా నెమ్మదిగా న గరిష్టంగా ఉంటుంది.

41
00:02:50,560 --> 00:02:58,990
కాబట్టి స్క్వేర్డ్ n యొక్క దాని O విధంగా, అది n యొక్క O కాదు లేదంటే అమలు చేయగలదు

42
00:02:58,990 --> 00:03:02,640
సరళ సమయంలో, కానీ n cubed ఓ ఉంటుంది

43
00:03:02,640 --> 00:03:06,390
అది n cubed ఓ హద్దుగా ఎందుకంటే.

44
00:03:06,390 --> 00:03:12,300
అది స్క్వేర్డ్ n ఓ హద్దుగా అయితే, అది n cubed ద్వారా కూడా కలిగి ఉంది.

45
00:03:12,300 --> 00:03:20,280
అది స్క్వేర్డ్ N, మరియు సంపూర్ణ విషయంలో అది స్క్వేర్డ్ n కంటే బాగా లేదు

46
00:03:20,280 --> 00:03:22,830
అది స్క్వేర్డ్ n ఓ వై ఉంది.

47
00:03:22,830 --> 00:03:31,200
కాబట్టి, అది n స్క్వేర్డ్ అని వస్తుంది ఎలా వద్ద గణిత చూడటానికి

48
00:03:31,200 --> 00:03:40,530
మేము మా జాబితాలో ఐదు అంశాలు ఉంటే, మొదటి సారి ఎన్ని మార్పిడులు మీరు సమర్థవంతంగా చేయవలసి కాలేదు

49
00:03:40,530 --> 00:03:47,170
ఈ పొందడానికి? యొక్క నిజానికి లెట్ -

50
00:03:47,170 --> 00:03:52,040
ఎన్ని మార్పిడులు మేము శ్రేణి ద్వారా బబుల్ సార్ట్ మొదటి పరుగుల చేసే పొందబోతున్నారు?

51
00:03:52,040 --> 00:03:53,540
[విద్యార్థి] n - 1. >> అవును.

52
00:03:53,540 --> 00:03:58,340
>> 1 - 5 అంశాలు ఉన్నాయి, మేము n చేయవలసి చూడాలని.

53
00:03:58,340 --> 00:04:01,100
అప్పుడు ఒక సెకను ఎన్ని మార్పిడులు మేము కలిగి వెళ్తున్నారు?

54
00:04:01,100 --> 00:04:03,440
[విద్యార్థి] n - 2. >> అవును.

55
00:04:03,440 --> 00:04:11,640
మరియు మూడవ n ఉండబోతుంది - 3, మరియు అప్పుడు సౌలభ్యం కోసం నేను గత రెండు వ్రాయడానికి ఉంటుంది

56
00:04:11,640 --> 00:04:15,270
అప్పుడు మేము 2 మార్పిడులు మరియు 1 swap చేయవలసి చూడాలని.

57
00:04:15,270 --> 00:04:19,899
నేను గత ఒకటి లేదా నిజానికి జరిగి అవసరం కాకపోవచ్చు అంచనా.

58
00:04:19,899 --> 00:04:22,820
అది స్వాప్ ఉంది? నాకు తెలీదు.

59
00:04:22,820 --> 00:04:26,490
కాబట్టి ఈ మొత్తం మార్పిడి మొత్తంలో లేదా మీరు తయారు చేసుకోవాలి కనీసం పోలిక ఉంటాయి.

60
00:04:26,490 --> 00:04:29,910
మీరు స్వాప్ లేదు, మీరు ఇప్పటికీ విలువలు పోల్చి చూడాలి.

61
00:04:29,910 --> 00:04:33,910
కాబట్టి n ఉన్నాయి - శ్రేణి ద్వారా మొదటి పరుగుల 1 పోలికలు.

62
00:04:33,910 --> 00:04:42,050
మీరు ఈ విషయాలు క్రమాన్ని ఉంటే, విషయాలు చక్కగా స్టేక్ అప్ కాబట్టి యొక్క దీన్ని ఆరు విషయాలు తయారు చేద్దాము

63
00:04:42,050 --> 00:04:44,790
మరియు నేను, 2, 1 3 చేస్తాను.

64
00:04:44,790 --> 00:04:49,910
కాబట్టి కేవలం ఈ మొత్తాలను అమర్చడానికి, మేము మేము ఎన్ని పోలికలు చూడాలనుకుంటే

65
00:04:49,910 --> 00:04:52,700
మొత్తం అల్గోరిథం లో.

66
00:04:52,700 --> 00:04:56,550
మేము డౌన్ ఇక్కడ ఈ కుర్రాళ్ళు తీసుకుని అలా అయితే,

67
00:04:56,550 --> 00:05:07,470
అప్పుడు మేము ఇప్పటికీ కేవలం ఉన్నాయి అయితే అనేక పోలికలు సంక్షిప్తం చేస్తున్నారు.

68
00:05:07,470 --> 00:05:13,280
కానీ మేము ఈ మొత్తం మరియు మేము ఈ మొత్తం మరియు మేము ఈ సంకలనం ఉంటే,

69
00:05:13,280 --> 00:05:18,130
అది ఇప్పటికీ అదే సమస్య. మేము ఆ ప్రత్యేక సంస్థల మొత్తం.

70
00:05:18,130 --> 00:05:22,400
>> కాబట్టి ఇప్పుడు మేము 3 n యొక్క సంక్షిప్తం చేస్తున్నారు. ఇది కేవలం 3 n యొక్క కాదు.

71
00:05:22,400 --> 00:05:27,650
ఇది ఎల్లప్పుడూ n / 2 n యొక్క చేస్తాడు.

72
00:05:27,650 --> 00:05:29,430
కాబట్టి ఇక్కడ 6 కలిగి పొందుతున్నారు.

73
00:05:29,430 --> 00:05:34,830
మేము 10 విషయాలు కలిగి ఉంటే, అప్పుడు మేము విషయాలను 5 వివిధ జతల కోసం ఈ గుంపు చేయగల

74
00:05:34,830 --> 00:05:37,180
మరియు n + n + n + n + n తో ముగుస్తుంది.

75
00:05:37,180 --> 00:05:45,840
మీరు ఎల్లప్పుడూ n / 2 n యొక్క పొందడానికి వెళుతున్న, అందువలన ఈ మేము n స్క్వేర్డ్ / 2 దీనిని పరిమాణం చేస్తాము.

76
00:05:45,840 --> 00:05:48,890
మరియు అందువలన వస్తాయి, ఇది సగం యొక్క అంశం, అయినా అయితే

77
00:05:48,890 --> 00:05:54,190
అర్రే పైగా ప్రతి పునరావృతం ద్వారా మేము 1 తక్కువ పోల్చి వాస్తవం కారణంగా

78
00:05:54,190 --> 00:05:58,040
కాబట్టి మేము 2 పై ఎంత, అయితే ఇప్పటికీ స్క్వేర్డ్ n.

79
00:05:58,040 --> 00:06:01,650
మేము ఒక భాగం స్థిరమైన అంశం గురించి పట్టించుకోను.

80
00:06:01,650 --> 00:06:07,760
ఈ వంటి పెద్ద O stuff చాలా గణిత ఈ విధమైన చేయడం కేవలం రకం మీద ఆధారపడి ఉంటుంది కాబట్టి,

81
00:06:07,760 --> 00:06:12,260
అంకగణితం మొత్తాలను మరియు రేఖాగణిత సిరీస్ stuff చేయడం,

82
00:06:12,260 --> 00:06:17,750
కానీ ఈ కోర్సు వాటిని చాలా అందంగా సూటిగా ఉన్నాయి.

83
00:06:17,750 --> 00:06:19,290
సరే.

84
00:06:19,290 --> 00:06:24,430
ఎందుకు చొప్పించడం విధమైన n యొక్క ఒమేగా ఉంది? ఒమేగా శతకము

85
00:06:24,430 --> 00:06:27,730
[ఒకసారి మాట్లాడుతూ రెండు విద్యార్థులు - అపారదర్శక] >> అవును.

86
00:06:27,730 --> 00:06:30,630
ఒమేగా మీరు తక్కువ కట్టుబడి వంటి యొక్క ఆలోచించవచ్చు.

87
00:06:30,630 --> 00:06:36,550
>> మీ చొప్పించడం విధమైన అల్గోరిథం ఎలా సమర్థవంతంగా ఉన్నా,

88
00:06:36,550 --> 00:06:41,810
సంబంధం లేకుండా జారీ చేసే జాబితాలో, ఇది ఎల్లప్పుడూ కనీసం n విషయాలు పోల్చడానికి ఉంది

89
00:06:41,810 --> 00:06:44,620
లేదా n విషయాలు మీద iterate ఉంటుంది.

90
00:06:44,620 --> 00:06:47,280
ఎందుకు అని?

91
00:06:47,280 --> 00:06:51,190
[విద్యార్థి] ఎందుకంటే జాబితా ఇప్పటికే క్రమబద్ధీకరించబడింది, అప్పుడు ద్వారా మొదటి పునరుక్తి

92
00:06:51,190 --> 00:06:54,080
మీరు మాత్రమే, మొట్టమొదటి మూలకం కనీసం అని హామీ

93
00:06:54,080 --> 00:06:56,490
మరియు రెండవ మళ్ళా మీరు మాత్రమే మొదటి రెండు హామీ

94
00:06:56,490 --> 00:07:00,010
మీరు జాబితా మిగిలిన క్రమబద్ధీకరించబడింది తెలియదు ఎందుకంటే. >> అవును.

95
00:07:00,010 --> 00:07:08,910
మీరు చాలా కనీసం, ఒక పూర్తిగా క్రమబద్ధీకరించబడతాయి జాబితాలో పాస్ ఉంటే మీరు అన్ని మూలకాల కంటే వెళ్ళాలి

96
00:07:08,910 --> 00:07:12,180
ఆ ఏమీ గీస్తారు అవసరం చూడటానికి.

97
00:07:12,180 --> 00:07:14,720
కాబట్టి జాబితా పై ప్రయాణిస్తున్న మరియు OH, ఈ అప్పటికే క్రమబద్ధీకరించబడింది చెప్పడం

98
00:07:14,720 --> 00:07:18,240
మీరు క్రమబద్ధీకరించబడతాయి నాకు తెలుసు మీరు ప్రతి మూలకం తనిఖీ వరకు అది అసాధ్యం

99
00:07:18,240 --> 00:07:20,660
వారు క్రమబద్ధీకరించబడతాయి క్రమంలో అని చూడటానికి.

100
00:07:20,660 --> 00:07:25,290
కాబట్టి చొప్పించడం విధమైన న కట్టుబడి తక్కువ n యొక్క ఒమేగా ఉంది.

101
00:07:25,290 --> 00:07:28,210
విషయంలో, విలీనం విధమైన సమయం అంటే నడుస్తున్న యొక్క

102
00:07:28,210 --> 00:07:31,390
విషయంలో మళ్లీ పెద్ద O ఉండటం?

103
00:07:31,390 --> 00:07:37,660
కాబట్టి చెత్త దృష్టాంతంలో, విలీనంతో విధమైన ఎలా అమలు చేస్తుంది?

104
00:07:42,170 --> 00:07:43,690
[విద్యార్థి] N log N. >> అవును.

105
00:07:43,690 --> 00:07:49,990
వేగవంతమైన సాధారణ సార్టింగ్ అల్గోరిథంలు n లాగ్ n ఉంటాయి. మీరు బాగా లేదు.

106
00:07:51,930 --> 00:07:55,130
>> అక్కడ ప్రత్యేక సందర్భాల్లో, మరియు మేము ఈ రోజు సమయం ఉంటే - కాని మేము బహుశా won't -

107
00:07:55,130 --> 00:07:59,330
మేము N log N కంటే మెరుగైన చేసే ఒక చూడవచ్చు.

108
00:07:59,330 --> 00:08:04,050
కానీ సాధారణ సందర్భంలో, మీరు n లాగ్ n కంటే బాగా లేదు.

109
00:08:04,050 --> 00:08:09,680
మరియు విలీనం విధమైన మీరు n లాగ్ n అని ఈ కోర్సు కోసం తెలుసుకోవాలి ఒకటి నిర్మాణము.

110
00:08:09,680 --> 00:08:13,260
కాబట్టి మేము నిజంగా ఆ రోజు అమలు చేయబడతాయి.

111
00:08:13,260 --> 00:08:18,070
చివరకు, no more మూడు కంటే వాక్యాలను, ఎలా ఎంపిక విధమైన పని చేస్తుంది?

112
00:08:18,070 --> 00:08:20,370
సమాధానం అనుకుంటుంది, మరియు నేను మీ వాక్యాలు కౌంట్ చేస్తాము

113
00:08:20,370 --> 00:08:22,390
ఎందుకంటే మీరు 3 వెళ్ళి ఉంటే -

114
00:08:25,530 --> 00:08:28,330
ఎవరైనా ఎంపిక విధమైన గుర్తు?

115
00:08:31,280 --> 00:08:37,809
ఎన్నిక విధమైన కేవలం పేరు నుండి గుర్తుంచుకోవడానికి సాధారణంగా చాలా సులభం.

116
00:08:37,809 --> 00:08:45,350
మీరు శ్రేణి మీద iterate, ఏ అతిపెద్ద విలువ లేదా సూక్ష్మ ఉద్యోగాలు -

117
00:08:45,350 --> 00:08:47,290
మీరు క్రమబద్ధీకరించేందుకు చేసిన ఏ క్రమంలో

118
00:08:47,290 --> 00:08:50,750
కాబట్టి యొక్క మేము చిన్న నుండి గొప్ప కు క్రమబద్ధీకరించేందుకు చేస్తున్నారు అనుకోండి అనుమతిస్తాయి.

119
00:08:50,750 --> 00:08:55,250
మీరు కనీసం మూలకం ఉండే వస్తువు కోసం చూస్తున్న, అర్రే పైగా iterate

120
00:08:55,250 --> 00:08:59,750
ఎంచుకోండి, మరియు అప్పుడు మొదటి స్థానంలో ఉంది అది స్వాప్.

121
00:08:59,750 --> 00:09:04,090
ఆపై శ్రేణి మీద రెండవ పయనంలో, మళ్ళీ కనీస మూలకం కోసం చూడండి

122
00:09:04,090 --> 00:09:07,490
ఎంచుకోండి, మరియు తరువాత రెండవ స్థానంలో ఏది తో స్వాప్.

123
00:09:07,490 --> 00:09:10,650
కాబట్టి మేము కేవలం ఎంచుకోవడం మరియు కనీస విలువలు ఎంచుకుంటున్నారు

124
00:09:10,650 --> 00:09:16,050
యెరే యొక్క ముందు వాటిని ఇన్సర్ట్ అది క్రమబద్ధీకరించబడింది వరకు.

125
00:09:19,210 --> 00:09:21,560
ఆ ప్రశ్నలకు?

126
00:09:21,560 --> 00:09:25,710
>> ఈ అనివార్యంగా మీరు pset సమర్పించడం చేసినప్పుడు పూరించడానికి కలిగి రూపాలు కనిపిస్తాయి.

127
00:09:29,010 --> 00:09:32,360
ఆ ప్రధానంగా వారికి సమాధానాలు.

128
00:09:32,360 --> 00:09:34,230
సరే, ఇప్పుడు సమస్యలు కోడింగ్.

129
00:09:34,230 --> 00:09:40,140
నేను ఇప్పటికే ఇమెయిల్ ద్వారా పంపింది - ఎవరైనా ఆ ఇమెయిల్ అందలేదా? సరే.

130
00:09:40,140 --> 00:09:46,630
నేను ఇప్పటికే, ఇమెయిల్ ద్వారా మేము ఉపయోగించి కావడం చేస్తున్న స్పేస్ పంపింది

131
00:09:46,630 --> 00:09:52,120
మీరు నా పేరు మీద క్లిక్ చేస్తే మరియు - నేను క్రింద మాత్రం థింక్ అయామ్

132
00:09:52,120 --> 00:09:57,170
ఎందుకంటే వెనుకకు r యొక్క - మీరు నా పేరు మీద క్లిక్ చేస్తే కానీ మీరు 2 కూర్పుల చూస్తారు.

133
00:09:57,170 --> 00:10:02,650
కూర్పుల 1 నేను ఇప్పటికే కాపీ మరియు Spaces కోడ్ అతికించబడతాయి అన్నారు

134
00:10:02,650 --> 00:10:06,900
శోధన విషయం కోసం మీరు అమలు చూడాలని.

135
00:10:06,900 --> 00:10:10,540
మరియు కూర్పుల 2 మేము ఆ తర్వాత అమలు చేసే విధమైన విషయం ఉంటుంది.

136
00:10:10,540 --> 00:10:15,770
కాబట్టి మీరు నా కూర్పుల 1 క్లిక్ అక్కడ నుండి పని చేయవచ్చు.

137
00:10:17,350 --> 00:10:22,060
ఇప్పుడు మేము బైనరీ శోధన అమలుచెయ్యాలని.

138
00:10:22,060 --> 00:10:26,470
>> ఎవరైనా ఒక pseudocode ఉన్నత స్థాయి వివరణ ఇవ్వాలని లేదు

139
00:10:26,470 --> 00:10:31,440
ఏమి మేము శోధన కోసం ఏమి చూడాలని? అవును.

140
00:10:31,440 --> 00:10:36,170
[విద్యార్థి] మీరు శ్రేణి మధ్యలో తీసుకుని మీరు చూస్తున్న చూడండి

141
00:10:36,170 --> 00:10:38,650
కంటే తక్కువ లేదా కంటే ఎక్కువ.

142
00:10:38,650 --> 00:10:41,080
మరియు అది తక్కువ ఉంటే, మీరు, తక్కువ అని సగం వెళ్ళండి

143
00:10:41,080 --> 00:10:44,750
అది ఇంకా ఉంటే మీరు ఇంకా సగానికి వెళ్ళి మీరు మళ్ళీ ఆ మీరు ఒక విషయం వచ్చేవరకు.

144
00:10:44,750 --> 00:10:46,570
[బౌడెన్] అవును.

145
00:10:46,570 --> 00:10:51,320
మా సంఖ్యలు శ్రేణి ఇప్పటికే క్రమబద్ధీకరించబడింది ప్రకటనలో,

146
00:10:51,320 --> 00:10:57,190
మరియు, అందువలన మేము ఆ పొందగలరు మరియు మేము మొదటి తనిఖీ అని అర్థం

147
00:10:57,190 --> 00:11:00,390
ఓకే, నేను సంఖ్య 50 చూస్తున్నాను.

148
00:11:00,390 --> 00:11:03,720
నేను మధ్యలో వెళ్ళవచ్చు.

149
00:11:03,720 --> 00:11:07,380
మధ్య, అది విషయాలను మరింత సంఖ్య ఉన్నప్పుడు పేర్కొనడానికి కష్టం

150
00:11:07,380 --> 00:11:10,820
కానీ మేము ఎల్లప్పుడూ మధ్య ఖండించు చేస్తాము సే తెలియజేయండి.

151
00:11:10,820 --> 00:11:14,420
కాబట్టి ఇక్కడ 8 విషయాలను కలిగి ఉంటాయి, కాబట్టి మధ్య 16 ఉంటుంది.

152
00:11:14,420 --> 00:11:17,330
నేను 50 చూస్తున్నాను, అలా 50 16 కంటే ఎక్కువగా ఉంటుంది.

153
00:11:17,330 --> 00:11:21,310
కాబట్టి ఇప్పుడు నేను ప్రధానంగా ఈ అంశాలు నా శ్రేణి చికిత్స చేయవచ్చు.

154
00:11:21,310 --> 00:11:23,450
నేను 16 నుండి ప్రతిదీ తీసివేసినట్లు చేయవచ్చు.

155
00:11:23,450 --> 00:11:27,440
ఇప్పుడు నా శ్రేణి కేవలం ఈ 4 అంశాలను, నేను మళ్ళీ.

156
00:11:27,440 --> 00:11:31,910
కాబట్టి అప్పుడు నేను మళ్ళీ మధ్య కావలసిన, ఇది 42 అవతరిస్తుంది.

157
00:11:31,910 --> 00:11:34,730
42 50 కంటే తక్కువ, నేను ఈ రెండు అంశాలను తీసివేసినట్లు చేయవచ్చు.

158
00:11:34,730 --> 00:11:36,890
ఈ నా మిగిలిన శ్రేణి.

159
00:11:36,890 --> 00:11:38,430
నేను మళ్ళీ మధ్య కనుగొనేందుకు వెళుతున్న.

160
00:11:38,430 --> 00:11:42,100
నేను ఎల్లప్పుడూ ఎడమ విషయాలను దూరంగా విసిరి వలన నేను, 50 ఒక చెడ్డ ఉదాహరణ ఉండిఉండవచ్చు

161
00:11:42,100 --> 00:11:48,280
కానీ అదే కొలత ద్వారా, నేను ఏదో కోసం చూస్తున్నాను

162
00:11:48,280 --> 00:11:52,100
మరియు అది, నేను ప్రస్తుతం చూస్తున్నాను మూలకం కంటే తక్కువగా

163
00:11:52,100 --> 00:11:55,080
అప్పుడు నేను ప్రతిదీ తీసివేసినట్లు వెళుతున్న.

164
00:11:55,080 --> 00:11:58,150
కాబట్టి ఇప్పుడు మేము ఆ అమలు చేయాలి.

165
00:11:58,150 --> 00:12:02,310
మేము పరిమాణం పాస్ అవసరం ఉంటుందని గమనించాలి.

166
00:12:02,310 --> 00:12:06,730
మేము కూడా హార్డ్ కోడ్ పరిమాణం అవసరం లేదు.

167
00:12:06,730 --> 00:12:11,640
మేము ఆ వదిలించుకోవటం అయితే # define -

168
00:12:19,630 --> 00:12:21,430
సరే.

169
00:12:21,430 --> 00:12:27,180
నేను చక్కగా సంఖ్యలు శ్రేణి యొక్క పరిమాణం ప్రస్తుతం ఏమిటి గుర్తించడానికి చేయవచ్చు?

170
00:12:27,180 --> 00:12:30,950
>> సంఖ్యలు శ్రేణి లో ఎన్ని అంశాలు?

171
00:12:30,950 --> 00:12:33,630
[విద్యార్థి] అంకెలు, బ్రాకెట్లలో. పొడవు?

172
00:12:33,630 --> 00:12:36,600
[బౌడెన్] C. లో ఆ లేదు

173
00:12:36,600 --> 00:12:38,580
అవసరం. పొడవు.

174
00:12:38,580 --> 00:12:42,010
వ్యూహాలను లక్షణాలు లేదు, శ్రేణుల సంఖ్య పొడవు ఆస్తి ఉంది కాబట్టి

175
00:12:42,010 --> 00:12:45,650
కేవలం అది నిర్మాణము మీరు సుదీర్ఘ ఇస్తుంది.

176
00:12:48,180 --> 00:12:51,620
[విద్యార్థి] ఇది ఎంత మెమరీ చూడండి మరియు ఎంత ద్వారా విభజించి - >> అవును.

177
00:12:51,620 --> 00:12:55,810
కాబట్టి మేము ఎలా అది ఎంత మెమరీ చూడగలరు? >> [విద్యార్థి] Sizeof. >> అవును, sizeof.

178
00:12:55,810 --> 00:13:01,680
Sizeof సంఖ్యలు శ్రేణి యొక్క పరిమాణం తిరిగి వెళుతున్న ఆ ఆపరేటర్.

179
00:13:01,680 --> 00:13:10,060
అయితే అనేక పూర్ణాంకాల చేస్తాడు ఆ సార్లు పూర్ణాంకం యొక్క పరిమాణం ఉన్నాయి

180
00:13:10,060 --> 00:13:14,050
అది నిజంగా చేపట్టడానికి ఎలా మెమరీని ల నాటినుండి.

181
00:13:14,050 --> 00:13:17,630
నేను యెరే నందలి విషయాలు సంఖ్య అనుకుంటే,

182
00:13:17,630 --> 00:13:20,560
అప్పుడు నేను ఒక పూర్ణ సంఖ్య యొక్క పరిమాణం ద్వారా విభజించడానికి కావలసిన వెళుతున్న.

183
00:13:22,820 --> 00:13:26,010
సరే. కాబట్టి నాకు ఇక్కడ పరిమాణం పాస్ అనుమతిస్తుంది.

184
00:13:26,010 --> 00:13:29,430
నేను అన్ని వద్ద పరిమాణం పాస్ చేయాలి?

185
00:13:29,430 --> 00:13:38,570
నేను కేవలం Int పరిమాణం ఇక్కడ చెయ్యలేరు = sizeof (గడ్డివాము) / sizeof (Int)?

186
00:13:38,570 --> 00:13:41,490
ఎందుకు ఈ పని లేదు?

187
00:13:41,490 --> 00:13:44,470
[విద్యార్థి] ఇది ప్రపంచ వేరియబుల్ కాదు.

188
00:13:44,470 --> 00:13:51,540
, [బౌడెన్] హేస్టాక్ ఉంది మరియు మేము గడ్డివాము వంటి సంఖ్యలు అక్కడ చేస్తున్నారు

189
00:13:51,540 --> 00:13:54,700
మరియు ఈ ఒక రావాలని ఏది సూచనకు రకం. అవును.

190
00:13:54,700 --> 00:14:00,170
[విద్యార్థి] హేస్టాక్ దానికి సూచన, కాబట్టి ఇది సూచన ఎంత పెద్ద చేరాడు.

191
00:14:00,170 --> 00:14:02,150
అవును.

192
00:14:02,150 --> 00:14:09,000
నేను మీరు నిజంగా, కుడి ఇంకా స్టాక్ చూసిన ఆ ఉపన్యాసం డౌట్?

193
00:14:09,000 --> 00:14:11,270
మేము దాని గురించి మాట్లాడే చేసాము.

194
00:14:11,270 --> 00:14:16,090
మీ వేరియబుల్స్ యొక్క అన్ని నిల్వ వెళ్లి ఇక్కడ సో స్టాక్ ఉంది.

195
00:14:16,090 --> 00:14:19,960
>> స్థానిక వేరియబుల్స్ కోసం కేటాయించబడిన చేసే ఏదైనా మెమరీ, స్టాక్ లో అన్నారు

196
00:14:19,960 --> 00:14:24,790
మరియు ప్రతి చర్య స్టాక్ దాని స్వంత స్పేస్ వస్తుంది, దాని స్వంత స్టాక్ ఫ్రేమ్ దీనిని ఏమి ఉంది.

197
00:14:24,790 --> 00:14:31,590
కాబట్టి ప్రధాన దాని స్టాక్ ఫ్రేమ్ ఉంది, మరియు లోపల ఈ సంఖ్యలు శ్రేణి ఉన్నాయి అన్నారు

198
00:14:31,590 --> 00:14:34,270
మరియు అది పరిమాణం sizeof (సంఖ్యలు) యొక్క చేస్తాడు.

199
00:14:34,270 --> 00:14:38,180
ఇది మూలకాల పరిమాణం ద్వారా విభజించబడింది సంఖ్యల పరిమాణం కలిగి జరగబోతోంది

200
00:14:38,180 --> 00:14:42,010
కానీ ప్రధాన యొక్క స్టాక్ ఫ్రేమ్ అన్ని జీవితాలను ఆ.

201
00:14:42,010 --> 00:14:45,190
మేము శోధన కాల్ చేసినప్పుడు, అన్వేషణ, దాని స్వంత స్టాక్ ఫ్రేమ్ గెట్స్

202
00:14:45,190 --> 00:14:48,840
తన సొంత స్థలం దాని స్థానిక వేరియబుల్స్ యొక్క అన్ని నిల్వ.

203
00:14:48,840 --> 00:14:56,420
కానీ ఈ వాదనలు - కాబట్టి గడ్డివాము ఈ మొత్త కాపీని కాదు.

204
00:14:56,420 --> 00:15:00,990
మేము శోధన ఒక కాపీని వంటి మొత్త లో అనుమతించబడవు.

205
00:15:00,990 --> 00:15:04,030
ఇది ఆ శ్రేణి ఒక సూచన వెళుతుంది.

206
00:15:04,030 --> 00:15:11,470
కాబట్టి శోధన ఈ సూచన ద్వారా ఈ సంఖ్యలు యాక్సెస్ చేయవచ్చు.

207
00:15:11,470 --> 00:15:17,100
ఇప్పటికీ, ప్రధాన యొక్క స్టాక్ ఫ్రేమ్ లోపలి నివసించే విషయాలు యాక్సెస్ యొక్క

208
00:15:17,100 --> 00:15:22,990
కానీ సాధారణంగా, మేము గమనికలు కు వచ్చిన, ఇది త్వరలో ఉండాలి

209
00:15:22,990 --> 00:15:24,980
ఈ గమనికలు ఉన్నాయి ఏమిటి.

210
00:15:24,980 --> 00:15:29,400
గమనికలు కేవలం విషయాలను సూచనలు ఉన్నాయి, మరియు మీరు విషయాలు ప్రాప్తి చేయడానికి గమనికలు ఉపయోగించవచ్చు

211
00:15:29,400 --> 00:15:32,030
ఇతర విషయాలు 'స్టాక్ ఫ్రేమ్లలో ఆ ఉంటాయి.

212
00:15:32,030 --> 00:15:37,660
సంఖ్యలు ప్రధాన స్థానిక అయినప్పటికీ కాబట్టి, మేము ఇప్పటికీ ఈ పాయింటర్ ద్వారా యాక్సెస్ చేయవచ్చు.

213
00:15:37,660 --> 00:15:41,770
కానీ అది కేవలం ఒక పాయింటర్ మరియు ఇది ఒక సూచన నుంచి,

214
00:15:41,770 --> 00:15:45,040
sizeof (గడ్డివాము) కేవలం సూచన యొక్క పరిమాణం తిరిగి.

215
00:15:45,040 --> 00:15:47,950
ఇది సూచించే థింగ్ యొక్క పరిమాణం తిరిగి లేదు.

216
00:15:47,950 --> 00:15:51,110
ఇది సంఖ్యల అసలు పరిమాణం తిరిగి లేదు.

217
00:15:51,110 --> 00:15:55,660
మేము దానికి కావలసిన కాబట్టి ఇది పని లేదు.

218
00:15:55,660 --> 00:15:57,320
>> ఆ ప్రశ్నలకు?

219
00:15:57,320 --> 00:16:03,250
గమనికలు వచ్చిన వారాల్లో అధిక నెత్తురు వివరాలు లోకి తొలగించబడతాయి.

220
00:16:06,750 --> 00:16:13,740
ఎందుకు మీరు చూసే విషయాలు, చాలా శోధన విషయాలు లేదా విధమైన విషయాలు చాలా, మరియు ఈ ఉంది

221
00:16:13,740 --> 00:16:16,990
వారు దాదాపు అన్ని, అర్రే యొక్క అసలు పరిమాణం తీసుకోవలసిన అవసరం చూడాలని

222
00:16:16,990 --> 00:16:20,440
సి ఎందుకంటే, మేము శ్రేణి యొక్క పరిమాణం ఏ ఆలోచన ఉంది.

223
00:16:20,440 --> 00:16:22,720
మీరు మాన్యువల్గా దీన్ని సైన్ పాస్ అవసరం

224
00:16:22,720 --> 00:16:27,190
మీరు సూచన అక్కడ ఉన్నందున మరియు మీరు మానవీయంగా మొత్త లో పూర్తి చెయ్యలేని

225
00:16:27,190 --> 00:16:30,390
మరియు అది సూచన నుండి పరిమాణాన్ని పొందలేము.

226
00:16:30,390 --> 00:16:32,300
సరే.

227
00:16:32,300 --> 00:16:38,160
కాబట్టి ఇప్పుడు మేము ముందు వివరించబడింది ఏమి అమలుచెయ్యాలని.

228
00:16:38,160 --> 00:16:41,530
మీరు, ఒక నిమిషం పనిచేయగలము

229
00:16:41,530 --> 00:16:45,250
మరియు మీరు ప్రతిదీ ఖచ్చితంగా 100% పని గురించి ఆందోళన లేదు.

230
00:16:45,250 --> 00:16:51,410
మీరు అది పని నేను భావిస్తున్నాను ఎలా సగం pseudocode అప్ వ్రాయండి.

231
00:16:52,000 --> 00:16:53,630
సరే.

232
00:16:53,630 --> 00:16:56,350
పూర్తిగా ఇంకా ఈ తో చేయాలి కాదు.

233
00:16:56,350 --> 00:17:02,380
కానీ ఎవరైనా, వారు ఇప్పటివరకు ఏం తో సుఖంగా లేదు

234
00:17:02,380 --> 00:17:05,599
ఏదో వంటి మేము కలిసి పని చేయవచ్చు?

235
00:17:05,599 --> 00:17:09,690
ఎవరైనా వెచ్చిస్తున్నారు అనుకుంటుంది? లేదా నేను యాదృచ్ఛికంగా తెలుస్తాయి.

236
00:17:12,680 --> 00:17:18,599
ఇది కుడి ఏ కొలత అయితే పని రాష్ట్రం లోకి మార్చవచ్చు దానివల్ల అని లేదు.

237
00:17:18,599 --> 00:17:20,720
[విద్యార్థి] షూర్. సరే >>.

238
00:17:20,720 --> 00:17:27,220
కాబట్టి మీరు చిన్న సేవ్ ఐకాన్ పై క్లిక్ చేసి పునర్విమర్శ సేవ్ చేయవచ్చు.

239
00:17:27,220 --> 00:17:29,950
మీరు కుడి, రమ్య ఉన్నారు? >> [విద్యార్థి] అవును. >> [బౌడెన్] సరే.

240
00:17:29,950 --> 00:17:35,140
కాబట్టి ఇప్పుడు నేను మీ పునర్విమర్శ చూడవచ్చు మరియు ప్రతి ఒక్కరూ పునర్విమర్శ పుల్ అప్ చేయవచ్చు.

241
00:17:35,140 --> 00:17:38,600
మరియు ఇక్కడ మనం - సరే.

242
00:17:38,600 --> 00:17:43,160
కాబట్టి రమ్య ఖచ్చితంగా సరైన పరిష్కారమని ఇది పునరావృత పరిష్కారం తో వెళ్ళింది.

243
00:17:43,160 --> 00:17:44,970
మీరు ఈ సమస్య చేయవచ్చు రెండు మార్గాలు ఉన్నాయి.

244
00:17:44,970 --> 00:17:48,060
మీరు పునరుక్తిలాగా లేదా పునరావృతంగా దీన్ని చెయ్యవచ్చు.

245
00:17:48,060 --> 00:17:53,860
మీరు పునరావృతంగా చేయవచ్చు ఆ ఎదుర్కునే అనేక సమస్యలు కూడా పునరుత్ధాన చేయవచ్చు.

246
00:17:53,860 --> 00:17:58,510
కాబట్టి ఇక్కడ పునరావృతంగా చేశాను.

247
00:17:58,510 --> 00:18:03,730
>> ఎవరైనా ఒక ఫంక్షన్ పునరావృత చేయడానికి అర్థం నిర్వచించే అనుకుంటుంది?

248
00:18:07,210 --> 00:18:08,920
[విద్యార్థి] మీరు ఒక ఫంక్షన్ కలిగి ఉన్నప్పుడు కూడా కాల్

249
00:18:08,920 --> 00:18:13,470
అది నిజమైన మరియు నిజమైన తో బయటకు వచ్చి వరకు మరియు తరువాత కూడా పిలుస్తారు. >> అవును.

250
00:18:13,470 --> 00:18:17,680
ఒక పునరావృత ఫంక్షన్ కేవలం స్వయంగా పిలిచే ఒక విధి.

251
00:18:17,680 --> 00:18:24,140
ఒక పునరావృత ఫంక్షన్ తప్పనిసరిగా మూడు పెద్ద అంశాలు ఉన్నాయి.

252
00:18:24,140 --> 00:18:27,310
మొదటి ఉద్దేశ్యం, దానికి పిలుస్తుంది.

253
00:18:27,310 --> 00:18:29,650
రెండవ బేస్ విషయం.

254
00:18:29,650 --> 00:18:33,390
కాబట్టి ఏదో ఒక సమయంలో ఫంక్షన్ కూడా అని పిలవడం ఆపివేయండి అవసరం

255
00:18:33,390 --> 00:18:35,610
మరియు ఆ యొక్క బేస్ కేసు ఏమిటి.

256
00:18:35,610 --> 00:18:43,860
కాబట్టి ఇక్కడ మేము ఆపడానికి అని తెలుసు, మేము మా శోధన లో ఇస్తుంది

257
00:18:43,860 --> 00:18:48,150
ప్రారంభ ముగింపు సమానం అయినప్పుడు - మరియు మేము అర్థం వాటిని వెళ్తారో.

258
00:18:48,150 --> 00:18:52,130
అయితే చివరకు, పునరావృత విధులు కోసం ముఖ్యమైన చివరి విషయం:

259
00:18:52,130 --> 00:18:59,250
విధులు ఏదో బేస్ కేసు అవలంబించే ఉండాలి.

260
00:18:59,250 --> 00:19:04,140
మీరు రెండవ పునరావృత కాల్ చేసినపుడు మీరు నిజంగా ఏదైనా నవీకరించడాన్ని కాకపోతే ఇష్టం,

261
00:19:04,140 --> 00:19:07,880
మీరు మాటప్రకారము అదే వాదనలు మళ్ళీ చర్యను కాల్ మీరు

262
00:19:07,880 --> 00:19:10,130
మరియు ప్రపంచ వేరియబుల్స్, మార్చారు లేదా ఏదైనా

263
00:19:10,130 --> 00:19:14,430
మీరు, బేస్ కేసు చేరుకోవడానికి ఎప్పుడూ ఈ సందర్భంలో ఆ దురదృష్టకరం లో.

264
00:19:14,430 --> 00:19:17,950
ఇది ఒక అనంత సూత్రం మరియు ఒక స్టాక్ ఓవర్ఫ్లో ఉంటుంది.

265
00:19:17,950 --> 00:19:24,330
కానీ ఇక్కడ మేము, మేము ప్రారంభం + ముగింపు / 2 నవీకరిస్తున్నాము నుండి నవీకరణ జరుగుతున్న ఆ చూడండి

266
00:19:24,330 --> 00:19:28,180
మేము ఇక్కడ ప్రారంభించండి వాదన అప్ డేట్ చేస్తున్నాము, ఇక్కడ చివరి వాదన అప్ డేట్ చేస్తున్నాము.

267
00:19:28,180 --> 00:19:32,860
కాబట్టి అన్ని పునరావృత కాల్స్ లో ఏదో అప్ డేట్ చేస్తున్నాము. సరే.

268
00:19:32,860 --> 00:19:38,110
మీ పరిష్కారం ద్వారా మాకు నడిచే మీరు అనుకుంటున్నారా? >> ఖచ్చితంగా.

269
00:19:38,110 --> 00:19:44,270
నేను ప్రతిసారీ నేను ఈ ఫంక్షన్ కాల్ తద్వారా SearchHelp ఉపయోగించి నేను

270
00:19:44,270 --> 00:19:47,910
నేను యెరే నందలి కోసం చూస్తున్నాను పేరు యొక్క ప్రారంభ మరియు ముగింపు కలిగి

271
00:19:47,910 --> 00:19:49,380
పేరు యొక్క నేను శ్రేణి చూస్తున్నాను.

272
00:19:49,380 --> 00:19:55,330
>> ఇది ప్రారంభ ఇది మధ్య మూలకం, + ముగింపు / 2 తెలిపారు చోట అడుగడుగునా,

273
00:19:55,330 --> 00:19:58,850
మేము చూస్తున్న సమానంగా ఉంటుంది?

274
00:19:58,850 --> 00:20:04,650
అది ఉంటే మరియు, అప్పుడు మేము దాన్ని దొరకలేదు, మరియు నేను సూత్రం యొక్క స్థాయిలు జరిగింది పొందే అంచనా.

275
00:20:04,650 --> 00:20:12,540
నిజమైన కాదు ఉంటే, అప్పుడు మేము, అర్రే ఆ మధ్య విలువ చాలా పెద్దది అని తనిఖీ

276
00:20:12,540 --> 00:20:19,320
కేసు దీనిలో మేము ప్రారంభం నుండి మధ్య ఇండెక్స్ వెళ్ళి శ్రేణి యొక్క ఎడమ అర్ధ చూడండి.

277
00:20:19,320 --> 00:20:22,710
మరియు లేకుంటే మేము చివరి సగం చేయండి.

278
00:20:22,710 --> 00:20:24,740
[బౌడెన్] సరే.

279
00:20:24,740 --> 00:20:27,730
ఆ మంచిది.

280
00:20:27,730 --> 00:20:36,640
సరే, ఒక జంట విషయాలు కాబట్టి, మరియు నిజానికి, ఈ ఒక అత్యధిక స్థాయి విషయం

281
00:20:36,640 --> 00:20:41,270
మీరు ఈ కోర్సు కోసం తెలుసుకోవాలి కాదు, కానీ నిజం.

282
00:20:41,270 --> 00:20:46,080
రికర్సివ్ విధులు, మీరు ఎల్లప్పుడూ వారు ఒక చెడ్డ ఒప్పందం అని వినడానికి

283
00:20:46,080 --> 00:20:51,160
మీరు పునరావృతంగా మీరే చాలా సార్లు కాల్, మీరు స్టాక్ ఓవర్ఫ్లో పొందండి ఎందుకంటే

284
00:20:51,160 --> 00:20:54,990
నేను ముందు అన్నాడు నుండి, ప్రతి చర్య దాని స్వంత స్టాక్ ఫ్రేమ్ పొందుతాడు.

285
00:20:54,990 --> 00:20:59,500
కాబట్టి పునరావృత ఫంక్షన్ ప్రతి కాల్ తన సొంత స్టాక్ ఫ్రేమ్ పొందుతాడు.

286
00:20:59,500 --> 00:21:04,140
మీరు 1,000 పునరావృత కాల్స్ అయితే, మీరు, 1,000 స్టాక్ ఫ్రేములు పొందండి

287
00:21:04,140 --> 00:21:08,390
మరియు త్వరగా మీరు చాలా స్టాక్ చట్రాలు మరియు విషయాలు కేవలం బ్రేక్ కలిగి దారి.

288
00:21:08,390 --> 00:21:13,480
పునరావృత విధులు సాధారణంగా చెడు ఎందుకు కాబట్టి ఆ.

289
00:21:13,480 --> 00:21:19,370
కానీ పునరావృత ఫంక్షన్ల ఒక nice ఉపసమితి, తోక పునరావృత విధులను అంటారు

290
00:21:19,370 --> 00:21:26,120
మరియు ఈ కంపైలర్ ఈ గమనిస్తాడు ఉంటే పేరు ఒక ఉదాహరణ నిర్మాణము

291
00:21:26,120 --> 00:21:29,920
మరియు అది, నేను అనుకుంటున్నాను - గణగణమని ద్వని చేయు లో మీరు-O2 జెండా పాస్ ఉంటే

292
00:21:29,920 --> 00:21:33,250
అప్పుడు ఈ తోక పునరావృత ఉంది గమనించి మరియు విషయాలు మంచి చేస్తుంది.

293
00:21:33,250 --> 00:21:40,050
>> ఇది ప్రతి పునరావృత కాల్ కోసం మళ్ళీ మరియు ద్వారా ఒకే స్టాక్ ఫ్రేమ్ తిరిగి కనిపిస్తుంది.

294
00:21:40,050 --> 00:21:47,010
మీరు అదే స్టాక్ ఫ్రేమ్ ఉపయోగించే నుండి కాబట్టి, మీరు గురించి ఆందోళన అవసరం లేదు

295
00:21:47,010 --> 00:21:51,690
మీరు ముందు చెప్పారు వంటి ఎప్పుడూ, పొంగిప్రవహిస్తున్న స్టాక్ మరియు అదే సమయంలో,

296
00:21:51,690 --> 00:21:56,380
మీరు నిజమైన తిరిగి పేరు ఒకసారి, అది ఈ స్టాక్ ఫ్రేములు మొత్తం తిరిగి ఉంది

297
00:21:56,380 --> 00:22:01,740
మరియు SearchHelp 9TH తిరిగి ఉంది 10 కాల్, 8 వ తిరిగి ఉంటుంది.

298
00:22:01,740 --> 00:22:05,360
కాబట్టి ఆ విధులు తోక పునరావృత ఉన్నప్పుడు జరిగే అవసరం లేదు.

299
00:22:05,360 --> 00:22:13,740
కాబట్టి ఈ ఫంక్షన్ తోక పునరావృత చేస్తుంది నోటీసు అని searchHelp కు ఏ కాల్ కోసం

300
00:22:13,740 --> 00:22:18,470
దీనితో చేసే పునరావృత కాల్ అది తిరిగి ఏమి ఉంది.

301
00:22:18,470 --> 00:22:25,290
కాబట్టి SearchHelp మొదటి కాల్, మేము గాని వెంటనే, తప్పుడు తిరిగి

302
00:22:25,290 --> 00:22:29,590
వెంటనే నిజమైన తిరిగి, లేదా మేము SearchHelp ఒక పునరావృత కాల్

303
00:22:29,590 --> 00:22:33,810
మనం తిరిగి చేస్తున్న కాల్ తిరిగి ఏమిటి పేరు.

304
00:22:33,810 --> 00:22:51,560
మేము Int x = SearchHelp, తిరిగి x * 2 వంటి ఏదో చేశారు ఉంటే మేము, దీన్ని కాదు

305
00:22:51,560 --> 00:22:55,440
కొన్ని యాదృచ్ఛిక మార్పు.

306
00:22:55,440 --> 00:23:01,470
>> కాబట్టి ఇప్పుడు ఈ పునరావృత కాల్, ఈ Int x = SearchHelp పునరావృత కాల్,

307
00:23:01,470 --> 00:23:05,740
నిజానికి తిరిగి కలిగి కాబట్టి తోక ఇకపై పునరావృత ఉంది

308
00:23:05,740 --> 00:23:10,400
తిరిగి మునుపటి స్టాక్ ఫ్రేమ్ తద్వారా ఫంక్షన్ ఆ మునుపటి కాల్

309
00:23:10,400 --> 00:23:13,040
అప్పుడు తిరిగి విలువ ఏదో ఒకటి చెయ్యాలి.

310
00:23:13,040 --> 00:23:22,190
కాబట్టి ఈ తోక పునరావృత కాదు, కానీ చక్కగా తోక పునరావృత ముందుగా మేము ఏ. అవును.

311
00:23:22,190 --> 00:23:27,000
[విద్యార్థి] రెండవ బేస్ కేసు మొదటి తనిఖీ కదా

312
00:23:27,000 --> 00:23:30,640
మీరు వాదన పాస్ అక్కడ పరిస్థితి ఉండవచ్చు ఎందుకంటే

313
00:23:30,640 --> 00:23:35,770
మీరు = ముగింపు ప్రారంభం, కానీ వారు సూది విలువ ఉంటాయి.

314
00:23:35,770 --> 00:23:47,310
చివరి సూది విలువ ఉన్న ప్రశ్న మేము కేసు లోకి అమలు కాదు జరిగినది

315
00:23:47,310 --> 00:23:52,000
లేదా = ముగింపు ప్రారంభం, తగిన, = ముగింపు ప్రారంభం

316
00:23:52,000 --> 00:23:59,480
మరియు మీరు నిజంగా, ఇంకా నిర్దిష్ట విలువ తనిఖీ లేదు

317
00:23:59,480 --> 00:24:03,910
అప్పుడు + ముగింపు / 2 ప్రారంభం కేవలం ఒకే విలువ అన్నారు.

318
00:24:03,910 --> 00:24:07,890
కానీ మేము ఇప్పటికే తప్పుడు తిరిగి చేసిన మరియు మేము నిజంగా విలువ తనిఖీ లేదు.

319
00:24:07,890 --> 00:24:14,240
పరిమాణం 0 ఉంటే చాలా కనీసం, మొదటి కాల్, అప్పుడు మేము తప్పుడు తిరిగి అనుకుంటున్నారా.

320
00:24:14,240 --> 00:24:17,710
పరిమాణం 1 ఉంటే మాత్రం ప్రారంభంలో, సమాన చివర వెళ్ళడం లేదు

321
00:24:17,710 --> 00:24:19,820
మరియు మేము కనీసం ఒక మూలకం తనిఖీ చేస్తాము.

322
00:24:19,820 --> 00:24:26,750
కానీ నేను, మీరు + ముగింపు / 2 ప్రారంభం మేము ఒక సందర్భంలో అవుతుంది ఆ కుడి ఉన్నాయి

323
00:24:26,750 --> 00:24:31,190
ప్రారంభ, ప్రారంభం + ముగింపు / 2 అదే ఉండటం ముగిసింది

324
00:24:31,190 --> 00:24:35,350
కానీ మేము నిజంగా ఆ మూలకం తనిఖీ లేదు.

325
00:24:35,350 --> 00:24:44,740
>> కాబట్టి మేము మొదటి తనిఖీ ఉంటే మధ్య మూలకం, మేము చూస్తున్న విలువ

326
00:24:44,740 --> 00:24:47,110
అప్పుడు మేము వెంటనే నిజమైన తిరిగి రావచ్చు.

327
00:24:47,110 --> 00:24:50,740
వారు సమాన ఉన్నారు ఎల్స్, అప్పుడు నిరంతర ఏ పాయింట్ ఉంది

328
00:24:50,740 --> 00:24:58,440
మేము ఒకే మూలకం శ్రేణి మీద ఉన్న ఒక సందర్భంలో నవీకరించడానికి వెళుతున్న నుండి.

329
00:24:58,440 --> 00:25:01,110
, ఆ సింగిల్ మూలకం మేము చూస్తున్న ఒక కాకపోతే

330
00:25:01,110 --> 00:25:03,530
అప్పుడు ప్రతిదీ తప్పు. అవును.

331
00:25:03,530 --> 00:25:08,900
[విద్యార్థి] విషయం, పరిమాణం నుండి యెరే నందలి మూలకాల సంఖ్య కంటే వాస్తవానికి పెద్ద ఉంటుంది

332
00:25:08,900 --> 00:25:13,070
ఒక ఆఫ్సెట్ ఉంది - >> కాబట్టి పరిమాణం రెడీ -

333
00:25:13,070 --> 00:25:19,380
[విద్యార్థి] అర్రే పరిమాణం 0 ఉంటే సే, అప్పుడు SearchHelp వాస్తవానికి 0 గడ్డివాము తనిఖీ చేస్తుంది

334
00:25:19,380 --> 00:25:21,490
మొదటి కాల్ న.

335
00:25:21,490 --> 00:25:25,300
>> అవును - అర్రే పరిమాణం 0 కలిగి, 0 కాబట్టి.

336
00:25:25,300 --> 00:25:30,750
మరో విషయం - ఇది మంచి కావచ్చు. అని లెట్.

337
00:25:30,750 --> 00:25:40,120
అర్రే 10 అంశాలను కలిగి మరియు మేము తనిఖీ చూడాలని మధ్య ఒక ఇండెక్స్ 5, కనుక ఉంటే

338
00:25:40,120 --> 00:25:45,700
కాబట్టి మేము 5 తనిఖీ చేస్తున్నాము, మరియు తక్కువ విలువ పేర్కొన్నారు లెట్స్.

339
00:25:45,700 --> 00:25:50,720
కాబట్టి మేము 5 నుండి దూరంగా ప్రతిదీ విసిరే చేస్తున్నారు.

340
00:25:50,720 --> 00:25:54,030
కాబట్టి ముగింపు / 2 మా కొత్త ముగింపు అన్నారు + ప్రారంభం

341
00:25:54,030 --> 00:25:57,450
అవును అలా, ఇది ఎల్లప్పుడూ శ్రేణి ముగింపు మించి ఉండడానికి జరగబోతోంది.

342
00:25:57,450 --> 00:26:03,570
అది సరి లేదా బేసి అది ఒక ఒకవేళ అదే నిజమైతే, అప్పుడు మేము, సే,, 4 తనిఖీ చేస్తాడు

343
00:26:03,570 --> 00:26:05,770
కానీ మేము ఇంకా దూరంగా విసిరి చేస్తున్నారు -

344
00:26:05,770 --> 00:26:13,500
అవును కాబట్టి, ముగింపు ఎప్పుడూ శ్రేణి యొక్క వాస్తవ చివరి ఉండని అన్నారు.

345
00:26:13,500 --> 00:26:18,350
మేము దృష్టి సారించాము అంశాలు కాబట్టి, ముగింపు ఎప్పుడూ తర్వాత ఒకటిగా అన్నారు.

346
00:26:18,350 --> 00:26:24,270
ప్రారంభ ఎప్పుడూ సమానమైన ముగింపు ఒకవేళ కాబట్టి, మేము పరిమాణం 0 యొక్క వ్యూహం ఉన్నాయి.

347
00:26:24,270 --> 00:26:35,600
>> నేను ఆలోచన ఇతర విషయం మేము మొదలవుతుంది ప్రారంభ నవీకరిస్తున్నాము + ముగింపు / 2, ఉంటుంది

348
00:26:35,600 --> 00:26:44,020
ఈ + ముగింపు / 2 ప్రారంభం నేను సమస్య నేను ఆ సందర్భంలో, ఉంది

349
00:26:44,020 --> 00:26:46,820
మేము తనిఖీ చేస్తున్నాము మూలకం ఉంది.

350
00:26:46,820 --> 00:26:58,150
లెట్ యొక్క ఈ 10-మూలకం శ్రేణి కలిగి చెప్పారు. ఏమైనప్పటికీ.

351
00:26:58,150 --> 00:27:03,250
కాబట్టి ముగింపు / 2 ఇలాంటి ఏదో అన్నారు + ప్రారంభం

352
00:27:03,250 --> 00:27:07,060
మరియు ఆ విలువను లేకుంటే, మేము అప్డేట్ అనుకుందాం.

353
00:27:07,060 --> 00:27:10,060
విలువ ఎక్కువ, కాబట్టి మేము శ్రేణి యొక్క ఈ సగం వద్ద చూడవచ్చు.

354
00:27:10,060 --> 00:27:15,910
కాబట్టి మేము ప్రారంభ అప్ డేట్ చేస్తున్నాము ఎలా, మేము ఇప్పుడు ఈ మూలకం ప్రారంభ అప్ డేట్ చేస్తున్నాము.

355
00:27:15,910 --> 00:27:23,790
కానీ ఇది ఇప్పటికీ పని చేయవచ్చు, లేదా కనీసం, మీరు ప్రారంభ చేయవచ్చు + ముగింపు / 2 + 1.

356
00:27:23,790 --> 00:27:27,850
[విద్యార్థి] మీరు + ముగింపు ప్రారంభం అవసరం లేదు [వినబడని] >> అవును.

357
00:27:27,850 --> 00:27:33,240
మేము ఇప్పటికే ఈ మూలకం తనిఖీ మరియు ఇది మేము చూస్తున్న ఒక కాదు తెలుసు ఉన్నాయి.

358
00:27:33,240 --> 00:27:36,800
కాబట్టి మేము ఈ మూలకం ప్రారంభం అప్డేట్ అవసరం లేదు.

359
00:27:36,800 --> 00:27:39,560
మేము దానిని దాటవేసి, ఈ అంశం మొదలు నవీకరించవచ్చు.

360
00:27:39,560 --> 00:27:46,060
మరియు ఒక విషయం ఎప్పుడూ ఉంది, ఈ ముగింపు అని, సే తెలియజేయండి

361
00:27:46,060 --> 00:27:53,140
ఈ ఉంటుంది కాబట్టి అప్పుడు మొదలు, + ముగింపు ప్రారంభం / 2 ఈ ఉంటుంది,

362
00:27:53,140 --> 00:28:00,580
+ ముగింపు ప్రారంభం - అవును, నేను అనంత సూత్రం లో అవుతుంది అనుకుంటున్నాను.

363
00:28:00,580 --> 00:28:12,690
అది కేవలం పరిమాణం 2 లేదా 1 పరిమాణం వ్యూహం యొక్క వ్యూహం యొక్క అనుకుందాము. నేను ఈ పని తీస్తుంది.

364
00:28:12,690 --> 00:28:19,490
కాబట్టి ప్రస్తుతం, ప్రారంభ మూలకం మరియు చివరినాటికి మించి 1 ఉంటుంది.

365
00:28:19,490 --> 00:28:24,110
కాబట్టి మేము తనిఖీ చూడాలని ఉద్దేశ్యంతో మూలకం, ఈ ఒకటి

366
00:28:24,110 --> 00:28:29,400
మరియు తర్వాత మేము ప్రారంభ అప్డేట్ చేసినప్పుడు, మేము 0 + 1/2, అని ప్రారంభ అప్ డేట్ చేస్తున్నాము

367
00:28:29,400 --> 00:28:33,160
ఇది ప్రారంభ ఈ మూలకం తో మాకు తిరిగి చివరకు అన్నారు.

368
00:28:33,160 --> 00:28:36,210
>> కాబట్టి మేము మళ్ళీ మరియు ద్వారా ఒకే మూలకం తనిఖీ చేస్తున్నాము.

369
00:28:36,210 --> 00:28:43,310
కాబట్టి ఈ ప్రతి పునరావృత కాల్ నిజానికి ఏదో అప్డేట్ చేసుకోవాలి సందర్భంలో ఉంటుంది.

370
00:28:43,310 --> 00:28:48,370
కాబట్టి మేము ఒక సందర్భంలో అక్కడ ప్రారంభ + / ముగింపు + 1, లేదంటే 2 చెయ్యాల్సిన

371
00:28:48,370 --> 00:28:50,710
అక్కడ వాస్తవానికి ప్రారంభ నవీకరించడాన్ని లేదు.

372
00:28:50,710 --> 00:28:53,820
అందరూ ఆ చూడండి?

373
00:28:53,820 --> 00:28:56,310
సరే.

374
00:28:56,310 --> 00:29:03,860
ఎవరైనా ఈ పరిష్కారం లేదా ఏ వ్యాఖ్యలు ప్రశ్నలకు కలిగి ఉందా?

375
00:29:05,220 --> 00:29:10,280
సరే. ఎవరైనా ఒక మేము అన్ని చూడవచ్చు ఆ పరిష్కారం పునరుత్థాన ఉంటాయా?

376
00:29:17,400 --> 00:29:20,940
మేము అన్ని పునరావృతంగా ఇది ఎలా చేశాడు?

377
00:29:20,940 --> 00:29:25,950
లేదా కూడా నేను ఆమె ప్రారంభించారు, అప్పుడు మీరు మీ మునుపటి భర్తీ కలిగి ఉండవచ్చు అనుకుంటున్నాను.

378
00:29:25,950 --> 00:29:28,810
అది స్వయంచాలకంగా సేవ్ చేస్తుంది? నేను మంచి కాదు.

379
00:29:35,090 --> 00:29:39,130
ఎవరైనా పునరుత్థాన ఉంటాయా?

380
00:29:39,130 --> 00:29:42,430
మేము కలిసి అది నడవడానికి ఉంటే కాదు.

381
00:29:46,080 --> 00:29:48,100
ఆలోచన ఒకే విధంగా అన్నారు.

382
00:30:00,260 --> 00:30:02,830
పరిష్కారం పునరుక్తి.

383
00:30:02,830 --> 00:30:07,140
మేము ప్రధానంగా అదే ఆలోచన చేయాలని చూడాలని

384
00:30:07,140 --> 00:30:16,530
మేము శ్రేణి యొక్క కొత్త ముగింపు ట్రాక్ మరియు యెరే యొక్క కొత్త ప్రారంభం ఉంచాలని పేరు

385
00:30:16,530 --> 00:30:18,510
మరియు ఆ పై మరియు పైగా చేయండి.

386
00:30:18,510 --> 00:30:22,430
మరియు మేము ప్రారంభ మరియు ముగింపు ఎప్పుడూ కలుస్తాయి వంటి పర్యవేక్షించడం ఏమి ఉంటే,

387
00:30:22,430 --> 00:30:29,020
అప్పుడు మేము దానిని కనుగొనేందుకు లేదు మరియు మేము తప్పుడు తిరిగి రావచ్చు.

388
00:30:29,020 --> 00:30:37,540
కాబట్టి నేను ఆ చేయాలి? ఎవరైనా టు పుల్ అప్ నాకు సలహాలు లేదా కోడ్ ఉందా?

389
00:30:42,190 --> 00:30:47,450
[విద్యార్థి] కొంత లూప్ చేయండి. >> అవును.

390
00:30:47,450 --> 00:30:49,450
మీరు ఒక లూప్ చేయాలనుకుంటున్నారా ఇస్తున్నాయి.

391
00:30:49,450 --> 00:30:51,830
>> మీరు నేను పుల్ అప్ చేయవచ్చు కోడ్ కలిగి, లేదా మీకు సూచించారు ఉండేవి?

392
00:30:51,830 --> 00:30:56,340
[విద్యార్థి] నేను అలా అనుకుంటున్నాను. >> అన్ని కుడి. ఈ విషయాలు సులభతరం చేస్తుంది. మీ పేరు ఏమిటి?

393
00:30:56,340 --> 00:30:57,890
[విద్యార్థి] లుకాస్.

394
00:31:00,140 --> 00:31:04,190
కూర్పుల 1. సరే.

395
00:31:04,190 --> 00:31:13,200
తక్కువ మేము ముందు మొదలు అని ఏమిటి.

396
00:31:13,200 --> 00:31:17,080
అప్ మేము ముందు తుది అని చాలా ఏ కాదు.

397
00:31:17,080 --> 00:31:22,750
అసలైన, ముగింపు శ్రేణి లోపల ఉంది. ఇది మేము పరిగణలోకి తీసుకోవాలని ఒక ఎలిమెంట్.

398
00:31:22,750 --> 00:31:26,890
కాబట్టి తక్కువ 0, దాదాపు శ్రేణి యొక్క పరిమాణం - 1,

399
00:31:26,890 --> 00:31:34,780
మరియు ఇప్పుడు మేము మళ్ళీ వెతికినా, మరియు మేము తనిఖీ చేస్తున్నాము -

400
00:31:34,780 --> 00:31:37,340
నేను మీరు ద్వారా నడిచే అంచనా.

401
00:31:37,340 --> 00:31:41,420
ఈ ద్వారా మీ ఆలోచన ఏమిటి? మీ కోడ్ ద్వారా మాకు వల్క్.

402
00:31:41,420 --> 00:31:49,940
[విద్యార్థి] షూర్. మధ్యలో గడ్డివాము విలువ వద్ద చూడండి మరియు సూది ను పోల్చి.

403
00:31:49,940 --> 00:31:58,520
OH, వాస్తవానికి, ఆ వెనుకకు ఉండాలి - ఇది మీ సూది కంటే ఎక్కువ ఉంటే కాబట్టి, అప్పుడు మీరు.

404
00:31:58,520 --> 00:32:05,180
మీరు కుడి సగం తీసివేసినట్లు కావలసిన చూడాలని, అందువలన అవును, అది మార్గం ఉండాలి.

405
00:32:05,180 --> 00:32:08,830
[బౌడెన్] ఈ తక్కువ ఉండాలి? మీరు చెప్పారు అంటే ఏమిటి? >> [విద్యార్థి] అవును.

406
00:32:08,830 --> 00:32:10,390
[బౌడెన్] సరే. తక్కువ.

407
00:32:10,390 --> 00:32:15,700
మనం వద్ద చూస్తున్న మేము ఏమి కంటే తక్కువగా ఉంటుంది కనుక,

408
00:32:15,700 --> 00:32:19,410
అప్పుడు అవును, మేము, ఎడమ అర్ధ తీసివేసినట్లు కావలసిన

409
00:32:19,410 --> 00:32:22,210
ఇది మనం టున్న ప్రతిదీ నవీకరిస్తున్నాము అర్థం

410
00:32:22,210 --> 00:32:26,610
యెరే యొక్క కుడి తక్కువ తరలించడం ద్వారా.

411
00:32:26,610 --> 00:32:30,130
ఈ బాగుంది.

412
00:32:30,130 --> 00:32:34,550
నేను, అది మేము ముందు చెప్పారు అదే సమస్య గురించి

413
00:32:34,550 --> 00:32:49,760
పేరు తక్కువ 0 మరియు 1 తక్కువ తర్వాత, ఉంది + అప్ / 2 మళ్లీ అదే కాదు ఏర్పాటు అన్నారు ఉంటే.

414
00:32:49,760 --> 00:32:53,860
>> ఆ సందర్భంలో లేదు అయినా, అది చాలా కనీసం మరింత సమర్థవంతంగా

415
00:32:53,860 --> 00:32:57,630
కేవలం మూలకం తీసివేసినట్లు మేము తప్పు తెలుసు ఇది చూశారు.

416
00:32:57,630 --> 00:33:03,240
కాబట్టి తక్కువ + అప్ / 2 + 1 - >> [విద్యార్థి] ఆ విధంగా ఇతర ఉండాలి.

417
00:33:03,240 --> 00:33:05,900
[బౌడెన్] లేదా ఈ ఉండాలి - 1 మరియు ఇతర ఒక + 1 ఉండాలి.

418
00:33:05,900 --> 00:33:09,580
[విద్యార్థి], డబుల్ ఉండాలి సైన్ సమానం. >> [బౌడెన్] అవును.

419
00:33:09,580 --> 00:33:11,340
[విద్యార్థి] అవును.

420
00:33:14,540 --> 00:33:15,910
సరే.

421
00:33:15,910 --> 00:33:21,280
చివరకు, ఇప్పుడు మేము ఈ + 1 కలిగి - 1 విషయం,

422
00:33:21,280 --> 00:33:31,520
ఇది - అది కాదు - అది తక్కువ అప్ ఎక్కువ విలువ కలిగిన వదులుకోవడానికి ఎప్పుడూ సాధ్యమేనా?

423
00:33:35,710 --> 00:33:40,320
సాధ్యమవుతుంది - ఏమి మాత్రమే మార్గం భావిస్తున్నారా? >> [విద్యార్థి] నాకు తెలీదు.

424
00:33:40,320 --> 00:33:45,220
కానీ కత్తిరించబడింది వచ్చి అప్పుడు మైనస్ గెట్స్ ఉంటే ఆ తర్వాత 1 మరియు - >> అవును.

425
00:33:45,220 --> 00:33:47,480
[విద్యార్థి] ఇది బహుశా గందరగోళంలో ఉంటుంది.

426
00:33:49,700 --> 00:33:53,940
నేను మాత్రమే ఎందుకంటే మంచి ఉండాలి అనుకుంటున్నాను

427
00:33:53,940 --> 00:33:58,800
ఇది తక్కువ వదులుకోవడానికి వారు సమాన ఉండాలి, నేను అనుకుంటున్నాను.

428
00:33:58,800 --> 00:34:03,070
ఒకవేళ అది సమానం అయితే, అప్పుడు మేము లేదు, అయితే లూప్ జరిగేది

429
00:34:03,070 --> 00:34:06,670
మరియు మేము విలువ తిరిగి ఉండేది. కాబట్టి మనం ఇప్పుడు మంచి భావిస్తున్నాను.

430
00:34:06,670 --> 00:34:11,530
గమనికను ఈ సమస్య ఇకపై పునరావృత ఉంది, అయినప్పటికీ

431
00:34:11,530 --> 00:34:17,400
మేము ఈ సులభంగా కూడా ఇస్తుంది ఎలా చూడవచ్చు ఆలోచనలు రకమైన దరఖాస్తు

432
00:34:17,400 --> 00:34:23,659
మేము మళ్ళీ మరియు పైగా సూచీలు అప్ డేట్ చేస్తున్నాము వాస్తవం ఒక పునరావృత పరిస్థితికి,

433
00:34:23,659 --> 00:34:29,960
మేము సమస్య చిన్నది చేస్తున్న, మేము శ్రేణి యొక్క ఉపసమితి న ధ్యేయం.

434
00:34:29,960 --> 00:34:40,860
[విద్యార్థి] తక్కువ 0 మరియు 1 ఉంటే, వారు రెండు, 0 + 1/2, 0 వెళ్ళండి ఇది ఉంటుంది

435
00:34:40,860 --> 00:34:44,429
తరువాత ఒక + 1 ఉంటుంది, ఒకరు - 1.

436
00:34:47,000 --> 00:34:50,870
[విద్యార్థి] ఎక్కడ మేము సమానత్వం తనిఖీ చేస్తున్నాము?

437
00:34:50,870 --> 00:34:55,100
మధ్య ఒక నిజానికి సూది ఉంటే నచ్చిందా?

438
00:34:55,100 --> 00:34:58,590
మేము ప్రస్తుతం ఆ చేయడం లేదు? ఓహ్!

439
00:35:00,610 --> 00:35:02,460
It's ఉంటే -

440
00:35:05,340 --> 00:35:13,740
అవును. లెట్స్ మొదటి మధ్య చెప్పడానికి మేము డౌన్ ఇక్కడ పరీక్ష లాగే కాదు -

441
00:35:13,740 --> 00:35:16,430
[విద్యార్థి] ఇది నిజానికి బౌండ్ దూరంగా వదులుకోవద్దు ఇష్టం అన్నారు.

442
00:35:16,430 --> 00:35:20,220
మీరు వెళ్ళే తీసివేసినట్లు చేస్తే, మీరు మొదటి లేదా అది తనిఖీ చేయాలి.

443
00:35:20,220 --> 00:35:23,350
ఆహ్. అవును. >> [విద్యార్థి] అవును.

444
00:35:23,350 --> 00:35:29,650
కాబట్టి ఇప్పుడు మేము, మేము ప్రస్తుతం చూశారు ఒక పారేస్తారు చేశారు

445
00:35:29,650 --> 00:35:33,260
ఇది మేము ఇప్పుడు కూడా కలిగి ఉండాలి అర్థం

446
00:35:33,260 --> 00:35:44,810
(గడ్డివాము [(తక్కువ + UP) / 2] == సూది), అప్పుడు మేము నిజమైన తిరిగి.

447
00:35:44,810 --> 00:35:52,070
మరియు నేను ఇంకా లేదా ఉంటే ఉంచారు లేదో వాచ్యంగా ఇదే అర్థం

448
00:35:52,070 --> 00:35:57,110
ఈ నిజమైన తిరిగి ఉండదు.

449
00:35:57,110 --> 00:36:01,450
కాబట్టి నేను ఇంకా ఉంటే ఉంచుతాము, కానీ అది లేదు.

450
00:36:01,450 --> 00:36:10,440
>> కాబట్టి ఎవరికి ఈ ఎల్స్ ఈ, మరియు ఈ నేను ఒక సాధారణ విషయం ఉంటే

451
00:36:10,440 --> 00:36:14,340
పేరు ప్రతిదీ ఇక్కడ మంచి సందర్భంలో అయినా,

452
00:36:14,340 --> 00:36:22,780
తక్కువ అప్ కంటే ఎక్కువ ఎన్నడూ వలె, ఇది ఆ నిజం అనే అంశంపై విలువ వాదన కాదు.

453
00:36:22,780 --> 00:36:28,010
తక్కువ కంటే తక్కువ లేదా సమానం అందువలన మీరు చెబుతాను

454
00:36:28,010 --> 00:36:30,720
లేదా తక్కువ తక్కువ ఉంది

455
00:36:30,720 --> 00:36:35,300
వారు ఎప్పుడూ సమానమైన లేదా తక్కువగా ఉంటే కనుక వెళ్తాయి ఏమవుతుంది

456
00:36:35,300 --> 00:36:40,130
అప్పుడు మేము ఈ లూప్ నుండి విరిగిపోతాయి.

457
00:36:41,410 --> 00:36:44,630
ప్రశ్నలు, ఆందోళనలు, వ్యాఖ్యలు?

458
00:36:47,080 --> 00:36:49,270
సరే. ఈ బాగుంది.

459
00:36:49,270 --> 00:36:52,230
ఇప్పుడు మేము విధమైన చేయాలనుకుంటున్నారా.

460
00:36:52,230 --> 00:37:04,030
మేము నా రెండవ పునర్విమర్శ వెళ్ళండి, మేము, ఈ అదే సంఖ్యలో చూడండి

461
00:37:04,030 --> 00:37:07,550
కానీ ఇప్పుడు అవి క్రమబద్ధీకరించబడతాయి క్రమంలో లేదు.

462
00:37:07,550 --> 00:37:12,840
మరియు మేము N log N ఓ ఏదైనా అల్గారిథమ్ ఉపయోగించి విధమైన అమలుచెయ్యాలని.

463
00:37:12,840 --> 00:37:17,240
మీరు ఇక్కడ మేము అమలు చేసే అల్గారిథమ్ కాబట్టి అనుకుంటున్నారు? >> [విద్యార్థి] విలీన విధమైన.

464
00:37:17,240 --> 00:37:23,810
[బౌడెన్] అవును. విలీనం విధమైన కాబట్టి మేము చేయబోతున్నామని ఏది, O (N log N) ఉంది.

465
00:37:23,810 --> 00:37:26,680
మరియు సమస్య, అందంగా సమానంగా అన్నారు

466
00:37:26,680 --> 00:37:31,920
ఇక్కడ సులభంగా ఒక పునరావృత పరిష్కారం కూడా ఇస్తుంది.

467
00:37:31,920 --> 00:37:35,580
మేము కావాలా మేము కూడా, ఒక పద్దతి పరిష్కారం రావచ్చు

468
00:37:35,580 --> 00:37:42,540
కానీ సూత్రం ఇక్కడ సులభంగా ఉంటుంది మరియు మేము సూత్రం చెయ్యాలి.

469
00:37:45,120 --> 00:37:49,530
నేను, మేము మొదటి విలీనంతో విధమైన ద్వారా నడిచే ఊహించడం

470
00:37:49,530 --> 00:37:54,280
విలీనంతో విధమైన ఒక మనోహరమైన వీడియో ఇప్పటికే ఉన్నాయి. [నవ్వు]

471
00:37:54,280 --> 00:37:59,780
కాబట్టి ఉన్నాయి విధమైన విలీనం - నేను ఈ పేపర్ చాలా వృధా చేస్తున్నాను.

472
00:37:59,780 --> 00:38:02,080
ఓహ్, కేవలం ఒక ఎడమ ఉంది.

473
00:38:02,080 --> 00:38:03,630
కాబట్టి విలీనం.

474
00:38:08,190 --> 00:38:12,470
ఓహ్, 1, 3, 5.

475
00:38:26,090 --> 00:38:27,440
సరే.

476
00:38:29,910 --> 00:38:33,460
విలీన రెండు ప్రత్యేక శ్రేణుల పడుతుంది.

477
00:38:33,460 --> 00:38:36,780
వ్యక్తిగతంగా ఆ రెండు శ్రేణుల క్రమబద్ధీకరించబడతాయి రెండు.

478
00:38:36,780 --> 00:38:40,970
కాబట్టి ఈ శ్రేణి, 1, 3, 5, క్రమబద్ధీకరించబడింది. ఈ శ్రేణి, 0, 2, 4, క్రమబద్ధీకరించబడింది.

479
00:38:40,970 --> 00:38:46,710
ఇప్పుడు ఏమి విలీనంతో చెయ్యాలి కూడా విభజిస్తారు ఏకైక శ్రేణి వాటిని మిళితం ఉంది.

480
00:38:46,710 --> 00:38:57,130
కాబట్టి మనం లోపల ఈ మూలకాలు అన్నారు ఆ పరిమాణం 6 యొక్క వ్యూహం కావలసిన

481
00:38:57,130 --> 00:38:59,390
క్రమబద్ధీకరించబడింది క్రమంలో.

482
00:38:59,390 --> 00:39:03,390
>> కాబట్టి మేము ఈ రెండు శ్రేణుల క్రమబద్ధీకరించబడతాయి వాస్తవం పొందగలరు

483
00:39:03,390 --> 00:39:06,800
సరళ సమయంలో ఇది చేయటానికి,

484
00:39:06,800 --> 00:39:13,510
సరళ సమయం అర్థం ఈ అర్రే పరిమాణం x మరియు ఈ పరిమాణం Y ఉంటే,

485
00:39:13,510 --> 00:39:20,970
అప్పుడు మొత్తం అల్గోరిథం O (x + y) ఉండాలి. సరే.

486
00:39:20,970 --> 00:39:23,150
సూచనలు కాబట్టి.

487
00:39:23,150 --> 00:39:26,030
[విద్యార్థి] మేము ఎడమ నుండి ప్రారంభిస్తారా?

488
00:39:26,030 --> 00:39:30,150
కాబట్టి మీరు డౌన్ మరియు తర్వాత 1 0 ఉంచుతాము మరియు ఇక్కడ మీరు 2 వద్ద ఉన్నారు.

489
00:39:30,150 --> 00:39:33,320
కాబట్టి మీరు కుడి కదిలే ఒక టాబ్ ఉన్నట్లు యొక్క ఉంటాము. >> [బౌడెన్] అవును.

490
00:39:33,320 --> 00:39:41,070
మేము కేవలం ఎడమవైపున మూలకం దృష్టి ఉంటే ఈ శ్రేణుల యొక్క రెండు కోసం.

491
00:39:41,070 --> 00:39:43,530
రెండు శ్రేణుల క్రమబద్ధీకరించబడతాయి ఎందుకంటే, మేము తెలిసిన ఈ 2 అంశాలు

492
00:39:43,530 --> 00:39:46,920
గాని యెరే నందలి చిన్న అంశాలు.

493
00:39:46,920 --> 00:39:53,500
కాబట్టి ఆ 2 అంశాల 1 మా విలీనమైన యెరే నందలి చిన్న మూలకం ఉండాలి అర్థం.

494
00:39:53,500 --> 00:39:58,190
ఇది కేవలం కాబట్టి చిన్న కుడి ఈ సమయం ఒకటి ఇలా జరిగింది.

495
00:39:58,190 --> 00:40:02,580
0 1 కన్నా తక్కువ ఎందుకంటే కాబట్టి మేము, 0 పడుతుంది ఎడమవైపు అది ఇన్సర్ట్

496
00:40:02,580 --> 00:40:08,210
కాబట్టి, 0 తీసుకోవాలని మా మొదటి స్థానం ఇన్సర్ట్, మరియు అప్పుడు మేము ఈ నవీకరణ

497
00:40:08,210 --> 00:40:12,070
ఇప్పుడు మొదటి మూలకం దృష్టి పెట్టడానికి.

498
00:40:12,070 --> 00:40:14,570
ఇప్పుడు మేము మళ్ళీ.

499
00:40:14,570 --> 00:40:20,670
కాబట్టి ఇప్పుడు మేము 2 పోల్చి మరియు 1. 1 చిన్న, కాబట్టి మేము 1 ఇన్సర్ట్ చేస్తాము.

500
00:40:20,670 --> 00:40:25,300
మేము ఈ గై సూచించడానికి ఈ పాయింటర్ నవీకరించండి.

501
00:40:25,300 --> 00:40:33,160
ఇప్పుడు మేము మళ్ళీ దాన్ని, 2 కాబట్టి. ఈ అప్డేట్ ఈ 2, 3 పోల్చి కనిపిస్తుంది.

502
00:40:33,160 --> 00:40:37,770
ఈ నవీకరణలను, 4 మరియు 5.

503
00:40:37,770 --> 00:40:42,110
కాబట్టి ఆ కలిసిపోయినా.

504
00:40:42,110 --> 00:40:49,010
>> ఇది మేము ఒకసారి ప్రతి మూలకం అంతటా వెళ్ళి నుండి ఇది దీర్ఘ సమయం అని చాలా స్పష్టమైన ఉండాలి.

505
00:40:49,010 --> 00:40:55,980
మరియు ఆ విధమైన విలీనంతో ఈ చేస్తోంది అమలు అతిపెద్ద అడుగు.

506
00:40:55,980 --> 00:40:59,330
మరియు ఆ హార్డు కాదు.

507
00:40:59,330 --> 00:41:15,020
గురించి ఆందోళన రెండు విషయాలు లెట్స్ మేము 1, 2, 3, 4, 5, 6 విలీనం తెలిపారు ఉంది.

508
00:41:15,020 --> 00:41:30,930
ఈ సందర్భంలో మనం, ఈ ఒక చిన్న మాత్రం కౌంటీ సందర్భంలో ముగుస్తుంది

509
00:41:30,930 --> 00:41:36,160
అప్పుడు మేము ఈ పాయింటర్ నవీకరించండి ఈ ఒక చిన్న అన్నారు, ఈ నవీకరణ,

510
00:41:36,160 --> 00:41:41,280
ఈ ఒక చిన్న, మరియు ఇప్పుడు మీరు గుర్తించి కలిగి

511
00:41:41,280 --> 00:41:44,220
మీరు నిజంగా తో పోల్చి అంశాల రన్నవుట్ చేసినప్పుడు.

512
00:41:44,220 --> 00:41:49,400
మేము ఇప్పటికే ఈ మొత్త ఉపయోగించారు కాబట్టి,

513
00:41:49,400 --> 00:41:55,190
ఈ శ్రేణి లో ప్రతిదీ ఇప్పుడు కేవలం ఇక్కడ చేర్చబడుతుంది.

514
00:41:55,190 --> 00:42:02,040
మనం మా శ్రేణుల యొక్క ఒక పూర్తిగా ఇప్పటికే విలీనం కౌంటీ స్థానం, ఆకస్మికంగా అయితే

515
00:42:02,040 --> 00:42:06,510
అప్పుడు మేము ఇతర శ్రేణి యొక్క అన్ని మూలకాలను తీసుకొని శ్రేణి ముగింపు వాటిని ఇన్సర్ట్.

516
00:42:06,510 --> 00:42:13,630
కాబట్టి, మనం కేవలం 5, 6 4 ఇన్సర్ట్ చేయవచ్చు. సరే.

517
00:42:13,630 --> 00:42:18,070
ఆ టు వాచ్ అవుట్ ఫర్ ఒక విషయం ఉంది.

518
00:42:22,080 --> 00:42:26,120
ఆ దశ 1 ఉండాలి అమలు.

519
00:42:26,120 --> 00:42:32,600
విలీనం మీద ఆధారపడి తర్వాత క్రమం, ఇది 2 దశలు, 2 వెర్రి దశలను ఉంది.

520
00:42:38,800 --> 00:42:42,090
లెట్ యొక్క ఈ శ్రేణి ఇస్తుంది.

521
00:42:57,920 --> 00:43:05,680
కాబట్టి విధమైన విలీనం, స్టెప్ 1 పునరావృతంగా భాగాలుగా విడదీస్తుంది శ్రేణి అధిగమించడానికి ప్రయత్నిస్తారు.

522
00:43:05,680 --> 00:43:09,350
కాబట్టి భాగాలుగా ఈ శ్రేణి విడిపోయారు.

523
00:43:09,350 --> 00:43:22,920
మేము ఇప్పుడు 4, 15, 16, 50 మరియు 8, 23, 42, 108 ఉన్నాయి.

524
00:43:22,920 --> 00:43:25,800
ఇప్పుడు మేము మళ్ళీ దీన్ని మేము భాగాలుగా ఈ విడిపోయారు.

525
00:43:25,800 --> 00:43:27,530
నేను ఈ సైడ్ లో లాగే ఉంటుంది.

526
00:43:27,530 --> 00:43:34,790
50, 4, 15 మరియు 16 కాబట్టి.

527
00:43:34,790 --> 00:43:37,440
మేము ఇక్కడ పైగా ఇదే అవుతుంది.

528
00:43:37,440 --> 00:43:40,340
ఇప్పుడు మేము మళ్ళీ భాగాలుగా విడదీస్తుంది అది విడిపోయింది.

529
00:43:40,340 --> 00:43:51,080
మరియు మేము 4, 15, 16, 50 ఉంటాయి.

530
00:43:51,080 --> 00:43:53,170
కాబట్టి మా బేస్ విషయం.

531
00:43:53,170 --> 00:44:00,540
శ్రేణుల 1 పరిమాణం ఒకసారి, అప్పుడు మేము భాగాలుగా విభజించడం తో ఆపడానికి.

532
00:44:00,540 --> 00:44:03,190
>> ఇప్పుడు మేము ఈ తో ఏమి చేస్తారు?

533
00:44:03,190 --> 00:44:15,730
మేము ఈ కూడా 8, 23, 42, మరియు 108 లో విచ్ఛిన్నం ముగుస్తుంది.

534
00:44:15,730 --> 00:44:24,000
కాబట్టి ఇప్పుడు మేము ఈ సమయంలో ఉన్నట్లు, ఇప్పుడు విలీనంతో విధమైన రెండు కేవలం జాబితాలకు జతల విలీనం ఉంది అడుగు.

535
00:44:24,000 --> 00:44:27,610
కాబట్టి మేము ఈ విలీనం చేయాలనుకుంటున్నాను. మేము విలీనం కాల్.

536
00:44:27,610 --> 00:44:31,410
మేము విలీనంతో క్రమబద్ధీకరించబడతాయి క్రమంలో ఈ తిరిగి తెలుసు.

537
00:44:31,410 --> 00:44:33,920
4, 15.

538
00:44:33,920 --> 00:44:41,440
ఇప్పుడు మేము ఈ విలీనం చేయాలనుకుంటున్నాను, మరియు ఆ, క్రమబద్ధీకరించబడింది క్రమంలో ఆ ఒక జాబితా చూపిస్తుంది

539
00:44:41,440 --> 00:44:44,160
16, 50.

540
00:44:44,160 --> 00:44:57,380
మేము ఆ విలీనం - నేను రాయలేదు - 8, 23 మరియు 42, 108.

541
00:44:57,380 --> 00:45:02,890
కాబట్టి మేము ఒకసారి విలీనమైన జతల.

542
00:45:02,890 --> 00:45:05,140
ఇప్పుడు మేము మళ్ళీ విలీనం.

543
00:45:05,140 --> 00:45:10,130
స్వయంగా ఈ జాబితాలు ప్రతి క్రమబద్ధీకరించబడింది ప్రకటనలో,

544
00:45:10,130 --> 00:45:15,220
మరియు తర్వాత మేము విభజించబడే పరిమాణం 4 జాబితాను పొందడానికి ఈ జాబితాలు విలీనం చెయ్యగలరు

545
00:45:15,220 --> 00:45:19,990
మరియు క్రమబద్ధీకరించబడింది ఆ పరిమాణం 4 జాబితాను పొందడానికి ఈ రెండు జాబితాలు విలీనం.

546
00:45:19,990 --> 00:45:25,710
చివరకు, మేము క్రమబద్ధీకరించబడింది ఆ పరిమాణం 8 ఒకటి జాబితా పొందడానికి పరిమాణం 4 యొక్క ఆ రెండు జాబితాలు విలీనం చెయ్యగలరు.

547
00:45:25,710 --> 00:45:34,030
కాబట్టి ఈ మొత్తం N log N ఉందని, ఇప్పటికే విలీనంతో సరళ అని చూసింది,

548
00:45:34,030 --> 00:45:40,390
కాబట్టి మేము అలా విలీనంతో మొత్తం ధర వంటి, ఈ విలీనం వ్యవహరించే చేస్తున్నారు

549
00:45:40,390 --> 00:45:43,410
ఈ రెండు జాబితాలు కేవలం 2 ఎందుకనగా -

550
00:45:43,410 --> 00:45:49,610
లేదా సరే, n యొక్క O, కానీ ఇక్కడ n కేవలం ఈ 2 అంశాలు, కాబట్టి అది 2 ఉంది.

551
00:45:49,610 --> 00:45:52,850
మరియు, ఈ 2 2 ఉంటుంది మరియు ఈ 2 2 ఉంటుంది మరియు ఈ 2 2 ఉంటుంది

552
00:45:52,850 --> 00:45:58,820
అందువలన నాకు అవసరమైన విలీనం అంతటా, మేము n చేయడం ముగుస్తుంది.

553
00:45:58,820 --> 00:46:03,210
2 ఇలా + 2 + 2 + 2 n ఇది 8, ఉంది

554
00:46:03,210 --> 00:46:08,060
ఈ సెట్ లో విలీనం ఖర్చు n.

555
00:46:08,060 --> 00:46:10,810
మరియు ఇక్కడ అదే విషయం.

556
00:46:10,810 --> 00:46:16,980
మేము ఈ 2, ఈ 2 విలీనం చేస్తాము, మరియు వ్యక్తిగతంగా ఈ విలీనంతో, నాలుగు కార్యకలాపాలు పడుతుంది

557
00:46:16,980 --> 00:46:23,610
ఈ విలీనంతో, ఈ అన్ని మధ్య మరోసారి నాలుగు కార్యకలాపాలు పడుతుంది, కానీ

558
00:46:23,610 --> 00:46:29,030
మేము విలీనం n మొత్తం విషయాలు ముగుస్తుంది, కాబట్టి ఈ దశలో n పడుతుంది.

559
00:46:29,030 --> 00:46:33,670
కాబట్టి ప్రతి స్థాయి విలీనం జరిగింది n మూలకాలు పడుతుంది.

560
00:46:33,670 --> 00:46:36,110
>> మరియు ఎన్ని స్థాయిలు ఉన్నాయి?

561
00:46:36,110 --> 00:46:40,160
ప్రతి స్థాయిలో, మా అర్రే పరిమాణం 2 పెరుగుతుంది.

562
00:46:40,160 --> 00:46:44,590
ఇక్కడ మా శ్రేణుల 1 పరిమాణం ఉంటాయి, ఇక్కడ వారు పరిమాణం 2 యొక్క ఉన్నాము, ఇక్కడ వారు, పరిమాణం 4 యొక్క ఉన్నారు

563
00:46:44,590 --> 00:46:46,470
చివరకు, వారు పరిమాణం 8 యొక్క ఉన్నారు.

564
00:46:46,470 --> 00:46:56,450
ఇది రెట్టింపు ఉంటుంది కాబట్టి నుండి, లాగ్ యొక్క n ఈ స్థాయిలు మొత్తం ఉన్నట్లు వెళ్తున్నారు.

565
00:46:56,450 --> 00:47:02,090
కాబట్టి లాగ్ n స్థాయిలు, ప్రతి వ్యక్తి స్థాయి తీసుకొని n మొత్తం కార్యకలాపాలను,

566
00:47:02,090 --> 00:47:05,720
మేము ఒక n లాగ్ n అల్గోరిథం పొందండి.

567
00:47:05,720 --> 00:47:07,790
ప్రశ్నలు?

568
00:47:08,940 --> 00:47:13,320
ప్రజలు ఇప్పటికే ఈ అమలు ఎలా కృషి చేస్తున్నాయి?

569
00:47:13,320 --> 00:47:18,260
నేను వారి కోడ్ పుల్ అప్ చేయవచ్చు పేరు ఇప్పటికే రాష్ట్రంలో ఎవరైనా ఉంది?

570
00:47:20,320 --> 00:47:22,260
నేను ఒక నిమిషం ఇస్తుంది.

571
00:47:24,770 --> 00:47:27,470
ఈ ఒక పొడవుగా అన్నారు.

572
00:47:27,470 --> 00:47:28,730
నేను ఎక్కువగా పునరావృతమయ్యే సిఫార్సు -

573
00:47:28,730 --> 00:47:30,510
మీరు విలీనంతో కోసం సూత్రం చేయడానికి లేదు

574
00:47:30,510 --> 00:47:33,750
విలీనంతో కోసం సూత్రం చేయడానికి ఎందుకంటే, మీరు వివిధ పరిమాణాల కొంత పాస్ చూడాలని.

575
00:47:33,750 --> 00:47:37,150
మీరు, కానీ బాధించే ఉంది.

576
00:47:37,150 --> 00:47:43,720
కానీ విధమైన మాత్రమే సూత్రం చాలా సులభం.

577
00:47:43,720 --> 00:47:49,190
మీరు వాచ్యంగా కుడి అర్ధభాగంలో విధమైన, ఎడమ అర్ధభాగంలో విధమైన కాల్. సరే.

578
00:47:51,770 --> 00:47:54,860
ఎవరైనా నేను ఇంకా పుల్ అప్ చేయవచ్చు ఏదైనా ఉందా?

579
00:47:54,860 --> 00:47:57,540
లేకపోతే నేను ఒక నిమిషం ఇస్తాము.

580
00:47:58,210 --> 00:47:59,900
సరే.

581
00:47:59,900 --> 00:48:02,970
ఎవరైనా మేము పని చేయవచ్చు ఏదైనా కలిగి?

582
00:48:05,450 --> 00:48:09,680
లేకపోతే మేము ఈ పని మరియు తరువాత నుండి విస్తరణ చేస్తాము.

583
00:48:09,680 --> 00:48:14,050
>> ఎవరైనా నేను పుల్ అప్ చేయవచ్చు ఈ కంటే ఎక్కువ?

584
00:48:14,050 --> 00:48:17,770
[విద్యార్థి] అవును. మీరు గని పుల్ అప్ చేయవచ్చు. >> అన్ని కుడి.

585
00:48:17,770 --> 00:48:19,730
అవును!

586
00:48:22,170 --> 00:48:25,280
[విద్యార్థి] పరిస్థితులు చాలా ఉన్నాయి. >> ఓహ్, కాలుస్తారు. మీరు కెన్ -

587
00:48:25,280 --> 00:48:28,110
[విద్యార్థి] నేను సేవ్ ఉంటుంది. >> అవును.

588
00:48:32,420 --> 00:48:35,730
కాబట్టి మేము విడిగా విలీనంతో చేయలేదని చెప్పారు.

589
00:48:35,730 --> 00:48:38,570
ఓహ్, కానీ ఆ చెడ్డ కాదు.

590
00:48:39,790 --> 00:48:41,650
సరే.

591
00:48:41,650 --> 00:48:47,080
కాబట్టి విధమైన కేవలం mergeSortHelp కాల్ ఉంటుంది.

592
00:48:47,080 --> 00:48:49,530
MergeSortHelp ఏమి మాకు వివరించండి.

593
00:48:49,530 --> 00:48:55,700
[విద్యార్థి] MergeSortHelp చాలా చక్కని రెండు ప్రధాన చర్యలను చేస్తుంది,

594
00:48:55,700 --> 00:49:01,270
ఇది శ్రేణిని ప్రతి అర్ధ క్రమం, తరువాత అవి రెండూ విలీనం చేయడం.

595
00:49:04,960 --> 00:49:08,050
[బౌడెన్] సరే, నాకు రెండవ ఇస్తాయి.

596
00:49:10,850 --> 00:49:13,210
నేను ఈ ఆలోచన - >> [విద్యార్థి] నేను అవసరం -

597
00:49:17,100 --> 00:49:19,400
అవును. నేను ఏదో మిస్ చేస్తున్నాను.

598
00:49:19,400 --> 00:49:23,100
విలీనంతో లో, నేను ఒక కొత్త శ్రేణి సృష్టించాలి గుర్తించలేరు

599
00:49:23,100 --> 00:49:26,530
నేను స్థానంలో దీనిని ఎందుకంటే. >> అవును. మీరు కాదు. సరిదిద్దండి.

600
00:49:26,530 --> 00:49:28,170
[విద్యార్థి] నేను ఒక కొత్త శ్రేణి సృష్టించండి.

601
00:49:28,170 --> 00:49:31,510
నేను తిరిగి మార్చడానికి విలీనం చివరిలో మర్చిపోయాను.

602
00:49:31,510 --> 00:49:34,490
సరే. మేము ఒక కొత్త శ్రేణి అవసరం.

603
00:49:34,490 --> 00:49:41,000
విలీనంతో విధమైన లో, ఈ ఎల్లప్పుడూ నిజం.

604
00:49:41,000 --> 00:49:44,340
ఒక మంచి అల్గోరిథం సమయం వారీగా ఖర్చు పార్ట్

605
00:49:44,340 --> 00:49:47,310
దాదాపు బిట్ మరింత మెమరీ ఉపయోగించడానికి అవసరం ఉంది.

606
00:49:47,310 --> 00:49:51,570
ఇక్కడ, మీరు ఎలా ఉన్నా విధమైన విలీనం,

607
00:49:51,570 --> 00:49:54,780
మీరు అనివార్యంగా కొన్ని అదనపు మెమరీ ఉపయోగించడం అవసరం.

608
00:49:54,780 --> 00:49:58,240
అతను లేదా ఆమె ఒక కొత్త శ్రేణి సృష్టించింది.

609
00:49:58,240 --> 00:50:03,400
ఆపై మీరు చివరిలో మేము అసలు శ్రేణి లోకి కొత్త శ్రేణి కాపీ అవసరం చెప్పారు.

610
00:50:03,400 --> 00:50:04,830
[విద్యార్థి] అవును, అలా అనుకుంటున్నాను.

611
00:50:04,830 --> 00:50:08,210
సూచన లేదా ఎలాగైనా ద్వారా లెక్కింపు పరంగా పనిచేస్తున్న నాకు తెలీదు -

612
00:50:08,210 --> 00:50:11,650
అవును, అది పని చేస్తుంది. >> [విద్యార్థి] సరే.

613
00:50:20,620 --> 00:50:24,480
మీరు ఈ నడుస్తున్న ప్రయత్నించండి తెలుసా? >> [విద్యార్థి] కాదు, ఇంకా. సరే >>.

614
00:50:24,480 --> 00:50:28,880
అది నడుస్తున్న ప్రయత్నించండి, మరియు నేను రెండో దాని గురించి మాట్లాడదాము.

615
00:50:28,880 --> 00:50:35,200
[విద్యార్థి] నేను, అయితే, అన్ని ఫంక్షన్ నమూనాలను మరియు ప్రతిదీ కలిగి ఉండాలి?

616
00:50:37,640 --> 00:50:40,840
ఫంక్షన్ నమూనాలను. అవును - ఓహ్, మీరు వంటి అర్థం.

617
00:50:40,840 --> 00:50:43,040
క్రమీకరించు mergeSortHelp కాల్ చేస్తోంది.

618
00:50:43,040 --> 00:50:47,390
>> కాబట్టి విధమైన mergeSortHelp కాల్ విధంగా, mergeSortHelp గాని నిర్వచించిన ఉండాలి

619
00:50:47,390 --> 00:50:56,370
విధమైన ముందు లేదా మేము నమూనా కేవలం అవసరం. కాపీ మరియు పేస్ట్ చెయ్యండి.

620
00:50:56,370 --> 00:50:59,490
మరియు అలాగే, mergeSortHelp, విలీనం కాల్

621
00:50:59,490 --> 00:51:03,830
కానీ విలీనంతో ఇంకా నిర్వచించబడింది, అందుచే మేము mergeSortHelp మాకు తెలియజేయవచ్చు

622
00:51:03,830 --> 00:51:08,700
ఆ యొక్క విలీనం ఏమి ఎలా అన్నారు, మరియు ఆ ఆ ఆ.

623
00:51:09,950 --> 00:51:15,730
MergeSortHelp కాబట్టి.

624
00:51:22,770 --> 00:51:32,660
మేము ఏ ఆధారం సందర్భాన్ని మనం ఇక్కడ ఒక సమస్య ఉంది.

625
00:51:32,660 --> 00:51:38,110
MergeSortHelp పునరావృత, కాబట్టి ఏ పునరావృత ఫంక్షన్

626
00:51:38,110 --> 00:51:42,610
పునరావృతంగా కూడా అని పిలవడం ఆపివేయండి అని తెలుసుకోవడానికి బేస్ కేసు విధమైన అవసరం అన్నారు.

627
00:51:42,610 --> 00:51:45,590
మా బేస్ కేసు ఇక్కడ ఏమి జరుగుతుందో? అవును.

628
00:51:45,590 --> 00:51:49,110
[విద్యార్థి] పరిమాణం 1 ఉంటే? >> [బౌడెన్] అవును.

629
00:51:49,110 --> 00:51:56,220
మేము అక్కడే చూసిన కాబట్టి వంటి మేము విడిపోవటం శ్రేణుల ఆగిపోయింది

630
00:51:56,220 --> 00:52:01,850
ఒకసారి మేము అనివార్యంగా తాము క్రమబద్ధీకరించబడతాయి ఇది పరిమాణం 1, వ్యూహాలను లోకి వచ్చింది.

631
00:52:01,850 --> 00:52:09,530
పరిమాణం 1 సమానం చేస్తే, మేము, అర్రే ఇప్పటికే క్రమబద్ధీకరించబడింది తెలుసు

632
00:52:09,530 --> 00:52:12,970
కాబట్టి మేము కేవలం తిరిగి రావచ్చు.

633
00:52:12,970 --> 00:52:16,880
>> శూన్యమైన అని గమనించండి, అందువలన మేము నిర్దిష్ట ఏదైనా తిరిగి లేదు, మేము తిరిగి.

634
00:52:16,880 --> 00:52:19,580
సరే. కాబట్టి మా బేస్ కేస్.

635
00:52:19,580 --> 00:52:27,440
మనం, పరిమాణం 0 యొక్క వ్యూహం విలీనం చేయడం జరిగితే మా బేస్ కేసు కూడా ఉంటుంది అంచనా

636
00:52:27,440 --> 00:52:30,030
మేము బహుశా, ఒక సమయంలో ఆపివేయాలనుకుంటున్నారా

637
00:52:30,030 --> 00:52:33,610
కాబట్టి మేము కేవలం 2 కంటే తక్కువగా లేదా కంటే తక్కువ లేదా 1 కి సమానమైన పరిమాణం చెప్పగలను

638
00:52:33,610 --> 00:52:37,150
ఈ ఇప్పుడు ఏ శ్రేణి కోసం పని చేస్తుంది కాబట్టి.

639
00:52:37,150 --> 00:52:38,870
సరే.

640
00:52:38,870 --> 00:52:42,740
కాబట్టి మా బేస్ కేస్.

641
00:52:42,740 --> 00:52:45,950
ఇప్పుడు మీరు విలీనంతో ద్వారా మాకు నడిచే అనుకుంటున్నారు?

642
00:52:45,950 --> 00:52:49,140
ఈ సందర్భాలలో ఏమిటి?

643
00:52:49,140 --> 00:52:54,480
ఇక్కడ, మనం కేవలం ఒకే ఆలోచన చేయుచున్నారు -

644
00:52:56,970 --> 00:53:02,470
[విద్యార్థి] నేను mergeSortHelp కాల్స్ తో పరిమాణం ఉత్తీర్ణత అవసరం.

645
00:53:02,470 --> 00:53:10,080
నేను ఒక అదనపు ప్రాధమిక వంటి పరిమాణం జోడించారు మరియు పరిమాణం / 2 వంటి అక్కడ కాదు.

646
00:53:10,080 --> 00:53:16,210
[బౌడెన్] ఓహ్, పరిమాణం / 2, పరిమాణం / 2. >> [విద్యార్థి] అవును, మరియు కూడా పైన ఫంక్షన్ లో.

647
00:53:16,210 --> 00:53:21,320
[బౌడెన్] ఇక్కడ? >> [విద్యార్థి] జస్ట్ పరిమాణం. >> [బౌడెన్] ఓహ్. సైజు, పరిమాణం? >> [విద్యార్థి] అవును.

648
00:53:21,320 --> 00:53:23,010
[బౌడెన్] సరే.

649
00:53:23,010 --> 00:53:26,580
నాకు రెండవ ఆలోచిస్తూ లెట్.

650
00:53:26,580 --> 00:53:28,780
మేము ఒక సమస్యను ఆకస్మికంగా లేదా?

651
00:53:28,780 --> 00:53:33,690
మేము ఎల్లప్పుడూ 0 గా ఎడమ చికిత్స చేస్తున్నారు. >> [విద్యార్థి] నం

652
00:53:33,690 --> 00:53:36,340
అది చాలా తప్పు. క్షమించాలి. ఇది ప్రారంభ ఉండాలి. అవును.

653
00:53:36,340 --> 00:53:39,230
[బౌడెన్] సరే. నేను మంచి ఇష్టం.

654
00:53:39,230 --> 00:53:43,880
మరియు ముగింపు. సరే.

655
00:53:43,880 --> 00:53:47,200
కాబట్టి ఇప్పుడు మీరు విలీనంతో ద్వారా మాకు నడిచే అనుకుంటున్నారు? >> [విద్యార్థి] సరే.

656
00:53:47,200 --> 00:53:52,150
నేను సృష్టించిన ఈ కొత్త వ్యవస్థల ద్వారా వాకింగ్ చేస్తున్నాను.

657
00:53:52,150 --> 00:53:57,420
దీని పరిమాణం మేము వేరు మీరు శ్రేణి యొక్క భాగం పరిమాణం

658
00:53:57,420 --> 00:54:03,460
మరియు నేను కొత్త శ్రేణి దశలో ఉంచారు అని మూలకం కనుగొనేందుకు ప్రయత్నిస్తున్న.

659
00:54:03,460 --> 00:54:10,140
యెరే యొక్క ఎడమ అర్ధ ఏ అంశాలు కొనసాగిస్తుంది చేస్తే ఆ విధంగా చేయడానికి, మొదటి నేను తనిఖీ చేస్తున్నాను,

660
00:54:10,140 --> 00:54:14,260
అది లేనప్పుడు మరియు, అప్పుడు మీరు చెప్పింది ఇది మిగిలిన పరిస్థితి, క్రిందికి వెళ్లి

661
00:54:14,260 --> 00:54:20,180
సరే, అది కుడి శ్రేణి ఉండాలి మరియు మేము newArray ప్రస్తుత ఇండెక్స్ లో ఉంచుతాము.

662
00:54:20,180 --> 00:54:27,620
>> యెరే యొక్క కుడివైపు కూడా పూర్తి ఉంటే అప్పుడు లేకపోతే, నేను, తనిఖీ చేస్తున్నాను

663
00:54:27,620 --> 00:54:30,630
ఈ సందర్భంలో నేను ఎడమ ప్రవేశపెట్టింది.

664
00:54:30,630 --> 00:54:34,180
వాస్తవానికి అవసరమైన కాదు. నాకు ఖచ్చితంగా తెలియదు.

665
00:54:34,180 --> 00:54:40,970
కానీ ఎలాగైనా, రెండు యొక్క ఇతర రెండు చెక్ ఎడమ లేదా కుడి వైపు చిన్నవిగా ఉంటాయి.

666
00:54:40,970 --> 00:54:49,770
మరియు ప్రతి సందర్భంలో, నేను పెంచడం కావాల్సిన ప్లేస్హోల్డర్ పెంచడం చేస్తున్నాను.

667
00:54:49,770 --> 00:54:52,040
[బౌడెన్] సరే.

668
00:54:52,040 --> 00:54:53,840
ఆ బాగుంది.

669
00:54:53,840 --> 00:54:58,800
ఎవరైనా వ్యాఖ్యలు సమస్యల లేదా ప్రశ్నలు ఉందా?

670
00:55:00,660 --> 00:55:07,720
లేదా ఐదు కనిపిస్తోంది - - మేము ఉనికిలోకి విషయాలు తీసుకుని కలిగి నాలుగు కేసులు కాబట్టి

671
00:55:07,720 --> 00:55:13,100
కానీ మేము, ఎడమ శ్రేణి మేము విలీనం చెయ్యాల్సిన పనులను రన్నవుట్ లేదో పరిగణించాలి

672
00:55:13,100 --> 00:55:16,390
కుడివైపు శ్రేణి మేము విలీనం చెయ్యాల్సిన పనులను రన్నవుట్ లేదో -

673
00:55:16,390 --> 00:55:18,400
నేను ఏమీ వద్ద గురిపెట్టి చేస్తున్నాను.

674
00:55:18,400 --> 00:55:21,730
కాబట్టి ఎడమ శ్రేణి విషయాలను రన్నవుట్ లేదా కుడి శ్రేణి విషయాలను రన్నవుట్ లేదో.

675
00:55:21,730 --> 00:55:24,320
ఆ రెండు కేసులు ఉన్నాయి.

676
00:55:24,320 --> 00:55:30,920
మేము కూడా ఎడమ విషయం సరి కంటే తక్కువ అనే చిన్నవిషయం కేసు అవసరం.

677
00:55:30,920 --> 00:55:33,910
అప్పుడు మేము ఎడమ విషయం ఎంచుకోవాలనుకుంటే.

678
00:55:33,910 --> 00:55:37,630
ఆ సందర్భాలలో ఉన్నాయి.

679
00:55:37,630 --> 00:55:40,990
కాబట్టి ఈ కుడికి, అని తద్వారా.

680
00:55:40,990 --> 00:55:46,760
అర్రే వదిలి. ఇది 1, 2, 3 యొక్క. సరే. కాబట్టి యేః, ఆ మేము భావించే నాలుగు విషయాలు ఇక్కడ ఉన్నాయి.

681
00:55:50,350 --> 00:55:54,510
మరియు మేము ఒక పరిష్కారం పునరుత్థాన మీద కాదు.

682
00:55:54,510 --> 00:55:55,980
నేను చదవనక్కరలేదు -

683
00:55:55,980 --> 00:56:03,070
విలీనం విధమైన, పునరావృత రెండు తోక లేని ఒక చర్య యొక్క ఒక ఉదాహరణ

684
00:56:03,070 --> 00:56:07,040
ఇది తోక పునరావృత చేయడం సులభం కాదు

685
00:56:07,040 --> 00:56:13,450
కానీ అది పునరుక్తి చేయడానికి చాలా సులభం కాదు.

686
00:56:13,450 --> 00:56:16,910
ఈ చాలా సులభం.

687
00:56:16,910 --> 00:56:19,170
విలీనంతో విధమైన ఈ అమలు,

688
00:56:19,170 --> 00:56:22,140
, మీరు ఏ విషయం విలీనం, మీరు విలీనంతో నిర్మించడానికి చూడాలని.

689
00:56:22,140 --> 00:56:29,170
>> కాబట్టి విలీనం పై నిర్మించబడిన విధమైన పునరావృతంగా కేవలం ఈ మూడు సరళి విలీనం.

690
00:56:29,170 --> 00:56:34,700
పునరుత్ధాన, దాని గురించి ఆలోచించటం మరింత అసహ్యమైన మరియు మరింత కష్టం.

691
00:56:34,700 --> 00:56:41,860
కానీ mergeSortHelp నుండి పునరావృత తోక కాదు అని గుర్తించలేకపోతే - అది స్వయంగా కాల్స్ ఉన్నప్పుడు -

692
00:56:41,860 --> 00:56:46,590
అది ఇప్పటికీ ఈ పునరావృత కాల్ రాబడి తర్వాత పనులను అవసరం.

693
00:56:46,590 --> 00:56:50,830
కాబట్టి ఈ స్టాక్ ఫ్రేమ్ కూడా ఈ కాల్ తర్వాత ఉనికిలో అవ్వాలి.

694
00:56:50,830 --> 00:56:54,170
ఆపై మీరు ఈ కాల్ చేసినప్పుడు, స్టాక్ ఫ్రేమ్ ఉన్నాయి అవ్వాలి

695
00:56:54,170 --> 00:56:57,780
కూడా ఆ కాల్ తర్వాత, మేము ఇప్పటికీ విలీనం అవసరం ఎందుకంటే.

696
00:56:57,780 --> 00:57:01,920
మరియు ఈ తోక పునరావృత చేయడానికి nontrivial ఉంది.

697
00:57:04,070 --> 00:57:06,270
ప్రశ్నలు?

698
00:57:08,300 --> 00:57:09,860
అన్ని కుడి.

699
00:57:09,860 --> 00:57:13,400
కాబట్టి క్రమం తిరిగి వెళ్ళడం - ఓహ్, నేను చూపాలనుకుంటున్న రెండు విషయాలను. సరే.

700
00:57:13,400 --> 00:57:17,840
క్రమీకరించు కు వెళుతున్నారు, మేము త్వరగా చేస్తాను.

701
00:57:17,840 --> 00:57:21,030
లేదా శోధన. క్రమీకరించు? క్రమీకరించు. అవును.

702
00:57:21,030 --> 00:57:22,730
క్రమీకరించు ప్రారంభం కు వెళుతున్నారు.

703
00:57:22,730 --> 00:57:29,870
మేము ఏ అల్గారిథమ్ ఉపయోగించి ఆ రకాల శ్రేణి ఒక అల్గోరిథం సృష్టించాలనుకునే

704
00:57:29,870 --> 00:57:33,660
n యొక్క O లో.

705
00:57:33,660 --> 00:57:40,860
కాబట్టి ఎలా ఈ సాధ్యమేనా? ఎవరైనా ఏ విధమైన కలిగి ఉంది -

706
00:57:40,860 --> 00:57:44,300
నేను వద్ద ముందు సూచనప్రాయంగా -

707
00:57:44,300 --> 00:57:48,300
మేము N log N నుండి n యొక్క O కు మెరుగుపరచడానికి గురించి అయితే,

708
00:57:48,300 --> 00:57:51,450
మేము మా అల్గోరిథం సమయం వారీగా, అభివృద్ధి

709
00:57:51,450 --> 00:57:55,250
ఇది ఆ చేయడానికి చెయ్యాల్సిన ఏమి వెళ్తున్నారు? అర్థం

710
00:57:55,250 --> 00:57:59,520
[విద్యార్థి] స్పేస్. >> అవును. మేము మరింత ఖాళీస్థలం కావడం చేస్తున్నారు.

711
00:57:59,520 --> 00:58:04,490
మరియు కూడా కేవలం మరింత స్థలం, ఇది విశేషంగా మరింత స్పేస్ యొక్క.

712
00:58:04,490 --> 00:58:14,320
నేను అల్గోరిథం యొక్క ఈ రకం నకిలీ ఏదో, నకిలీ polynom భావిస్తే -

713
00:58:14,320 --> 00:58:18,980
నకిలీ - నాకు గుర్తు లేదు. సూడో ఏదో.

714
00:58:18,980 --> 00:58:22,210
ఎక్కువ ఖాళీ ఉపయోగించాలి ఎందుకంటే కానీ ఇది

715
00:58:22,210 --> 00:58:28,610
ఈ సాధించగల కానీ వాస్తవిక లేదు.

716
00:58:28,610 --> 00:58:31,220
>> మరియు మేము ఎలా సాధించడం లేదు?

717
00:58:31,220 --> 00:58:36,810
మేము హామీ మేము ఈ సాధించలేకపోవడం శ్రేణి, ఏ మూలకం

718
00:58:36,810 --> 00:58:39,600
క్రింద ఒక నిర్దిష్ట పరిమాణం.

719
00:58:42,070 --> 00:58:44,500
కాబట్టి, కేవలం పరిమాణం 200 పేర్కొన్నారు లెట్స్

720
00:58:44,500 --> 00:58:48,130
వ్యూహం ఏదైనా మూలకం క్రింద పరిమాణం 200 ఉంది.

721
00:58:48,130 --> 00:58:51,080
మరియు ఈ నిజంగా చాలా యదార్ధంగా ఉంది.

722
00:58:51,080 --> 00:58:58,660
మీరు చాలా సులభంగా మీరు ప్రతిదీ తెలుసు వ్యూహం ఉండవచ్చు

723
00:58:58,660 --> 00:59:00,570
కొన్ని సంఖ్య కంటే తక్కువగా అన్నారు.

724
00:59:00,570 --> 00:59:07,400
మీరు కొన్ని పూర్తిగా భారీ vector లేదా ఏదైనా కలిగి ఉంటే ఇష్టం

725
00:59:07,400 --> 00:59:11,810
కానీ మీరు ప్రతిదీ, 0 మరియు 5 మధ్య అన్నారు తెలుసు

726
00:59:11,810 --> 00:59:14,790
అప్పుడు దీన్ని చాలా వేగంగా చేస్తాడు.

727
00:59:14,790 --> 00:59:17,930
మరియు అంశాలను ఏ న బౌండ్, 5

728
00:59:17,930 --> 00:59:21,980
ఈ బౌండ్ కాబట్టి, ఆ మీరు ఉపయోగిస్తున్న చూడాలని ఎంత మెమరీ ఉంది.

729
00:59:21,980 --> 00:59:26,300
కాబట్టి బౌండ్ 200 ఉంది.

730
00:59:26,300 --> 00:59:32,960
పూర్ణాంకం మాత్రమే 4 బిలియన్ కాబట్టి సిద్ధాంతంలో ఒక బైండ్, ఎప్పుడూ ఉంటుంది

731
00:59:32,960 --> 00:59:40,600
కానీ ఆ తర్వాత మేము స్థలం ఉపయోగించి లోనవుతాను నుండి అవాస్తవ యొక్క

732
00:59:40,600 --> 00:59:44,400
4 బిలియన్ యొక్క ఆర్డర్ మీద. కాబట్టి ఆ అవాస్తవ ఉంది.

733
00:59:44,400 --> 00:59:47,060
కానీ ఇక్కడ మేము మా బౌండ్ సే చేస్తాము 200 ఉంది.

734
00:59:47,060 --> 00:59:59,570
n యొక్క O లో నటించడానికి ట్రిక్ మేము పరిమాణం గణనలు BOUND అని మరొక శ్రేణి తయారు ఉంది.

735
00:59:59,570 --> 01:00:10,470
కాబట్టి నిజంగా, ఈ ఒక షార్ట్కట్ ఉంది - గణగణమని ద్వని చేయు ఈ ఒకవేళ నేను నిజంగా తెలియదు.

736
01:00:11,150 --> 01:00:15,330
కానీ చాలా కనీసం GCC లో - I'm ఊహిస్తూ గణగణమని ద్వని చేయు చాలా అది -

737
01:00:15,330 --> 01:00:18,180
ఇది 0 సె అని మొత్త ప్రారంభించడం కనిపిస్తుంది.

738
01:00:18,180 --> 01:00:25,320
నేను అనుకుంటే కాబట్టి, నేను విడిగా కోసం చేయగల (Int i = 0;

739
01:00:25,320 --> 01:00:31,500
i <BOUND; i + +) మరియు గణనలు [i] = 0;

740
01:00:31,500 --> 01:00:35,260
కాబట్టి ఇప్పుడు ప్రతిదీ 0 to initialized ఉంది.

741
01:00:35,260 --> 01:00:39,570
నేను, నా శ్రేణి మీద iterate

742
01:00:39,570 --> 01:00:51,920
మరియు నేను నేను ప్రతి సంఖ్యపై చేస్తున్నాను ఉంది - ఇక్కడ డౌన్ ప్రారంభించండి.

743
01:00:51,920 --> 01:00:55,480
మేము 4, 15, 16, 50, 8, 23, 42, 108 ఉన్నాయి.

744
01:00:55,480 --> 01:01:00,010
నేను లెక్కింపు నేను ఆ అంశాల ప్రతి యొక్క సంభావ్యతలను సంఖ్య.

745
01:01:00,010 --> 01:01:03,470
యొక్క నిజానికి కొన్ని రిపీట్స్ ఇక్కడ ఒక జంట మరింత జోడించడానికి అనుమతిస్తుంది.

746
01:01:03,470 --> 01:01:11,070
మేము ఇక్కడ ఉన్నాయి విలువ కాబట్టి, ఆ విలువ [i] అర్రే అయి అన్నారు.

747
01:01:11,070 --> 01:01:14,850
కాబట్టి Val 4 లేదా 8 లేదా ఎలాగైనా ఉండవచ్చు.

748
01:01:14,850 --> 01:01:18,870
ఇప్పుడు నేను చూసిన ఎన్ని ఆ విలువ లెక్కింపు నేను

749
01:01:18,870 --> 01:01:21,230
గణనలు కాబట్టి [Val] + +;

750
01:01:21,230 --> 01:01:29,430
ఇలా చేసిన తర్వాత, గణనలు 0001 లో లాగ చూడండి అన్నారు.

751
01:01:29,430 --> 01:01:42,190
గణనలు తెలియజేసేలా యొక్క [Val] - + 1 BOUND.

752
01:01:42,190 --> 01:01:48,230
>> ఇప్పుడు మేము 0 నుండి మొదలు పెడుతున్నారు వాస్తవం బాధ్యత కేవలం ఉంది.

753
01:01:48,230 --> 01:01:50,850
అయితే 200, మా పెద్ద సంఖ్య అన్నారు

754
01:01:50,850 --> 01:01:54,720
అప్పుడు 0 to 200 201 విషయాలను ఉంది.

755
01:01:54,720 --> 01:02:01,540
మేము ఒక 4 ఎందుకంటే గణనలు కాబట్టి, అది 00001 వంటి పరిశీలిస్తాము.

756
01:02:01,540 --> 01:02:10,210
అప్పుడు మేము లెక్క 8 సూచిక ఒక 1 ఉంటుంది పేరు 0001 ఉంటుంది.

757
01:02:10,210 --> 01:02:14,560
మేము లెక్క 23 ఇండెక్స్ లో ఒక 2 ఉంటుంది.

758
01:02:14,560 --> 01:02:17,630
మేము లెక్క 42 వ సూచిక లో ఒక 2 ఉంటుంది.

759
01:02:17,630 --> 01:02:21,670
కాబట్టి మేము COUNT ఉపయోగించవచ్చు.

760
01:02:34,270 --> 01:02:44,920
కాబట్టి num_of_item = గణనలు [i].

761
01:02:44,920 --> 01:02:52,540
మరియు num_of_item 2 అయితే, మేము సంఖ్య i యొక్క 2 ఇన్సర్ట్ చెయ్యడానికి కావలసిన అర్థం

762
01:02:52,540 --> 01:02:55,290
మా క్రమబద్ధీకరించబడతాయి శ్రేణి లోకి.

763
01:02:55,290 --> 01:03:02,000
కనుక మేము శ్రేణి లోకి ఎలా దూరంగా ట్రాక్ అవసరం.

764
01:03:02,000 --> 01:03:05,470
కాబట్టి ఇండెక్స్ = 0.

765
01:03:05,470 --> 01:03:09,910
అర్రే - నేను వ్రాయుటకు చేస్తాము.

766
01:03:16,660 --> 01:03:18,020
కౌంట్స్ -

767
01:03:19,990 --> 01:03:28,580
అర్రే [ఇండెక్స్ + +] = i;

768
01:03:28,580 --> 01:03:32,490
నేను ఏమి ఉంది? నేను ఆ నేను ఏమి అని.

769
01:03:35,100 --> 01:03:38,290
అవును, ఈ బాగుంది. సరే.

770
01:03:38,290 --> 01:03:43,050
కాబట్టి ప్రతి ఒక్కరూ నా గణనలు శ్రేణి యొక్క ప్రయోజనం ఏమిటి అర్థం లేదు?

771
01:03:43,050 --> 01:03:48,140
ఈ సంఖ్యల యొక్క ప్రతి ఏర్పడడం సంఖ్య లెక్కింపు ఉంటుంది.

772
01:03:48,140 --> 01:03:51,780
అప్పుడు నేను, ఆ గణనలు శ్రేణి మీద iterating am

773
01:03:51,780 --> 01:03:57,190
మరియు ఈ గణనలు యెరే నందలి ith స్థానం

774
01:03:57,190 --> 01:04:01,930
నా క్రమబద్ధీకరించబడతాయి శ్రేణి కనిపిస్తాయి ఆ I యొక్క సంఖ్య.

775
01:04:01,930 --> 01:04:06,840
4 యొక్క గణనలు 1 కానుంది ఎందుకు ఆ

776
01:04:06,840 --> 01:04:11,840
మరియు 8 యొక్క గణనలు 1 ఉండబోతుంది, 23 గణనలు 2 అన్నారు.

777
01:04:11,840 --> 01:04:16,900
అక్కడ నేను నా క్రమబద్ధీకరించబడతాయి శ్రేణి ఇన్సర్ట్ మీరు ఎలా వాటిలో అనేక ఉంది.

778
01:04:16,900 --> 01:04:19,200
అప్పుడు నేను అలా.

779
01:04:19,200 --> 01:04:28,960
నేను నా క్రమబద్ధీకరించబడతాయి శ్రేణి లోకి యొక్క num_of_item ఇన్సర్ట్ am.

780
01:04:28,960 --> 01:04:31,670
>> ప్రశ్నలు?

781
01:04:32,460 --> 01:04:43,100
మేము కేవలం ఒకసారి ఈ పైగా iterating కాబట్టి మరలా, ఈ, సరళ సమయం

782
01:04:43,100 --> 01:04:47,470
కానీ, ఈ సంఖ్య ఏమి లో కూడా సరళ యొక్క

783
01:04:47,470 --> 01:04:50,730
మరియు కనుక ఇది భారీగా మీ బౌండ్ ఆధారంగా ఉంటుంది.

784
01:04:50,730 --> 01:04:53,290
200 యొక్క ఒక బౌండ్ తో, ఆ చెడు కాదు.

785
01:04:53,290 --> 01:04:58,330
మీ బౌండ్ 10,000 మాత్రం ఉంటే, ఆ, కొద్దిగా స్ వర్స్

786
01:04:58,330 --> 01:05:01,360
మీ బౌండ్, 4 బిలియన్ మాత్రం కాని ఆ పూర్తిగా అవాస్తవ యొక్క

787
01:05:01,360 --> 01:05:07,720
మరియు ఈ శ్రేణి అవాస్తవిక ఇది పరిమాణం 4 బిలియన్, కలిగి ఉండాలి అన్నారు.

788
01:05:07,720 --> 01:05:10,860
కాబట్టి అది అదే. ప్రశ్నలు?

789
01:05:10,860 --> 01:05:13,270
[వినబడని విద్యార్థి ప్రతిస్పందన] >> సరే.

790
01:05:13,270 --> 01:05:15,710
మేము ద్వారా ఉండేవి నేను ఒక విషయం ఇతర గుర్తించారు.

791
01:05:17,980 --> 01:05:23,720
నేను సమస్య లుకాస్ యొక్క మరియు బహుశా మేము చూసిన ప్రతి ఒక ఉంది అనుకుంటున్నాను.

792
01:05:23,720 --> 01:05:26,330
నేను పూర్తిగా మర్చిపోయాను.

793
01:05:26,330 --> 01:05:31,040
నేను వ్యాఖ్యానించిన ఒక్కటే అని మీరు సూచీలు వంటి వాటిని వ్యవహరించే, చేసినప్పుడు

794
01:05:31,040 --> 01:05:38,320
మీరు లూప్ ఒక వ్రాస్తున్నప్పుడు మీరు నిజంగా, ఈ చూడండి ఎప్పుడూ

795
01:05:38,320 --> 01:05:41,120
కానీ సాంకేతికంగా, చేసినప్పుడు మీరు, ఈ సూచికలు వ్యవహరించే చేస్తున్నారు

796
01:05:41,120 --> 01:05:45,950
మీరు ఎల్లప్పుడూ సైన్ చేయని పూర్ణ వ్యవహరించే ఉండాలి.

797
01:05:45,950 --> 01:05:53,850
మీరు సంతకం పూర్ణాంకాల వ్యవహరించే చేసినప్పుడు ఈ కారణం ఉంది

798
01:05:53,850 --> 01:05:56,090
మీరు 2 సంతకం పూర్ణాంకాల కలిగి మరియు మీరు వాటిని కలిసి జోడించండి అయితే

799
01:05:56,090 --> 01:06:00,640
మరియు వారు చాలా పెద్ద ముగుస్తుంది, అప్పుడు మీకు ఒక ప్రతికూల సంఖ్య ముగిసేవి.

800
01:06:00,640 --> 01:06:03,410
కాబట్టి ఆ పూర్ణాంక ఓవర్ఫ్లో ఉంది ఏమి.

801
01:06:03,410 --> 01:06:10,500
>> నేను 2 బిలియన్ మరియు 1 బిలియన్ జోడిస్తే, నేను ప్రతికూల 1 బిలియన్ తో ముగుస్తుంది.

802
01:06:10,500 --> 01:06:15,480
ఆ పూర్ణ కంప్యూటర్ల మీద ఎలా.

803
01:06:15,480 --> 01:06:17,510
ఉపయోగించి సమస్య కాబట్టి -

804
01:06:17,510 --> 01:06:23,500
అంటే, తక్కువ 2 బిలియన్లు జరిగితే తప్ప మంచిది మరియు 1 బిలియన్ నిర్మాణము

805
01:06:23,500 --> 01:06:27,120
ఈ 1 బిలియన్ ప్రతికూల మాత్రం ఆ తర్వాత మేము తిరగడానికి చూడాలని ఉద్దేశ్యంతో 2

806
01:06:27,120 --> 01:06:29,730
మరియు ప్రతికూల 500 మిలియన్ ముగుస్తుంది.

807
01:06:29,730 --> 01:06:33,760
కాబట్టి ఈ మీరు వ్యూహం ద్వారా శోధించడం సాధ్యం జరిగితే మాత్రమే ఒక విషయం

808
01:06:33,760 --> 01:06:38,070
విషయాలు బిల్లియన్ల.

809
01:06:38,070 --> 01:06:44,050
తక్కువ + అప్ ఓవర్ఫ్లో జరిగితే కానీ, ఆ సమస్య ఉంది.

810
01:06:44,050 --> 01:06:47,750
వెంటనే మేము వాటిని సంతకం లేని రూపొందించినప్పుడు, తర్వాత 2 బిలియన్ ప్లస్ 1 బిలియన్ 3 బిలియన్లు ఉంది.

811
01:06:47,750 --> 01:06:51,960
2 ద్వారా విభజించబడింది 3 బిలియన్ 1.5 బిలియన్లు ఉంది.

812
01:06:51,960 --> 01:06:55,670
వారు సైన్ చేయని ఉన్నారు కాబట్టి వెంటనే, ప్రతిదీ ఖచ్చితంగా ఉంది.

813
01:06:55,670 --> 01:06:59,900
మీరు ఉచ్చులు కోసం మీ వ్రాస్తున్నప్పుడు మరియు తద్వారా, కూడా ఒక సమస్య

814
01:06:59,900 --> 01:07:03,940
మరియు వాస్తవానికి, ఇది బహుశా స్వయంచాలకంగా అది.

815
01:07:09,130 --> 01:07:12,330
ఇది నిజానికి మీరు అరుస్తుంటారు కనిపిస్తుంది.

816
01:07:12,330 --> 01:07:21,610
ఈ సంఖ్య కేవలం ఒక పూర్ణాంకం లో చాలా పెద్దది కానీ ఉంటే అది సంతకం లేని పూర్ణ అధిగమించడంలో చేస్తుంది

817
01:07:21,610 --> 01:07:24,970
మీరు అరుస్తుంటారు కనిపిస్తుంది, మీరు నిజంగా సమస్య ఆకస్మికంగా ఎప్పుడూ వై తద్వారా.

818
01:07:29,150 --> 01:07:34,820
మీరు ఒక సూచిక ప్రతికూల మాత్రం లేదు చూడగలరు

819
01:07:34,820 --> 01:07:39,220
మరియు మీరు, వ్యూహం మీద iterating చేసినప్పుడు

820
01:07:39,220 --> 01:07:43,970
మీరు ఎల్లప్పుడూ నేను Int సైన్ చేయని చెప్పగలదు, కానీ మీరు నిజంగా అవసరం లేదు.

821
01:07:43,970 --> 01:07:47,110
థింగ్స్ కేవలం అలాగే చాలా చక్కని పని వెళ్తున్నారు.

822
01:07:48,740 --> 01:07:50,090
సరే. [Whispers] అంటే సమయం?

823
01:07:50,090 --> 01:07:54,020
మరియు నేను దానిని నిజంగా శీఘ్ర చేస్తాను - నేను చూపించు కోరుకున్నారు లాస్ట్ థింగ్.

824
01:07:54,020 --> 01:08:03,190
మీరు మేము # 5 లేదా ఏదో MAX నిర్వచించే కాబట్టి మేము # define ఎలా తెలుసు?

825
01:08:03,190 --> 01:08:05,940
MAX లేదు లెట్ యొక్క. # 200 వంటి BOUND వివరిస్తాయి. అంటే ముందు ఏమి ఉంది.

826
01:08:05,940 --> 01:08:10,380
కేవలం కాపీ మరియు అతికించబడతాయి అన్నారు ఇది ఒక స్థిరమైన, నిర్వచిస్తుంది

827
01:08:10,380 --> 01:08:13,010
మేము BOUND రాయడానికి జరిగే చోట.

828
01:08:13,010 --> 01:08:18,189
>> కాబట్టి మేము నిజంగా # నిర్వచిస్తుంది మరింత చేయవచ్చు.

829
01:08:18,189 --> 01:08:21,170
మేము # విధులు నిర్వచించలేదు.

830
01:08:21,170 --> 01:08:23,410
వారు నిజంగా చర్యలు కావు, కానీ మాకు వాటిని విధులు పిలుస్తాను.

831
01:08:23,410 --> 01:08:36,000
ఒక ఉదాహరణ MAX (x, y) లాగ ఉంటుంది (?: X x <y y) నిర్వచించవచ్చు. సరే.

832
01:08:36,000 --> 01:08:40,660
కాబట్టి మీరు, టెర్నరీ ఆపరేటర్లు సింటాక్స్ ఉపయోగిస్తారు కావాలి

833
01:08:40,660 --> 01:08:49,029
కానీ x y కంటే తక్కువ? Y తిరిగి ఎల్స్ x తిరిగి.

834
01:08:49,029 --> 01:08:54,390
కాబట్టి మీరు, మీరు ఈ ప్రత్యేక ఫంక్షన్ చేయవచ్చు చూడగలరు

835
01:08:54,390 --> 01:09:01,399
bool MAX 2 వాదనలు పడుతుంది వంటి మరియు ఫంక్షన్ ఉంటుంది, ఈ తిరిగి.

836
01:09:01,399 --> 01:09:08,340
ఈ వంటి పూర్తి నేను చూడండి అత్యంత సాధారణంగా కనిపించే వాటిలో ఒకటి. మేము వాటిని macros కాల్.

837
01:09:08,340 --> 01:09:11,790
ఈ సూక్ష్మ ఉంది.

838
01:09:11,790 --> 01:09:15,859
ఇది దాని కోసం వాక్యనిర్మాణం.

839
01:09:15,859 --> 01:09:18,740
మీరు మీకు కావలసిన పనులను ఒక స్థూల వ్రాయగలవు.

840
01:09:18,740 --> 01:09:22,649
మీరు తరచుగా printfs మరియు stuff డీబగ్గింగ్ కోసం macros చూడండి.

841
01:09:22,649 --> 01:09:29,410
Printf ఒక రకమైన కాబట్టి, తక్కువగా LINE తక్కువగా వంటి C ప్రత్యేక స్థిరాంకాలు ఉంటాయి

842
01:09:29,410 --> 01:09:31,710
2, LINE తక్కువగా అండర్

843
01:09:31,710 --> 01:09:37,550
మరియు నేను 2 func అండర్ భావిస్తున్నాను కూడా ఉంది. అది కావచ్చు. ఆ వంటివి.

844
01:09:37,550 --> 01:09:40,880
ఆ విషయాలను చర్య యొక్క పేరును భర్తీ చేస్తుంది

845
01:09:40,880 --> 01:09:42,930
లేదా మీరు ఆ పంక్తిలో సంఖ్య.

846
01:09:42,930 --> 01:09:48,630
తరచుగా, మీరు డౌన్ ఇక్కడ నేను అప్పుడు వ్రాయండి అని డీబగ్గింగ్ printfs వ్రాయండి

847
01:09:48,630 --> 01:09:54,260
డీబగ్ మరియు లైన్ సంఖ్య మరియు నేను ఉండాలి జరిగే ఫంక్షన్ ముద్రిస్తుంది

848
01:09:54,260 --> 01:09:57,020
ఆ డీబగ్ ప్రకటన ఎదుర్కొనే.

849
01:09:57,020 --> 01:09:59,550
మరియు మీరు ఇతర విషయాలు ముద్రించవచ్చు.

850
01:09:59,550 --> 01:10:05,990
కాబట్టి మీరు వాచ్ అవుట్ ఫర్ ఉండవలసిన ఒక మాట # DOUBLE_MAX నిర్వచించే జరిగితే ఉంది

851
01:10:05,990 --> 01:10:11,380
2 * Y మరియు 2 లాగ వంటి * x.

852
01:10:11,380 --> 01:10:14,310
కాబట్టి ఏ కారణం చేతనైనా సరే, మీరు చాలా అలా ఏం.

853
01:10:14,310 --> 01:10:16,650
కాబట్టి దీనిని స్థూల చేయండి.

854
01:10:16,650 --> 01:10:18,680
ఈ నిజానికి విభజించబడింది.

855
01:10:18,680 --> 01:10:23,050
నేను DOUBLE_MAX (3, 6) వంటి దానిని చేయడం ఇది అంటారని.

856
01:10:23,050 --> 01:10:27,530
సో వాట్ తప్పక తిరిగి?

857
01:10:28,840 --> 01:10:30,580
[విద్యార్థి] 12.

858
01:10:30,580 --> 01:10:34,800
అవును, 12 తప్పక తిరిగి, మరియు 12 తిరిగి.

859
01:10:34,800 --> 01:10:43,350
3 x కోసం స్థానంలో చేస్తారు, 6 Y కోసం స్థానంలో, మరియు మేము 12 ఇది 2 * 6, తిరిగి ఉంటుంది.

860
01:10:43,350 --> 01:10:47,710
ఇప్పుడు ఈ గురించి? ఏ తప్పక తిరిగి?

861
01:10:47,710 --> 01:10:50,330
[విద్యార్థి] 14. >> ఆదర్శవంతంగా, 14.

862
01:10:50,330 --> 01:10:55,290
సమస్యను పని నిర్వచిస్తుంది ఎలా hash, ఇది కేవల నకలు మరియు పేస్ట్ యొక్క గుర్తు ఉంటుంది

863
01:10:55,290 --> 01:11:00,160
చాలా చక్కని ప్రతిదీ యొక్క, సో వాట్ ఈ విధంగా అన్వయించవచ్చు అన్నారు

864
01:11:00,160 --> 01:11:11,270
1 ప్లస్ 6, 2 సార్లు 1 ప్లస్ 6, 2 సార్లు 3 కంటే 3 తక్కువగా ఉంది.

865
01:11:11,270 --> 01:11:19,780
>> కాబట్టి ఈ కారణంగా మీరు ఎల్లప్పుడూ కుండలీకరణాల్లో ప్రతిదీ జరుగుతాయి.

866
01:11:22,180 --> 01:11:25,050
మీరు ఎల్లప్పుడూ కుండలీకరణాల్లో వ్రాప్ ఏదైనా వేరియబుల్.

867
01:11:25,050 --> 01:11:29,570
నేను ఇక్కడ అలా లేదు తెలుసు మీకు లేదు సందర్భాలలో ఉన్నాయి

868
01:11:29,570 --> 01:11:32,110
కంటే తక్కువగా ఉంటుంది కాబట్టి ఎల్లప్పుడూ కేవలం వెళ్లాలని,

869
01:11:32,110 --> 01:11:34,330
అయితే కూడా నిజమైన కాదు.

870
01:11:34,330 --> 01:11:41,870
DOUBLE_MAX (1 == 2) వంటి హాస్యాస్పదంగా ఏదో ఉంది ఉంటే,

871
01:11:41,870 --> 01:11:49,760
అప్పుడు 3 కంటే తక్కువ 1 భర్తీ పరుచుట కొరకు ఆ, 2 సమానం సమానం

872
01:11:49,760 --> 01:11:53,460
అందువలన అప్పుడు, సమాన 2, 1 కంటే తక్కువ 3 చేయడానికి లేదు జరగబోతోంది

873
01:11:53,460 --> 01:11:55,620
ఇది మేము ఏమి కాదు.

874
01:11:55,620 --> 01:12:00,730
కాబట్టి ఏ ఆపరేటర్లు ప్రాధాన్యత సమస్యలు నిరోధించడానికి,

875
01:12:00,730 --> 01:12:02,870
ఎల్లప్పుడూ కుండలీకరణాల్లో జరుగుతాయి.

876
01:12:03,290 --> 01:12:07,700
సరే. మరియు ఆ, 5:30 అంతే.

877
01:12:08,140 --> 01:12:12,470
మీరు pset న ఏవైనా ప్రశ్నలు ఉంటే, మాకు తెలియజేయండి.

878
01:12:12,470 --> 01:12:18,010
అదొక ఉండాలి, మరియు హ్యాకర్ ఎడిషన్ కూడా చాలా వాస్తవమని ఉంది

879
01:12:18,010 --> 01:12:22,980
గత సంవత్సరం యొక్క హ్యాకర్ ఎడిషన్ కంటే, కాబట్టి మేము మీరు చాలా ఇది ప్రయత్నించండి ఆశిస్తున్నాము.

880
01:12:22,980 --> 01:12:26,460
గత సంవత్సరం చాలా అధిక ఉంది.

881
01:12:28,370 --> 01:12:30,000
>> [CS50.TV]