1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
రాబ్ బౌడెన్: హాయ్, నేను, రాబ్ బౌడెన్ ఉన్నాను
మరియు యొక్క quiz0 మాట్లాడటానికి వీలు.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> కాబట్టి, మొదటి ప్రశ్న.

5
00:00:14,545 --> 00:00:17,750
ఈ ప్రశ్న పేరు
మీరు సంఖ్య కోడ్ అవసరం

6
00:00:17,750 --> 00:00:21,270
బైనరీ గడ్డలు లో 127.

7
00:00:21,270 --> 00:00:23,550
మీరు అనుకుంటే, మీరు అనుకొనుట
సాధారణ మార్పిడి

8
00:00:23,550 --> 00:00:25,950
దశాంశ నుండి బైనరీ, bi-- లేదా నుండి.

9
00:00:25,950 --> 00:00:28,300
కానీ బహుశా జరగబోతోంది
సమయం చాలా పడుతుంది.

10
00:00:28,300 --> 00:00:31,750
నేను మీరు ఆ గుర్తించడానికి కాలేదు,
సరే, 1, అక్కడ, 2 అక్కడ ఉంది

11
00:00:31,750 --> 00:00:33,650
4 అక్కడ, 8 లో ఉంది.

12
00:00:33,650 --> 00:00:39,280
సులభంగా మార్గం, 127 128 మైనస్ ఒకటి.

13
00:00:39,280 --> 00:00:42,013
ఆ ఎడమవైపున కాంతి బల్బ్ 128-బిట్.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
కాబట్టి 127 అన్ని నిజంగా ఉంది
ఇతర కాంతి గడ్డలు,

16
00:00:47,860 --> 00:00:51,420
ఆ ఎడమవైపున నుండి
కాంతి బల్బ్ మైనస్ 1.

17
00:00:51,420 --> 00:00:52,800
అని అడిగాను కోసం అంతే.

18
00:00:52,800 --> 00:00:54,060
>> ప్రశ్న.

19
00:00:54,060 --> 00:00:56,710
3 బిట్స్ తో కాబట్టి మీరు
8 ప్రత్యేక విలువలను సూచిస్తాయి.

20
00:00:56,710 --> 00:01:01,000
ఎందుకు, అప్పుడు, అతిపెద్ద కాని ప్రతికూల 7
మీరు సూచిస్తుంది దశాంశ పూర్ణాంక?

21
00:01:01,000 --> 00:01:04,050
బాగా, మేము మాత్రమే చెయ్యవచ్చు
8 ప్రత్యేక విలువలు ప్రాతినిధ్యం,

22
00:01:04,050 --> 00:01:07,430
అప్పుడు మనం చేయబోతున్నామని
పాఠశాల 7 ద్వారా 0.

23
00:01:07,430 --> 00:01:08,745
0 విలువలు ఒకటి తీసుకుంటుంది.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> ప్రశ్నను రెండు.

26
00:01:11,190 --> 00:01:14,610
N బిట్స్ తో, ఎన్ని విభిన్న
విలువలు మీరు ప్రాతినిధ్యం?

27
00:01:14,610 --> 00:01:19,080
కాబట్టి, n బిట్స్ తో, మీరు 2 కలిగి
ప్రతి బిట్ విలువల.

28
00:01:19,080 --> 00:01:22,300
కాబట్టి మేము 2 విలువల కోసం కలిగి
మొదటి బిట్, 2 విలువల

29
00:01:22,300 --> 00:01:24,450
రెండవ కోసం, 2
మూడవ అవకాశం.

30
00:01:24,450 --> 00:01:28,730
కాబట్టి ఆ 2 సార్లు 2 సార్లు 2, మరియు
చివరికి సమాధానం n కు 2.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> ప్రశ్న మూడు.

33
00:01:31,100 --> 00:01:33,450
బైనరీ లో 0x50 ఏమిటి?

34
00:01:33,450 --> 00:01:39,490
కాబట్టి హెక్సాడెసిమల్ చాలా ఉంది గుర్తుంచుకోవాలి
బైనరీ సూటిగా మార్పిడి.

35
00:01:39,490 --> 00:01:43,180
ఇక్కడ, మేము కేవలం చూడండి అవసరం
5 మరియు స్వతంత్రంగా 0.

36
00:01:43,180 --> 00:01:45,110
కాబట్టి బైనరీ లో 5 ఏమిటి?

37
00:01:45,110 --> 00:01:48,400
0101, ఆ 1 బిట్ మరియు 4 బిట్.

38
00:01:48,400 --> 00:01:49,900
బైనరీ లో 0 ఏమిటి?

39
00:01:49,900 --> 00:01:50,520
గమ్మత్తైన.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
కాబట్టి కేవలం వారిని కలిసి, మరియు
బైనరీ లో పూర్తి సంఖ్య.

42
00:01:54,970 --> 00:01:57,640
01010000.

43
00:01:57,640 --> 00:02:00,439
మీరు కోరుకుంటే మీరు అనుకొనుట
ఆ ఎడమవైపున సున్నా టేకాఫ్.

44
00:02:00,439 --> 00:02:01,105
ఇది అసంబద్ధం.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> కాబట్టి ప్రత్యామ్నాయంగా,
దశాంశ లో 0x50 ఏమిటి?

47
00:02:05,733 --> 00:02:08,649
మీరు అనుకుంటే మీరు, మీరు could--
బైనరీ తో మరింత సౌకర్యవంతమైన,

48
00:02:08,649 --> 00:02:11,340
మీరు బైనరీ సమాధానం పడుతుంది
మరియు దశాంశ ఆ మార్చేందుకు.

49
00:02:11,340 --> 00:02:13,870
లేదా మేము కేవలం గుర్తు
ఆ హెక్సాడెసిమల్.

50
00:02:13,870 --> 00:02:21,140
0 కాబట్టి 0 వ స్థానంలో ఉంది, మరియు
5 మొదటి స్థానానికి 16 లో ఉంది.

51
00:02:21,140 --> 00:02:25,990
ఇక్కడ, మేము 5 సార్లు 16 కలిగి
మొదటి, సున్నా ప్లస్ 0 సార్లు 16,

52
00:02:25,990 --> 00:02:27,520
80.

53
00:02:27,520 --> 00:02:29,710
మరియు మీరు చూశారు ఉంటే
ప్రశ్న టైటిల్,

54
00:02:29,710 --> 00:02:32,920
అది ఒక రకం ఇది CS 80, ఉంది
ఈ సమస్య సమాధానం సూచించు.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> ప్రశ్నను ఐదు.

57
00:02:35,420 --> 00:02:40,320
మేము ఇది ఈ స్క్రాచ్ లిపి
4 సార్లు వేరుశెనగ వెన్న జెల్లీ పునరావృత.

58
00:02:40,320 --> 00:02:42,800
కాబట్టి మేము సి కోడ్ ఇప్పుడు అలా?

59
00:02:42,800 --> 00:02:47,730
బాగా, మేము ఇక్కడ బోల్డ్ లో భాగంగా
మీరు అమలు వచ్చింది మాత్రమే భాగం.

60
00:02:47,730 --> 00:02:51,950
కాబట్టి మేము 4 మళ్ళీ వెతికినా ఒక 4 లూప్
సార్లు, printf కనుట వేరుశెనగ వెన్న జెల్లీ,

61
00:02:51,950 --> 00:02:53,910
కొత్త లైన్ తో సమస్య కోసం అడుగుతుంది.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> ప్రశ్నను ఆరు, మరొక స్క్రాచ్ సమస్య.

64
00:02:57,490 --> 00:03:00,210
మేము ఒక శాశ్వతంగా లూప్ ఉన్నాయి చూడండి.

65
00:03:00,210 --> 00:03:05,000
మేము వేరియబుల్ నేను చెబుతున్న
ఆపై 1 i పెంచడం.

66
00:03:05,000 --> 00:03:09,580
ఇప్పుడు మేము సి లో ఉన్నాయి అనుకుంటే
మేము ఈ చేసిన బహుళ మార్గాలు.

67
00:03:09,580 --> 00:03:12,840
ఇక్కడ మేము కోడ్ జరిగింది
కొంత (నిజమైన) ఎప్పటికీ లూప్.

68
00:03:12,840 --> 00:03:16,600
కాబట్టి మేము కేవలం నేను వేరియబుల్ డిక్లేర్
వంటి మేము స్క్రాచ్ లో వేరియబుల్ నేను కలిగి.

69
00:03:16,600 --> 00:03:21,950
వేరియబుల్ నేను డిక్లేర్, మరియు ఎప్పటికీ
(నిజమైన), మేము వేరియబుల్ నేను చెప్పటానికి.

70
00:03:21,950 --> 00:03:25,260
Printf% ఐ కెన్ లేదా మీరు% d ఉపయోగించి కాలేదు కాబట్టి.

71
00:03:25,260 --> 00:03:27,985
మేము ఆ వేరియబుల్, మరియు
అది పెంచడం, నేను ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> ప్రశ్న ఏడు.

74
00:03:30,830 --> 00:03:35,560
ఇప్పుడు మేము సమానమైన ఏదో చేయాలనుకుంటున్నారా
మారియో డాట్ సి సమస్య నుండి ఒక సెట్.

75
00:03:35,560 --> 00:03:39,110
మేము ఈ hashtags ప్రింట్ మీరు,
మేము ఒక ఐదు ప్రింట్ మీరు

76
00:03:39,110 --> 00:03:40,700
ఈ hashes మూడు దీర్ఘ చతురస్రం.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
కాబట్టి ఎలా మేము అలా వెళ్తున్నారు?

79
00:03:43,162 --> 00:03:45,370
బాగా, మేము మీరు ఒక మొత్తం ఇవ్వాలని
కోడ్ యొక్క బంచ్, మరియు మీరు కేవలం

80
00:03:45,370 --> 00:03:47,560
ముద్రణ గ్రిడ్ ఫంక్షన్ వేస్తారు.

81
00:03:47,560 --> 00:03:49,540
>> కాబట్టి ఏమి PrintGrid ఎలా చేస్తుంది?

82
00:03:49,540 --> 00:03:51,480
బాగా మీరు గతంలో ఉన్నాము
వెడల్పు మరియు ఎత్తు.

83
00:03:51,480 --> 00:03:53,520
కాబట్టి మేము ఒక బాహ్య 4
లూప్, ఆ మళ్ళీ వెతికినా యొక్క

84
00:03:53,520 --> 00:03:57,650
ఈ అన్ని వరుసలను పైగా
మేము ముద్రించాలా కావలసిన గ్రిడ్.

85
00:03:57,650 --> 00:04:01,250
అప్పుడు మేము, ఇంటర్ సమూహ 4 లూప్
ప్రతి కాలమ్ పై ముద్రణ.

86
00:04:01,250 --> 00:04:06,210
కాబట్టి ప్రతి వరుస కోసం, మేము కోసం ప్రింట్
ప్రతి కాలమ్, ఒకే హాష్.

87
00:04:06,210 --> 00:04:10,045
అప్పుడు వరుసగా చివరిలో మేము ప్రింట్ ఒక
ఒకే కొత్త లైన్ తదుపరి వరుస వెళ్ళడానికి.

88
00:04:10,045 --> 00:04:11,420
మరియు ఆ మొత్తం గ్రిడ్ కోసం అంతే.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> ప్రశ్నను ఎనిమిది.

91
00:04:13,675 --> 00:04:17,170
PrintGrid వంటి ఒక ఫంక్షన్ చెబుతారు
తిరిగి ఒక వైపు ప్రభావం, కానీ

92
00:04:17,170 --> 00:04:17,670
విలువ.

93
00:04:17,670 --> 00:04:19,209
వ్యత్యాసం వివరించండి.

94
00:04:19,209 --> 00:04:23,080
కాబట్టి ఈ మీరు గుర్తు ఆధారపడుతుంది
ఒక వైపు ప్రభావం ఏమిటి.

95
00:04:23,080 --> 00:04:25,180
బాగా, తిరిగి విలువ
మేము PrintGrid లేదు తెలుసు

96
00:04:25,180 --> 00:04:28,180
నుండి, తిరిగి విలువ కలిగి
ఇక్కడే అది తప్ప చెప్పారు.

97
00:04:28,180 --> 00:04:31,150
తప్ప తిరిగి కాబట్టి ఏదైనా
నిజంగా ఏదైనా తిరిగి లేదు.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
కాబట్టి వైపు ప్రభావం ఏమిటి?

100
00:04:33,620 --> 00:04:36,620
బాగా, ఒక వైపు ప్రభావం
విధమైన అలాగే ఏదైనా

101
00:04:36,620 --> 00:04:39,500
ఫంక్షన్ ముగుస్తుంది తర్వాత
ఆ, కేవలం తిరిగి కాదు

102
00:04:39,500 --> 00:04:41,340
మరియు అది కేవలం ఇన్పుట్లను నుండి కాదు.

103
00:04:41,340 --> 00:04:44,970
>> కాబట్టి, ఉదాహరణకు, మేము వాటిని
ఒక ప్రపంచ వేరియబుల్ మార్చడానికి.

104
00:04:44,970 --> 00:04:46,590
ఒక వైపు ప్రభావం ఉంటుంది.

105
00:04:46,590 --> 00:04:49,000
ఈ ప్రత్యేక సందర్భంలో, ఒక
చాలా ముఖ్యమైన వైపు ప్రభావం

106
00:04:49,000 --> 00:04:51,070
స్క్రీన్ ప్రింటింగ్.

107
00:04:51,070 --> 00:04:53,110
కాబట్టి ఒక వైపు ప్రభావం
ఆ PrintGrid ఉంది.

108
00:04:53,110 --> 00:04:54,980
మేము స్క్రీన్ ఈ విషయాలు ప్రింట్.

109
00:04:54,980 --> 00:04:56,370
మరియు మీరు యొక్క ఆలోచించవచ్చు
ఆ దుష్ప్రభావాన్ని,

110
00:04:56,370 --> 00:04:58,690
ఏదో నుండి
ఈ ఫంక్షన్ ముగుస్తుంది తర్వాత కొనసాగితే.

111
00:04:58,690 --> 00:05:01,481
ఆ నడవడిక ఏదో
ఈ ఫంక్షన్ యొక్క చివరికి

112
00:05:01,481 --> 00:05:03,380
మార్చబడింది,
స్క్రీన్ విషయాలు.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> ప్రశ్నను తొమ్మిది.

115
00:05:05,839 --> 00:05:07,880
, క్రింద కార్యక్రమం పరిగణించండి
లైన్ సంఖ్యలు

116
00:05:07,880 --> 00:05:09,740
జతచేయబడెను
చర్చ కొరకు.

117
00:05:09,740 --> 00:05:13,480
ఈ కార్యక్రమంలో, మేము కేవలం ఉన్నాయి
నిల్వ, GetString కాల్

118
00:05:13,480 --> 00:05:16,220
ఈ వేరియబుల్ s లో, మరియు అప్పుడు
ఆ వేరియబుల్ s ప్రింటింగ్.

119
00:05:16,220 --> 00:05:16,720
సరే.

120
00:05:16,720 --> 00:05:19,090
లైన్ ఒక ప్రస్తుతం ఎందుకు వివరించేందుకు.

121
00:05:19,090 --> 00:05:20,920
# ఉన్నాయి CS50 డాట్ h.

122
00:05:20,920 --> 00:05:23,820
ఎందుకు మేము CS50 డాట్ h # ఉన్నాయి అవసరం లేదు?

123
00:05:23,820 --> 00:05:26,180
మనము కాల్
ఫంక్షన్ GetString,

124
00:05:26,180 --> 00:05:28,840
మరియు GetString నిర్వచిస్తారు
CS50 లైబ్రరీ లో.

125
00:05:28,840 --> 00:05:31,600
మేము లేదు ఉంటే
# ఉన్నాయి CS50 డాట్ h,

126
00:05:31,600 --> 00:05:35,760
మేము ఆ పరిపూర్ణ ప్రకటన పొందుతారు
GetString ఫంక్షన్ లోపం

127
00:05:35,760 --> 00:05:36,840
కంపైలర్ నుండి.

128
00:05:36,840 --> 00:05:40,110
కాబట్టి మేము లైబ్రరీ ఉన్నాయి అవసరం
మేము శీర్షిక ఫైలు ఉన్నాయి అవసరం,

129
00:05:40,110 --> 00:05:42,870
లేదంటే కంపైలర్ లేదు
GetString ఉంది గుర్తించాయి.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> లైన్ రెండు ప్రస్తుతం ఎందుకు వివరించేందుకు.

132
00:05:46,140 --> 00:05:47,890
ప్రామాణిక IO డాట్ h.

133
00:05:47,890 --> 00:05:50,430
ఇది ఖచ్చితంగా అదే ఉంది
మునుపటి సమస్యగా,

134
00:05:50,430 --> 00:05:53,310
బదులుగా వ్యవహరించేందుకు తప్ప
GetString, మేము printf గురించి మాట్లాడటం.

135
00:05:53,310 --> 00:05:56,654
మేము మేము అవసరం అనలేదు కాబట్టి
ప్రామాణిక IO డాట్ h ఉన్నాయి,

136
00:05:56,654 --> 00:05:58,820
అప్పుడు మేము చేయలేరు
printf ఫంక్షన్ ఉపయోగించడానికి,

137
00:05:58,820 --> 00:06:00,653
కంపైలర్ ఎందుకంటే
దాని గురించి తెలియదు.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- ప్రాముఖ్యత ఏమిటి
లైన్ నాలుగు లో రద్దు?

140
00:06:05,260 --> 00:06:08,010
ఇక్కడ మేము Int ప్రధాన (తప్ప) కలిగి.

141
00:06:08,010 --> 00:06:10,600
కేవలం ఆ మేము మాట్లాడుతూ
ఏ కమాండ్ లైన్ పొందడానికి లేదు

142
00:06:10,600 --> 00:06:12,280
ప్రధాన వాదనలు.

143
00:06:12,280 --> 00:06:17,390
మేము Int చెప్పడానికి అని గుర్తుంచుకో
ప్రధాన Int argc స్ట్రింగ్ argv బ్రాకెట్లలో.

144
00:06:17,390 --> 00:06:20,400
ఇక్కడ మేము కేవలం మేము చెప్పటానికి తప్ప సే
ఆదేశ పంక్తి వాదనలు విస్మరిస్తూ ఉంటాయి.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> సరిగ్గా, మెమరీ సంబంధించి, వివరించేందుకు
లైన్ లో ఏమి GetString ఆరు తిరిగి.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString ఒక బ్లాక్ తిరిగి
మెమరీ, అక్షరాలు యొక్క వ్యూహం.

149
00:06:31,640 --> 00:06:34,870
ఇది నిజంగా ఒక తిరిగి
మొదటి పాత్ర పాయింటర్.

150
00:06:34,870 --> 00:06:37,170
ఒక స్ట్రింగ్ ఒక చార్ స్టార్ అని గుర్తుంచుకోండి.

151
00:06:37,170 --> 00:06:41,360
కాబట్టి మొదటి ఒక పాయింటర్ ఉంది
పాత్ర సంసార స్ట్రింగ్

152
00:06:41,360 --> 00:06:43,510
యూజర్ కీబోర్డ్ వద్ద ప్రవేశించిన.

153
00:06:43,510 --> 00:06:47,070
మరియు ఆ మెమరీ malloced నిర్మాణము,
కాబట్టి ఆ మెమరీ కుప్ప ఉంది.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> ప్రశ్న 13.

156
00:06:50,450 --> 00:06:51,960
క్రింద ప్రోగ్రామ్ పరిగణించండి.

157
00:06:51,960 --> 00:06:55,579
కాబట్టి అన్ని ఈ కార్యక్రమం చేస్తున్న
10 ద్వారా విభజించబడింది 1 printf కనుట ఉంది.

158
00:06:55,579 --> 00:06:57,370
కాబట్టి సంకలనం మరియు
అమలు, ఈ కార్యక్రమం

159
00:06:57,370 --> 00:07:01,170
ప్రతిఫలాన్ని 0.0, అయినప్పటికీ
10 ద్వారా విభజించబడింది 1 0.1 ఉంది.

160
00:07:01,170 --> 00:07:02,970
ఎందుకు 0.0 ఉంది?

161
00:07:02,970 --> 00:07:05,510
బాగా, ఈ ఎందుకంటే ఉంది
పూర్ణాంక విభజన యొక్క.

162
00:07:05,510 --> 00:07:08,580
కాబట్టి 1 పూర్ణాంకం 10 పూర్ణాంకం ఉంది.

163
00:07:08,580 --> 00:07:11,980
కాబట్టి 1 10, ప్రతిదీ ద్వారా విభజించబడింది
పూర్ణాంకాల పరిగణిస్తారు,

164
00:07:11,980 --> 00:07:16,380
మరియు సి లో, మేము పూర్ణాంక విభజన చేసినప్పుడు,
మేము ఏ దశాంశ పాయింట్ ఖండించు.

165
00:07:16,380 --> 00:07:19,590
కాబట్టి 1 10 ద్వారా విభజించబడింది
0, మరియు అప్పుడు మేము ప్రయత్నిస్తున్న

166
00:07:19,590 --> 00:07:24,410
కాబట్టి, ఒక ఫ్లోట్ ఆ ప్రింట్
ఒక ఫ్లోట్ గా ముద్రించిన సున్నా 0.0 ఉంది.

167
00:07:24,410 --> 00:07:27,400
మేము 0.0 పొందండి ఎందుకు మరియు ఆ.

168
00:07:27,400 --> 00:07:28,940
>> క్రింద ప్రోగ్రామ్ పరిగణించండి.

169
00:07:28,940 --> 00:07:31,280
ఇప్పుడు మేము 0.1 ప్రింటింగ్.

170
00:07:31,280 --> 00:07:34,280
అందువలన పూర్ణాంక విభజన,
మేము కేవలం, 0.1 ప్రింటింగ్

171
00:07:34,280 --> 00:07:37,100
కానీ మేము అది ప్రింటింగ్
28 దశాంశ స్థానాల వరకు.

172
00:07:37,100 --> 00:07:41,810
మరియు మేము ఈ 0,1000, ఒక మొత్తం బంచ్ పొందండి
సున్నాలు, 5 5 5, బ్లా బ్లా బ్లా.

173
00:07:41,810 --> 00:07:45,495
అది ఎందుకు ఇక్కడ ప్రశ్న
బదులుగా సరిగ్గా 0.1 యొక్క, ఆ ప్రింట్?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> ఇక్కడ కారణం ఇప్పుడు ఉంది
పాయింట్ imprecision తేలియాడే.

176
00:07:49,640 --> 00:07:53,410
ఫ్లోట్ మాత్రమే 32 బిట్స్ ఉంది గుర్తుంచుకోండి.

177
00:07:53,410 --> 00:07:57,540
కాబట్టి మేము కేవలం పరిమిత సంఖ్య ప్రాతినిధ్యం చేయవచ్చు
ఆ 32 తో ఫ్లోటింగ్ పాయింట్ విలువలు

178
00:07:57,540 --> 00:07:58,560
బిట్స్.

179
00:07:58,560 --> 00:08:01,760
బాగా చివరికి అనంతమైన ఉంది
అనేక ఫ్లోటింగ్ పాయింట్ విలువలు,

180
00:08:01,760 --> 00:08:04,940
మరియు ఫ్లోటింగ్ అనంతం ఉంది
0 మరియు 1 మధ్య పాయింట్ విలువలు,

181
00:08:04,940 --> 00:08:07,860
మరియు మేము ఖచ్చితంగా చూడగలరని
ఆ కంటే మరింత విలువలను సూచిస్తాయి.

182
00:08:07,860 --> 00:08:13,230
కాబట్టి మేము త్యాగం చేయడానికి కలిగి
అత్యంత విలువలు ప్రాతినిధ్యం చెయ్యడానికి.

183
00:08:13,230 --> 00:08:16,960
>> కాబట్టి 0.1 వంటి క్రింది, స్పష్టంగా
మేము ఖచ్చితంగా ప్రాతినిధ్యం కాదు.

184
00:08:16,960 --> 00:08:22,500
కాబట్టి బదులుగా 0.1 ప్రాతినిధ్యం మేము
ఉత్తమ మేము ఈ 0.100000 5 5 సూచిస్తుంది

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
మరియు ఆ, చాలా దగ్గరలో కానీ
అప్లికేషన్లు చాలా కోసం

187
00:08:26,306 --> 00:08:28,430
మీరు గురించి ఆందోళన
పాయింట్ imprecision తేలియాడే,

188
00:08:28,430 --> 00:08:30,930
మేము కేవలం ప్రాతినిధ్యం కాదు ఎందుకంటే
అన్ని పాయింట్లు ఖచ్చితంగా ఫ్లోటింగ్.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> ప్రశ్న 15.

191
00:08:33,380 --> 00:08:34,679
క్రింద కోడ్ పరిగణించండి.

192
00:08:34,679 --> 00:08:36,630
మేము కేవలం 1 ప్లస్ 1 ప్రింటింగ్.

193
00:08:36,630 --> 00:08:38,289
ఇక్కడ ఏ ట్రిక్ ఉంది.

194
00:08:38,289 --> 00:08:41,780
1 ప్లస్ 1 2 మదింపు, మరియు
అప్పుడు మేము ఆ ప్రింటింగ్.

195
00:08:41,780 --> 00:08:42,789
ఈ కేవలం 2 ముద్రిస్తుంది.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> ప్రశ్న 16.

198
00:08:44,700 --> 00:08:49,450
ఇప్పుడు మేము పాత్ర ప్రింటింగ్
1 ప్లస్ పాత్ర 1.

199
00:08:49,450 --> 00:08:52,110
ఎందుకు ఈ లేదు
ఇదే ముద్రించడానికి?

200
00:08:52,110 --> 00:08:57,680
బాగా పాత్ర 1 ప్లస్ పాత్ర
1, పాత్ర 1 ASCII విలువ 49 ఉంది.

201
00:08:57,680 --> 00:09:04,840
కాబట్టి ఈ నిజంగా 49 మాట్లాడుతూ ప్లస్ 49, మరియు ఉంది
చివరికి ఈ 98 ప్రింట్ అన్నారు.

202
00:09:04,840 --> 00:09:06,130
కాబట్టి ఈ 2 ప్రింట్ లేదు.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> ప్రశ్న 17.

205
00:09:09,271 --> 00:09:11,520
అమలు పూర్తి
విధంగా క్రింద బేసి

206
00:09:11,520 --> 00:09:14,615
ఫంక్షన్ ఉంటే నిజమైన తిరిగి
n కూడా ఉంటే n బేసి మరియు తప్పుగా.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
ఈ ఒక గొప్ప ప్రయోజనం ఉంది
mod ఆపరేటర్లు కోసం.

209
00:09:19,330 --> 00:09:24,530
కాబట్టి మేము మా వాదన n తీసుకోవాలని,
n mod 2 బాగా 1, సమానం

210
00:09:24,530 --> 00:09:28,030
ఆ n విభజించబడింది అర్థం
2 ఒక మిగిలిన కలిగి.

211
00:09:28,030 --> 00:09:33,270
N 2 ద్వారా విభజించబడింది ఉంటే, ఒక మిగిలిన ఉందని
n బేసి, కాబట్టి మేము నిజమైన తిరిగి అర్థం.

212
00:09:33,270 --> 00:09:34,910
ఎల్స్ మేము తప్పుడు తిరిగి.

213
00:09:34,910 --> 00:09:39,070
మీరు కూడా 2 సమానం అంటే n చేసి
సున్నా, వేరే, తప్పుడు తిరిగి నిజమైన తిరిగి.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> క్రింద పునరావృత ఫంక్షన్ పరిగణించండి.

216
00:09:43,640 --> 00:09:46,920
N ఉంటే కాబట్టి కంటే తక్కువ లేదా
1 తిరిగి, 1 సమానంగా,

217
00:09:46,920 --> 00:09:50,430
n మైనస్ 1 యొక్క f వేరే తిరిగి n సార్లు.

218
00:09:50,430 --> 00:09:52,556
కాబట్టి ఈ ఫంక్షన్ ఏమిటి?

219
00:09:52,556 --> 00:09:54,305
బాగా, ఈ కేవలం ఉంది
కారకమైన ఫంక్షన్.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
ఈ చక్కగా ప్రాతినిధ్యం
n కారకమైన వంటి.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> కాబట్టి ఇప్పుడు 19 ప్రశ్న, మేము కావలసిన
ఈ పునరావృత ఫంక్షన్ పడుతుంది.

224
00:10:02,310 --> 00:10:04,530
మేము అది పునరుక్తి చేయడానికి కావలసిన.

225
00:10:04,530 --> 00:10:05,874
కాబట్టి ఎలా మేము అలా లేదు?

226
00:10:05,874 --> 00:10:07,790
బాగా సిబ్బంది కోసం
పరిష్కారం, మరియు మళ్ళీ ఉంది

227
00:10:07,790 --> 00:10:11,090
మీరు చేసిన బహుళ మార్గాలు
, మేము ఈ Int ఉత్పత్తి ప్రారంభం

228
00:10:11,090 --> 00:10:11,812
1 సమానం.

229
00:10:11,812 --> 00:10:13,520
మరియు ఈ అంతటా
లూప్, మేము వెళుతున్న

230
00:10:13,520 --> 00:10:17,590
చివరికి ఉత్పత్తి గుణించడం వుంటుంది
పూర్తి కారకమైన తో ముగుస్తుంది.

231
00:10:17,590 --> 00:10:21,870
పూర్ణాంకానికి నేను 2 సమానం కాబట్టి, నేను
కంటే తక్కువ లేదా n సమానం, నేను ++.

232
00:10:21,870 --> 00:10:24,130
>> నేను 2 సమానం ఎందుకు మీరు wondering కావచ్చు.

233
00:10:24,130 --> 00:10:28,380
బాగా, మేము కలిగి ఇక్కడ గుర్తుంచుకోవాలి
మా బేస్ కేసు సరైనది నిర్ధారించుకోండి.

234
00:10:28,380 --> 00:10:32,180
N కంటే తక్కువ లేదా సమానం చేస్తే
1 కు, మేము కేవలం 1 తిరిగి చేస్తున్నారు.

235
00:10:32,180 --> 00:10:34,830
నేను 2 సమానం వద్ద ఇక్కడ కాబట్టి, మేము ప్రారంభం.

236
00:10:34,830 --> 00:10:39,090
మరియు నేను 1, ఒకవేళ అప్పుడు వాట్ లేదా
n లూప్ అప్పుడు 1, అయితే

237
00:10:39,090 --> 00:10:40,600
అన్ని అమలు కాదు.

238
00:10:40,600 --> 00:10:43,190
కాబట్టి మేము కేవలం ఆ
1 ఇది తిరిగి ఉత్పత్తి.

239
00:10:43,190 --> 00:10:45,920
అదేవిధంగా, ఉంటే n ఉన్నాయి
కంటే తక్కువ ఏదైనా 1 ఉంటుంది

240
00:10:45,920 --> 00:10:49,290
ఇది 0, అయితే ప్రతికూల 1, సంసార
మేము ఇప్పటికీ, 1 తిరిగి లోనవుతాను

241
00:10:49,290 --> 00:10:52,260
ఇది సరిగ్గా ఏమిటి
పునరావృత వెర్షన్ చేస్తోంది.

242
00:10:52,260 --> 00:10:54,660
>> ఇప్పుడు, n ఎక్కువ ఉంటే
1 కంటే, అప్పుడు మేము చూడాలని

243
00:10:54,660 --> 00:10:56,550
కనీసం ఒక చేయడానికి
ఈ లూప్ యొక్క పునరుక్తి.

244
00:10:56,550 --> 00:11:00,630
కాబట్టి అప్పుడు మేము ఉన్నాము, యొక్క n 5 అని పిలవబడు
ఉత్పత్తి సార్లు చేయ 2 సమానం.

245
00:11:00,630 --> 00:11:02,165
కాబట్టి ఇప్పుడు ఉత్పత్తి 2.

246
00:11:02,165 --> 00:11:04,040
ఇప్పుడు మేము చేయబోతున్నామని
ఉత్పత్తి సార్లు 3 సమానం.

247
00:11:04,040 --> 00:11:04,690
ఇప్పుడు అది 6.

248
00:11:04,690 --> 00:11:07,500
ఉత్పత్తి సార్లు ఇప్పుడు అది 24 ఉంది, 4 సమానం.

249
00:11:07,500 --> 00:11:10,420
ఉత్పత్తి సార్లు ఇప్పుడు అది 120 వార్తలు, 5 సమానం.

250
00:11:10,420 --> 00:11:16,730
కాబట్టి చివరికి, మేము తిరిగి
సరిగ్గా 5 కారకమైన ఇది 120,.

251
00:11:16,730 --> 00:11:17,510
>> ప్రశ్న 20.

252
00:11:17,510 --> 00:11:22,480
ఈ మీరు పూరించడానికి ఉన్న ఒకటి
ఏ అల్గోరిథం ఈ పట్టికలో,

253
00:11:22,480 --> 00:11:25,735
మేము చూసిన ఏదైనా, ఆ
ఈ క్రమసూత్ర అమలు సరిపోతుంది

254
00:11:25,735 --> 00:11:28,060
సార్లు ఈ asymptotic పరుగుల సార్లు.

255
00:11:28,060 --> 00:11:33,270
కాబట్టి ఒక అల్గోరిథం ఏమిటి అని
1 యొక్క ఒమేగా, కానీ n యొక్క పెద్ద O ఉంది?

256
00:11:33,270 --> 00:11:35,970
కాబట్టి అనంతమైన ఉండవచ్చు
ఇక్కడ అనేక సమాధానాలు.

257
00:11:35,970 --> 00:11:39,790
మేము బహుశా చాలా చూసిన ఒక
తరచుగా కేవలం సరళ శోధన.

258
00:11:39,790 --> 00:11:42,050
>> ఉత్తమ సందర్భంలో
దృష్టాంతంలో, మేము ఉన్నాము అంశం

259
00:11:42,050 --> 00:11:44,050
కోసం చూస్తున్న ఉంది
జాబితా ప్రారంభం

260
00:11:44,050 --> 00:11:47,400
అందువలన 1 దశలను ఒమేగా,
మేము తనిఖీ మొదటి విషయం,

261
00:11:47,400 --> 00:11:49,740
మేము కేవలం వెంటనే తిరిగి
మేము అంశం దొరకలేదు.

262
00:11:49,740 --> 00:11:52,189
చెత్త దృష్టాంతంలో,
అంశం, చివరిలో ఉంది

263
00:11:52,189 --> 00:11:53,730
లేదా అంశం వద్ద అన్ని జాబితాలో.

264
00:11:53,730 --> 00:11:56,700
కాబట్టి మేము శోధించడానికి
మొత్తం జాబితా, అన్ని n

265
00:11:56,700 --> 00:11:58,480
అంశాలు, మరియు అది n యొక్క O వై.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> కాబట్టి ఇప్పుడు అది రెండు అని ఏదో
n లాగ్ n యొక్క ఒమేగా, మరియు n లాగ్ n యొక్క పెద్ద O.

268
00:12:04,880 --> 00:12:08,650
బాగా అత్యంత సంబంధిత విషయం
మేము ఇక్కడ చూడవచ్చు విధమైన విలీనం చేసిన.

269
00:12:08,650 --> 00:12:12,950
కాబట్టి విధమైన, గుర్తు విలీనం,
చివరికి తీట

270
00:12:12,950 --> 00:12:16,920
తీటా నిర్వచించబడింది n లాగ్ n, యొక్క
ఒమేగా మరియు పెద్ద O ఒకే ఉంటే.

271
00:12:16,920 --> 00:12:17,580
రెండు n లాగ్.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> ఒమేగా ఏదో ఏమిటి
n యొక్క, మరియు n ఓ స్క్వేర్డ్?

274
00:12:21,970 --> 00:12:23,990
బాగా, మళ్ళీ ఉంది
బహుళ సాధ్యం సమాధానాలు.

275
00:12:23,990 --> 00:12:26,440
ఇక్కడ మేము బబుల్ సార్ట్ చెప్పడానికి జరిగే.

276
00:12:26,440 --> 00:12:28,840
చొప్పించడం విధమైన కూడా ఇక్కడ పని.

277
00:12:28,840 --> 00:12:31,400
బబుల్ సార్ట్ గుర్తుంచుకో
ఆప్టిమైజేషన్ పేరు ఉంది,

278
00:12:31,400 --> 00:12:34,630
మీరు పొందవచ్చు ఉంటే
మొత్తం జాబితా ద్వారా

279
00:12:34,630 --> 00:12:37,402
చేయడానికి అవసరం లేకుండా
ఏ మార్పిడులు, అప్పుడు, బాగా,

280
00:12:37,402 --> 00:12:40,110
మేము వెంటనే ఆ తిరిగి
జాబితా ప్రారంభించడానికి క్రమబద్ధీకరించబడతాయి.

281
00:12:40,110 --> 00:12:43,185
, ఉత్తమ దృష్టాంతంలో కాబట్టి
అది n యొక్క ఒమేగా ఉంది.

282
00:12:43,185 --> 00:12:45,960
అది కేవలం ఒక చక్కగా కాకపోతే
, తో ప్రారంభించడానికి జాబితా క్రమబద్ధీకరించబడింది

283
00:12:45,960 --> 00:12:48,270
అప్పుడు మేము n యొక్క O మార్పిడులు స్క్వేర్డ్ కలిగి.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
చివరకు, మేము ఎంపిక విధమైన కలిగి
స్క్వేర్డ్ n కోసం, ఒమేగా మరియు పెద్ద ఓ రెండు

286
00:12:55,610 --> 00:12:56,850
>> ప్రశ్న 21.

287
00:12:56,850 --> 00:12:58,870
పూర్ణాంక ఓవర్ఫ్లో ఏమిటి?

288
00:12:58,870 --> 00:13:02,160
బాగా మళ్ళీ, ముందు పోలి,
మేము మాత్రమే పరిమిత పలు బిట్స్

289
00:13:02,160 --> 00:13:04,255
పూర్ణాంకం ప్రాతినిధ్యం,
కాబట్టి 32 బిట్స్.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
యొక్క మేము ఒక సంతకం పూర్ణాంక కలిగి చెప్పారు.

292
00:13:09,180 --> 00:13:12,800
అప్పుడు చివరికి అత్యధిక
అనుకూల సంఖ్య మేము సూచిస్తుంది

293
00:13:12,800 --> 00:13:15,910
2 కు 31 మైనస్ 1.

294
00:13:15,910 --> 00:13:19,370
మేము ప్రయత్నించండి చేస్తే ఏమి జరుగుతుంది
ఆ పూర్ణాంక పెంచడం?

295
00:13:19,370 --> 00:13:25,320
బాగా, మేము 31 2 నుంచి చూడాలని
మైనస్ 1, డౌన్ ప్రతికూల 2 వరకు

296
00:13:25,320 --> 00:13:26,490
31 కు.

297
00:13:26,490 --> 00:13:29,470
కాబట్టి ఈ పూర్ణాంక ఓవర్ఫ్లో ఉంది
మీరు పెంచడం ఉంచండి ఉన్నప్పుడు,

298
00:13:29,470 --> 00:13:32,330
మరియు చివరికి మీరు కాదు
ఉన్నత మరియు అది కేవలం

299
00:13:32,330 --> 00:13:34,520
తిరిగి అన్ని మార్గం మూటగట్టి
ప్రతికూల విలువ చుట్టూ.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> ఒక బఫర్ ఓవర్ఫ్లో గురించి ఏమిటి?

302
00:13:37,779 --> 00:13:39,820
కాబట్టి ఒక బఫర్ overflow--
బఫర్ గుర్తు.

303
00:13:39,820 --> 00:13:41,000
ఇది కేవలం మెమరీ భాగం ఉంది.

304
00:13:41,000 --> 00:13:43,350
వ్యూహం లాగ బఫర్.

305
00:13:43,350 --> 00:13:46,120
కాబట్టి ఒక బఫర్ ఓవర్ఫ్లో ఉన్నప్పుడు ఉంది
మీరు మెమరీ యాక్సెస్ ప్రయత్నించండి

306
00:13:46,120 --> 00:13:47,880
ఆ శ్రేణి ముగింపు మించి.

307
00:13:47,880 --> 00:13:50,410
మీరు ఒక ఉంటే
పరిమాణం 5 మరియు మీరు శ్రేణి

308
00:13:50,410 --> 00:13:53,700
శ్రేణి బ్రాకెట్ యాక్సెస్ ప్రయత్నించండి
5 లేదా బ్రాకెట్ 6 లేదా బ్రాకెట్ 7,

309
00:13:53,700 --> 00:13:56,610
దాటి లేదా ఏదైనా
ముగింపు, లేదా ఏదైనా

310
00:13:56,610 --> 00:14:00,790
below-- శ్రేణి బ్రాకెట్ ప్రతికూల 1 ఉంటుంది
ఆ అన్ని బఫర్ ఓవర్ఫ్లో ఉన్నాయి.

311
00:14:00,790 --> 00:14:02,810
మీరు చెడు మార్గాల్లో మెమరీ తాకిన చేస్తున్నారు.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> ప్రశ్న 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
మీరు అవసరం ఈ ఒక లో కాబట్టి
strlen అమలు.

316
00:14:09,100 --> 00:14:11,630
మరియు మేము మీరు ఆ మీరు చెప్పండి
లు శూన్య ఉండదు ఊహించుకోవటం,

317
00:14:11,630 --> 00:14:13,790
కాబట్టి మీరు లేదు
శూన్య ఏ చెక్.

318
00:14:13,790 --> 00:14:16,190
మరియు బహుళ మార్గాలు ఉన్నాయి
మీరు ఈ చేసి.

319
00:14:16,190 --> 00:14:18,440
ఇక్కడ మేము కేవలం నేరుగా.

320
00:14:18,440 --> 00:14:21,780
మేము n, కౌంటర్ ప్రారంభం. n ఉంది
ఎన్ని అక్షరాలు లెక్కింపు.

321
00:14:21,780 --> 00:14:25,560
కాబట్టి మేము 0 వద్ద మొదలు, మరియు
మొత్తం జాబితా పై iterate.

322
00:14:25,560 --> 00:14:29,092
>> సమానం బ్రాకెట్ 0
శూన్య టెర్మినేటర్ పాత్ర?

323
00:14:29,092 --> 00:14:31,425
మేము చూస్తున్న గుర్తుంచుకో
శూన్య టెర్మినేటర్ పాత్ర

324
00:14:31,425 --> 00:14:33,360
మా స్ట్రింగ్ ఎంత గుర్తించడానికి.

325
00:14:33,360 --> 00:14:35,890
ఆ రద్దు అన్నారు
ఏ సంబంధిత స్ట్రింగ్.

326
00:14:35,890 --> 00:14:39,400
కాబట్టి యొక్క బ్రాకెట్ సమానం 0
శూన్య టెర్మినేటర్ కు?

327
00:14:39,400 --> 00:14:42,850
అలా కాకపోతే, అప్పుడు మేము చూడాలని
లు బ్రాకెట్ 1, లు బ్రాకెట్ 2 చూడండి.

328
00:14:42,850 --> 00:14:45,050
మేము వరకు కొనసాగించడాన్ని
శూన్య టెర్మినేటర్ కనుగొనేందుకు.

329
00:14:45,050 --> 00:14:48,580
మేము అది అనిపిస్తే, n కలిగి
స్ట్రింగ్ యొక్క మొత్తం పొడవు,

330
00:14:48,580 --> 00:14:49,942
మరియు మేము ఆ తిరిగి.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> ప్రశ్న 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
కాబట్టి ఈ ఒక ఇక్కడ మీరు
వాణిజ్యం చేసుకోవాలి.

335
00:14:56,050 --> 00:14:59,810
కాబట్టి ఒక విషయం ఒక మంచి ఉంది
, కానీ ఏ విధంగా మార్గం చెడ్డది?

336
00:14:59,810 --> 00:15:02,980
ఇక్కడ, విలీనం విధమైన ఉంటుంది
బబుల్ సార్ట్ కంటే వేగంగా.

337
00:15:02,980 --> 00:15:06,530
అక్కడ, బాగా ఆ చెప్పాడు
అనేక సమాధానాలను ఇక్కడ ఉన్నాయి.

338
00:15:06,530 --> 00:15:12,930
కానీ ప్రధాన ఒక బబుల్ సార్ట్ ఉంది
ఒక క్రమబద్ధీకరించబడతాయి జాబితా కోసం n యొక్క ఒమేగా ఉంది.

339
00:15:12,930 --> 00:15:14,950
>> మేము ముందుగా చూసిన పట్టిక గుర్తుంచుకో.

340
00:15:14,950 --> 00:15:17,600
బబుల్ యొక్క ఒమేగా రకాల
n, ఉత్తమ దృష్టాంతంలో

341
00:15:17,600 --> 00:15:20,010
అది కేవలం వెళ్ళి వీలు ఉంది
జాబితా ఒకసారి, గుర్తించడానికి

342
00:15:20,010 --> 00:15:22,270
హే ఈ విషయం ఇప్పటికే ఉంది
క్రమబద్ధీకరించిన మరియు తిరిగి.

343
00:15:22,270 --> 00:15:25,960
ఉన్నా, విలీనం విధమైన ఏమి
మీరు, n లాగ్ n యొక్క ఒమేగా ఉంది.

344
00:15:25,960 --> 00:15:29,200
క్రమబద్ధీకరించబడతాయి జాబితా కోసం, బబుల్ కాబట్టి
విధమైన వేగంగా చేస్తాడు.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> ఇప్పుడు జాబితాలు గురించి లింక్?

347
00:15:32,430 --> 00:15:36,070
కాబట్టి ఒక లింక్ జాబితా పెరుగుతాయి మరియు కుదించే చేయవచ్చు
కావలసినన్ని అంశాలను సరిపోయే.

348
00:15:36,070 --> 00:15:38,489
కాబట్టి ఆ చెప్పాడు
సాధారణంగా ప్రత్యక్ష పోలిక

349
00:15:38,489 --> 00:15:40,280
అనుబంధ అవతరిస్తుంది
వ్యూహం తో జాబితా.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
కాబట్టి కూడా శ్రేణుల అయితే
సులభంగా పెరుగుతాయి మరియు కుదించే

352
00:15:44,050 --> 00:15:47,130
అనేక అంశాలను సరిపోయే
అవసరమైన, ఒక లింక్ జాబితా

353
00:15:47,130 --> 00:15:49,600
ఒక శ్రేణి ఒక పోలిస్తే
శ్రేణి రాండమ్ యాక్సెస్ ఉంది.

354
00:15:49,600 --> 00:15:52,960
మేము ఏ సూచిక దీని
శ్రేణి యొక్క మూలకం.

355
00:15:52,960 --> 00:15:56,430
>> కాబట్టి ఒక లింక్ జాబితా కోసం, మేము కాదు
కేవలం ఐదవ మూలకం వెళ్ళండి,

356
00:15:56,430 --> 00:16:00,260
మేము ప్రారంభం నుండి ప్రయాణించేందుకు కలిగి
మేము ఐదవ మూలకం వచ్చేవరకు.

357
00:16:00,260 --> 00:16:03,990
మరియు ఆ నుండి మాకు నిరోధించడానికి చేస్తాడు
బైనరీ శోధన లాగ చేయడం.

358
00:16:03,990 --> 00:16:08,150
బైనరీ శోధన మాట్లాడుతూ, బైనరీ శోధన
సరళ శోధన కంటే వేగంగా ఉంటుంది.

359
00:16:08,150 --> 00:16:11,120
ఆ చెప్పాడు
కాబట్టి, ఒక సాధ్యం విషయం

360
00:16:11,120 --> 00:16:13,380
మీరు బైనరీ చెయ్యలేరని ఉంది
లింక్ జాబితాలు అన్వేషణ,

361
00:16:13,380 --> 00:16:14,730
మీరు మాత్రమే శ్రేణులపై చేయవచ్చు.

362
00:16:14,730 --> 00:16:18,030
కానీ బహుశా మరింత ముఖ్యంగా,
మీరు బైనరీ శోధన చెయ్యలేరు

363
00:16:18,030 --> 00:16:20,690
వర్గీకరించరు వ్యూహం మీద.

364
00:16:20,690 --> 00:16:23,990
ముందస్తు మీరు క్రమం అవసరం ఉండవచ్చు
శ్రేణి, మరియు అప్పుడు మాత్రమే చెయ్యవచ్చు

365
00:16:23,990 --> 00:16:25,370
మీరు బైనరీ శోధన.

366
00:16:25,370 --> 00:16:27,660
మీ విషయం కాదు ఉంటే
తో ప్రారంభించడానికి క్రమబద్ధీకరించబడతాయి,

367
00:16:27,660 --> 00:16:29,250
అప్పుడు సరళ శోధన వేగంగా కావచ్చు.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> ప్రశ్న 27.

370
00:16:31,740 --> 00:16:34,770
కాబట్టి క్రింద కార్యక్రమం పరిగణలోకి,
తదుపరి స్లయిడ్ ఉంటుంది.

371
00:16:34,770 --> 00:16:37,790
మరియు ఈ మేము ఎక్కడ ఒకటి
స్పష్టంగా రాష్ట్ర చేయకూడదని అన్నారు

372
00:16:37,790 --> 00:16:39,980
వివిధ వేరియబుల్స్ కోసం విలువలు.

373
00:16:39,980 --> 00:16:41,990
కాబట్టి యొక్క ఆ చూద్దాం.

374
00:16:41,990 --> 00:16:43,160
>> కాబట్టి ఒక లైన్.

375
00:16:43,160 --> 00:16:45,457
మేము Int x 1 సమానం.

376
00:16:45,457 --> 00:16:47,040
ఆ జరిగిందని మాత్రమే విషయం.

377
00:16:47,040 --> 00:16:50,440
కాబట్టి లైన్ ఒక వద్ద, మేము చూసే మా
పట్టిక, ఆ y, ఒక, బి, మరియు tmp అన్ని ఉన్నాయి

378
00:16:50,440 --> 00:16:51,540
బ్లాక్డ్ ఔట్.

379
00:16:51,540 --> 00:16:52,280
కాబట్టి x ఏమిటి?

380
00:16:52,280 --> 00:16:53,860
మనము దానిని 1 సమానము.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
ఆపై, బాగా, రెండు లైన్
మేము y 2 సెట్ చూడండి

383
00:16:58,770 --> 00:17:00,550
మరియు పట్టిక ఇప్పటికే ఉంది
మాకు పూరించిన.

384
00:17:00,550 --> 00:17:03,040
కాబట్టి x 1 మరియు y 2.

385
00:17:03,040 --> 00:17:05,890
>> ఇప్పుడు, లైన్ మూడు, మేము ఇప్పుడు ఉన్నాము
swap ఫంక్షన్ లోపల.

386
00:17:05,890 --> 00:17:07,560
మనం మారడానికి అధిగమించగలిగింది?

387
00:17:07,560 --> 00:17:11,609
మేము కోసం ఆంపర్సండ్ చిహ్నం x జారీ
బి కోసం ఒక, మరియు ఆంపర్సండ్ చిహ్నం y.

388
00:17:11,609 --> 00:17:15,160
ఎక్కడ సమస్య ముందు
పేర్కొంది x యొక్క చిరునామా

389
00:17:15,160 --> 00:17:17,520
0x10 ఉంది, మరియు y యొక్క చిరునామా 0x14 ఉంది.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
కాబట్టి ఒక మరియు బి సమానం
వరుసగా 0x10 మరియు 0x14,.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> ఇప్పుడు మూడు, x మరియు y ఏమిటి?

394
00:17:26,250 --> 00:17:28,554
బాగా, ఏమీ మార్చబడింది
ఈ సమయంలో x మరియు y గురించి.

395
00:17:28,554 --> 00:17:30,470
వారు ఉన్నారని
ఒక ప్రధాన స్టాక్ ఫ్రేమ్ లోపల,

396
00:17:30,470 --> 00:17:32,469
వారు ఇప్పటికీ అదే కలిగి
విలువలు వారు ముందు.

397
00:17:32,469 --> 00:17:34,030
మేము ఏ మెమరీ మార్పు లేదు.

398
00:17:34,030 --> 00:17:35,710
కాబట్టి x 1, y 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
అన్ని కుడి.

401
00:17:37,050 --> 00:17:40,300
కాబట్టి ఇప్పుడు మేము ఒక స్టార్ సమానంగా పూర్ణాంకానికి tmp చెప్పారు.

402
00:17:40,300 --> 00:17:44,410
కాబట్టి లైన్ నాలుగు, ప్రతిదీ వద్ద
tmp తప్ప అదే.

403
00:17:44,410 --> 00:17:47,130
మేము ఏ విలువలు మారలేదు
tmp తప్ప ఏదైనా యొక్క.

404
00:17:47,130 --> 00:17:49,230
మేము ఒక స్టార్ సమానంగా tmp సెట్.

405
00:17:49,230 --> 00:17:50,620
స్టార్ ఏమిటి?

406
00:17:50,620 --> 00:17:56,240
బాగా, ఒక పాయింట్లు x కు, కాబట్టి ఒక స్టార్
1 ఇది సమానంగా x, అన్నారు.

407
00:17:56,240 --> 00:18:00,080
కాబట్టి ప్రతిదీ కాపీ
డౌన్, మరియు tmp 1 సెట్.

408
00:18:00,080 --> 00:18:01,110
>> ఇప్పుడు తదుపరి లైన్.

409
00:18:01,110 --> 00:18:03,380
స్టార్ స్టార్ బి సమానం.

410
00:18:03,380 --> 00:18:10,000
కాబట్టి లైన్ ద్వారా five-- బాగా మళ్ళీ, ప్రతిదీ
స్టార్ ఏమైనా తప్ప అదే.

411
00:18:10,000 --> 00:18:10,830
స్టార్ ఏమిటి?

412
00:18:10,830 --> 00:18:13,720
బాగా, మేము కేవలం స్టార్ ఒక x చెప్పారు.

413
00:18:13,720 --> 00:18:16,400
కాబట్టి మేము సమాన స్టార్ బి x మారుస్తున్నాము.

414
00:18:16,400 --> 00:18:18,960
స్టార్ బి ఏమిటి? y. y బి పాయింట్లు.

415
00:18:18,960 --> 00:18:21,030
కాబట్టి స్టార్ బి y ఉంది.

416
00:18:21,030 --> 00:18:25,140
కాబట్టి మేము y కు x సమానంగా చేయడం చేస్తున్నారు
మరియు మిగతా వాటి ఉంటుంది.

417
00:18:25,140 --> 00:18:29,130
X ఇప్పుడు తదుపరి వరుసగా చూడండి
2, మరియు మిగిలిన డౌన్ కాపీ.

418
00:18:29,130 --> 00:18:31,120
>> ఇప్పుడు తదుపరి లైన్ లో, స్టార్ బి tmp సమానం.

419
00:18:31,120 --> 00:18:34,740
బాగా, మేము కేవలం స్టార్ బి y ఉంది అన్నారు,
కాబట్టి మేము tmp కు y సమానంగా చేయడం చేస్తున్నారు.

420
00:18:34,740 --> 00:18:37,450
మిగతావన్ని అదే ఉంది
కాబట్టి ప్రతిదీ డౌన్ కాపీ అవుతుంది.

421
00:18:37,450 --> 00:18:42,050
మేము ఇది tmp సమానంగా y సెట్ చేస్తున్నాము
వేరే ఒక, మరియు వాటి ఉంటుంది.

422
00:18:42,050 --> 00:18:43,210
>> ఇప్పుడు చివరకు, లైన్ ఏడు.

423
00:18:43,210 --> 00:18:44,700
మేము తిరిగి ప్రధాన ఫంక్షన్ లో ఉన్నాము.

424
00:18:44,700 --> 00:18:46,350
స్వాప్ ముగిసిన తర్వాత మేము.

425
00:18:46,350 --> 00:18:48,972
మేము ఒక, బి కోల్పోయింది, మరియు
tmp, కానీ మేము చివరికి

426
00:18:48,972 --> 00:18:51,180
ఏ విలువలు మారుతున్న లేదు
ఈ సమయంలో ఏదైనా,

427
00:18:51,180 --> 00:18:52,800
మేము x మరియు y డౌన్ కాపీ.

428
00:18:52,800 --> 00:18:56,490
మరియు మేము x మరియు y అని చూడండి
ఇప్పుడు 2 మరియు 1 బదులుగా 1 మరియు 2.

429
00:18:56,490 --> 00:18:58,160
స్వాప్ విజయవంతంగా అమలు చేసింది.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> ప్రశ్న 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
మీరు ఎదుర్కొనే అనుకుందాం
దోష సందేశాలు

434
00:19:03,100 --> 00:19:06,790
ఆఫీసు సమయాల్లో క్రింద
ఒక CA లేదా TF వచ్చే ఏడాది.

435
00:19:06,790 --> 00:19:08,930
ఈ లోపాలు ప్రతి పరిష్కరించడానికి ఎలా సలహా.

436
00:19:08,930 --> 00:19:11,160
GetString కాబట్టి వివరింపబడని సూచన.

437
00:19:11,160 --> 00:19:12,540
ఎందుకు మీరు ఈ చూడవచ్చు?

438
00:19:12,540 --> 00:19:15,380
బాగా, ఒక విద్యార్థి ఉపయోగిస్తుంటే
వారి కోడ్ లో GetString,

439
00:19:15,380 --> 00:19:20,310
వారు సరిగా CS50 ఉన్నాయి హాష్ చేశారు
డాట్ h CS50 లైబ్రరీ ఉన్నాయి.

440
00:19:20,310 --> 00:19:22,380
>> బాగా, వారు ఏమి
ఈ లోపం పరిష్కరించడానికి అవసరం?

441
00:19:22,380 --> 00:19:26,810
వారు ఒక డాష్ lcs50 ఏమి అవసరం
వారు కంపైల్ చేసినప్పుడు కమాండ్ లైన్.

442
00:19:26,810 --> 00:19:29,501
వారు పాస్ చేస్తే
గణగణమని ద్వని చేయు డాష్ lcs50, వారు ఉన్నారు

443
00:19:29,501 --> 00:19:32,000
అసలు ఏమీ ఉండదని
GetString అమలు కోడ్.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> ప్రశ్న 29.

446
00:19:34,170 --> 00:19:36,190
పరిపూర్ణంగా ప్రకటించారు
లైబ్రరీ ఫంక్షన్ strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
బాగా ఈ ఇప్పుడు, వారు కలిగి
సరైన హాష్ సాధిస్తారు ఉన్నాయి.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
ఈ ప్రత్యేక సందర్భంలో, శీర్షిక ఫైలు
వారు, స్ట్రింగ్ డాట్ h ఉంది ఉన్నాయి అవసరం

451
00:19:45,410 --> 00:19:48,710
మరియు ఇప్పుడు స్ట్రింగ్ డాట్ h, సహా
ఇప్పుడు విద్యార్థి కంపైలర్

452
00:19:48,710 --> 00:19:51,750
యాక్సెస్
strlen ప్రకటనలతో,

453
00:19:51,750 --> 00:19:54,120
మరియు అది తెలుసు మీ కోడ్
సరిగ్గా strlen ఉపయోగిస్తోంది.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> ప్రశ్న 30.

456
00:19:56,580 --> 00:20:00,240
మరిన్ని శాతం మార్పిడులు
డేటా వాదనలు కంటే.

457
00:20:00,240 --> 00:20:01,540
కాబట్టి ఈ ఏమి ఉంది?

458
00:20:01,540 --> 00:20:06,470
బాగా ఈ శాతం గుర్తుంచుకోవాలి
వారు printf సంబంధిత ఉన్నాము ఎలా signs--.

459
00:20:06,470 --> 00:20:08,890
కాబట్టి printf మేము percent-- ఉండవచ్చు
మేము ఏదో ప్రింట్ ఉండవచ్చు

460
00:20:08,890 --> 00:20:11,380
శాతం వంటి n నేను బాక్ స్లాష్.

461
00:20:11,380 --> 00:20:15,310
లేదా మేము, శాతం ఐ ప్రింట్ ఉండవచ్చు
స్పేస్, శాతం నేను, స్పేస్, శాతం నేను.

462
00:20:15,310 --> 00:20:18,950
ఆ ప్రతి కాబట్టి
చిహ్నాలు శాతం, మేము అవసరం

463
00:20:18,950 --> 00:20:21,560
printf చివరిలో ఒక వేరియబుల్ పాస్.

464
00:20:21,560 --> 00:20:26,980
>> కాబట్టి మేము చెప్పుకోవాలంటే printf బ్రాకెట్ శాతం
నేను, n దగ్గరగా బ్రాకెట్ బాక్ స్లాష్

465
00:20:26,980 --> 00:20:30,270
బాగా, మేము అని చెప్పటానికి
పూర్ణాంకం ప్రింట్ అన్నారు

466
00:20:30,270 --> 00:20:33,970
కానీ అప్పుడు మేము printf అనుమతించబడవు
పూర్ణాంకం వాస్తవానికి ప్రింట్.

467
00:20:33,970 --> 00:20:37,182
ఇక్కడ మరింత శాతం
డేటా వాదనలు కంటే మార్పిడులు?

468
00:20:37,182 --> 00:20:39,390
మేము కలిగి మాట్లాడుతూ
శాతాలు యొక్క మొత్తం బంచ్,

469
00:20:39,390 --> 00:20:42,445
మరియు మేము తగినంత వేరియబుల్స్ లేదు
నిజానికి ఆ శాతాలు పూరించడానికి.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> ఆపై ఖచ్చితంగా, ప్రశ్న 31 కోసం,
ఖచ్చితంగా ఒక బ్లాక్స్ లో 40 బైట్లు కోల్పోయారు.

472
00:20:50,010 --> 00:20:52,350
కాబట్టి ఈ ఒక Valgrind లోపం ఉంది.

473
00:20:52,350 --> 00:20:54,720
ఈ తెలిపాడు
ఎక్కడో మీ కోడ్ లో,

474
00:20:54,720 --> 00:20:59,010
మీరు 40 అని ఒక కేటాయింపు ఉంది
బైట్లు పెద్ద కాబట్టి మీరు, 40 బైట్లు malloced

475
00:20:59,010 --> 00:21:00,515
మరియు మీరు అది విడుదల ఎప్పుడూ.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
మీరు అవసరం ఎక్కువగా
కొన్ని మెమరీ లీక్ కనుగొనేందుకు,

478
00:21:05,140 --> 00:21:07,650
మరియు మీరు అవసరం ఎక్కడ
మెమరీ ఈ బ్లాక్ విముక్తికై.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> మరియు, 32 ప్రశ్న
పరిమాణం 4 యొక్క చెల్లని రాసే.

481
00:21:11,910 --> 00:21:13,250
మళ్ళీ ఈ ఒక Valgrind లోపం ఉంది.

482
00:21:13,250 --> 00:21:15,440
దీన్ని లేదు
ఇప్పుడు మెమరీ లీకేజ్ తో.

483
00:21:15,440 --> 00:21:20,750
ఈ నేను అర్థం likely-- చాలా, అది, ఉంది
చెల్లని మెమరీ హక్కుల విధమైన.

484
00:21:20,750 --> 00:21:23,270
మరియు ఎక్కువగా ఈ ఉంది కొన్ని
బఫర్ ఓవర్ఫ్లో యొక్క విధమైన.

485
00:21:23,270 --> 00:21:26,560
ఎక్కడ మీరు బహుశా, వ్యూహం
పూర్ణాంకం శ్రేణి, మరియు లెట్స్

486
00:21:26,560 --> 00:21:30,115
అది పరిమాణం 5 యొక్క చెప్పాలి, మరియు మీరు
శ్రేణి బ్రాకెట్ 5 టచ్ ప్రయత్నించండి.

487
00:21:30,115 --> 00:21:34,150
మీరు ఆ వ్రాయడానికి ప్రయత్నించండి చేస్తే
విలువ, మెమరీ భాగం కాదు

488
00:21:34,150 --> 00:21:37,440
మీరు నిజంగా యాక్సెస్, మరియు ఆ
కాబట్టి మీరు ఈ తప్పిదం చూడాలని,

489
00:21:37,440 --> 00:21:39,272
పరిమాణం 4 యొక్క చెల్లని రాసే విధంగా.

490
00:21:39,272 --> 00:21:42,480
Valgrind మీరు గుర్తించి అన్నారు
తగినవిధంగా మెమరీ తాకే ప్రయత్నిస్తున్నారు.

491
00:21:42,480 --> 00:21:43,980
>> మరియు ఆ quiz0 కోసం అంతే.

492
00:21:43,980 --> 00:21:47,065
నేను రాబ్ బౌడెన్ ఉన్నాను, మరియు ఈ CS50 ఉంది.

493
00:21:47,065 --> 00:21:51,104