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
કે leftmost લાઇટ બલ્બ 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
કે leftmost છે કારણ કે
પ્રકાશ ગોળો બાદ 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
એ બિટ્સ સાથે, કેટલા અલગ
મૂલ્યો તમે પ્રતિનિધિત્વ કરી શકે છે?

27
00:01:14,610 --> 00:01:19,080
તેથી, એ બિટ્સ સાથે, તમે 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
જો તમે ઇચ્છતા હોય અને તમે કરી શકે છે
કે leftmost શૂન્ય બોલ લે છે.

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
તે એક પ્રકારની હતી, જે સીએસ 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 દ્વારા incrementing.

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
આ હેશો ત્રણ લંબચોરસ દ્વારા.

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
આ ચલ ઓ માં, અને પછી
કે ચલ ઓ પ્રિન્ટ કરે છે.

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 ટપકું ક.

122
00:05:20,920 --> 00:05:23,820
શા માટે અમે CS50 ટપકું ક સમાવેશ કરવાની જરૂર છે?

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 ડોટ એચ.

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 ડોટ એચ સમાવેશ થાય છે,

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
તેથી અહીં અમે પૂર્ણાંક મુખ્ય (રદબાતલ) હોય છે.

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
અમે પૂર્ણાંક કહી શકે છે કે જે યાદ રાખો
મુખ્ય પૂર્ણાંક 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
તેથી આ તમામ કાર્યક્રમ કરી રહ્યા છે
1 10 દ્વારા વિભાજીત છે printf-ing છે.

158
00:06:55,579 --> 00:06:57,370
તેથી જ્યારે સંકલિત અને
ચલાવવામાં, આ કાર્યક્રમ

159
00:06:57,370 --> 00:07:01,170
આઉટપુટ 0.0 છે, તેમ છતાં
1 10 દ્વારા વિભાજીત 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
તેથી 10 દ્વારા 1 છે વિભાજિત
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, સંપૂર્ણ સમૂહ છે
zeros છે, 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
>> તેથી અહીં કારણ છે હવે
બિંદુ અશુદ્ધિ તરતી.

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
તમે ચિંતા કરવાની જરૂર
બિંદુ અશુદ્ધિ તરતી,

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
કાર્ય જો સાચું આપે છે
એ પણ છે કે જો એ વિચિત્ર અને ખોટું છે.

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

208
00:09:16,710 --> 00:09:19,330
આ એક મહાન હેતુ છે
મોડ ઓપરેટર છે.

209
00:09:19,330 --> 00:09:24,530
તેથી અમે અમારી દલીલ એ લે છે,
એ મોડ 2 તેમજ 1, બરાબર હોય તો,

210
00:09:24,530 --> 00:09:28,030
તે n વિભાજિત અર્થ એ થાય કે
2 દ્વારા બાકીની હતી.

211
00:09:28,030 --> 00:09:33,270
N 2 દ્વારા વિભાજી, તો બાકીની હતું કે
એ વિચિત્ર છે, તેથી અમે સાચું પાછા આવી છે.

212
00:09:33,270 --> 00:09:34,910
બાકી અમે ખોટા આવો.

213
00:09:34,910 --> 00:09:39,070
તમે પણ 2 સમકક્ષ મોડ એ કરી શકે છે
શૂન્ય, બીજું, ખોટા પાછા સાચું આવો.

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
એ ઓછા 1 એફ બીજું પરત 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
તમે આ કરી શકે છે ઘણી રીતે
અમે આ પૂર્ણાંક ઉત્પાદન સાથે શરૂ

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 સમકક્ષ શા માટે તમે આશ્ચર્ય થઈ શકે છે.

233
00:10:24,130 --> 00:10:28,380
વેલ, અમે અહીં યાદ રાખો કે
અમારા આધાર કેસ યોગ્ય છે તેની ખાતરી કરો.

234
00:10:28,380 --> 00:10:32,180
એ કરતા ઓછો અથવા સમાન છે તેથી જો
1, અમે ફક્ત 1 પરત કરી રહ્યાં છો.

235
00:10:32,180 --> 00:10:34,830
હું 2 સમકક્ષ અહીં પર તેથી, અમે શરૂ કરો.

236
00:10:34,830 --> 00:10:39,090
વેલ, હું 1, હતા તો પછી કરવું અથવા
એ લૂપ માટે પછી 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
>> હવે, એ વધારે હોય છે
1 કરતાં, તો પછી અમે જઈ રહ્યાં છો,

243
00:10:54,660 --> 00:10:56,550
ઓછામાં ઓછી એક કરવા માટે
આ લૂપની પુનરાવૃત્તિ.

244
00:10:56,550 --> 00:11:00,630
તેથી તો અમે છો, ચાલો એ 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
વખત આ અનંત સ્પર્શી રન વખત.

255
00:11:28,060 --> 00:11:33,270
તેથી અલ્ગોરિધમનો શું છે
1 ઓમેગા, પરંતુ એ મોટી ઓ છે?

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 ના ઓ છે કે શા માટે છે.

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

267
00:11:59,670 --> 00:12:04,880
>> તેથી હવે તે બંને છે કે કંઈક છે
n લોગ n ના ઓમેગા, અને n લોગ n ના મોટા ઓ.

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 છે,
ઓમેગા અને મોટી ઓ બંને એક જ હોય ​​છે.

271
00:12:16,920 --> 00:12:17,580
બંને n લોગ 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
, શ્રેષ્ઠ કેસ દૃશ્ય તેથી
તે એ માત્ર ઓમેગા છે.

282
00:12:43,185 --> 00:12:45,960
તે માત્ર એક સરસ ન હોય તો
સાથે શરૂ કરવા માટે યાદી સૉર્ટ થાય છે

283
00:12:45,960 --> 00:12:48,270
પછી અમે n ના ઓ અદલબદલ સ્ક્વેર્ડ છે.

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
વેલ, ફરીથી અગાઉ સમાન છે,
અમે માત્ર finitely ઘણા બિટ્સ હોય

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
તેથી આ પૂર્ણાંક ઓવરફ્લો
તમે incrementing રાખે છે,

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 પર શરૂ થાય છે અને
સમગ્ર યાદી પર ફરી વળવું.

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 ના ઓમેગા છે.

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
અમે પૂર્ણાંક એક્સ 1 સમકક્ષ હોય છે.

376
00:16:45,457 --> 00:16:47,040
કે થયું છે કે આ જ વસ્તુ છે.

377
00:16:47,040 --> 00:16:50,440
તેથી એક લીટી પર, અમે, અમારા જુઓ
ટેબલ, કે વાય, બી, અને tmp બધા છે

378
00:16:50,440 --> 00:16:51,540
બ્લેક્ડ આઉટ.

379
00:16:51,540 --> 00:16:52,280
તેથી એક્સ શું છે?

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
અને પછી, સારી રીતે, બે લીટી
અમે વાય 2 સુયોજિત થયેલ છે કે જુઓ

383
00:16:58,770 --> 00:17:00,550
અને ટેબલ પહેલેથી જ છે
અમને ભરી.

384
00:17:00,550 --> 00:17:03,040
તેથી એક્સ 1 છે અને વાય 2 છે.

385
00:17:03,040 --> 00:17:05,890
>> હવે, રેખા ત્રણ, હવે અમે છો
સ્વેપ કાર્ય અંદર.

386
00:17:05,890 --> 00:17:07,560
શું આપણે સ્વેપ પસાર કરી હતી?

387
00:17:07,560 --> 00:17:11,609
અમે માટે ચિન્હ એક્સ પસાર
b માટે, અને ચિન્હ વાય.

388
00:17:11,609 --> 00:17:15,160
ક્યાં સમસ્યા અગાઉ
જણાવ્યું હતું કે x ની સરનામું

389
00:17:15,160 --> 00:17:17,520
0x10 છે, અને વાય ના સરનામા 0x14 છે.

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

391
00:17:18,970 --> 00:17:21,909
તેથી a અને b સમાન હોય છે
અનુક્રમે 0x10 અને 0x14.

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

393
00:17:23,670 --> 00:17:26,250
>> હવે લીટી ત્રણ, એક્સ અને વાય શું છે?

394
00:17:26,250 --> 00:17:28,554
ઠીક છે, કંઈ જ બદલાઈ જાય છે
આ બિંદુએ, એક્સ અને વાય વિશે.

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
તેથી એક્સ 1, વાય 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
વેલ, એક પોઈન્ટ એક્સ, તેથી તારો
1 છે, જે સમાન એક્સ, રહ્યું છે.

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
વેલ, અમે ફક્ત તારો એક્સ છે.

413
00:18:13,720 --> 00:18:16,400
તેથી અમે સમાન તારો બો એક્સ બદલી રહ્યાં છીએ.

414
00:18:16,400 --> 00:18:18,960
સ્ટાર બી શું છે? વાય. વાય બી નિર્દેશ કરે છે.

415
00:18:18,960 --> 00:18:21,030
તેથી સ્ટાર બી વાય છે.

416
00:18:21,030 --> 00:18:25,140
તેથી અમે વાય એક્સ સમાન સુયોજિત કરી રહ્યા છીએ
અને બાકીનું બધું જ છે.

417
00:18:25,140 --> 00:18:29,130
એક્સ હવે છે કે જેથી અમે આગામી પંક્તિ જુઓ
2, અને બાકીના માત્ર નીચે નકલ થયેલ છે.

418
00:18:29,130 --> 00:18:31,120
>> હવે આગામી વાક્ય તારો બો tmp સમકક્ષ હોય છે.

419
00:18:31,120 --> 00:18:34,740
વેલ, અમે ફક્ત તારો બો વાય છે જણાવ્યું હતું કે,
તેથી અમે tmp વાય સમાન સુયોજિત કરી રહ્યાં છો.

420
00:18:34,740 --> 00:18:37,450
બાકીનું બધું જ છે,
જેથી નીચે બધું નકલ નહીં.

421
00:18:37,450 --> 00:18:42,050
અમે છે, કે જે tmp સમાન વાય સુયોજિત કરી રહ્યા છીએ
બીજું એક છે, અને બધું જ છે.

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
અમે હમણાં જ એક્સ અને વાય નીચે નકલ કરો.

428
00:18:52,800 --> 00:18:56,490
અને અમે એક્સ અને વાય છે કે નહીં તે જોવા
હવે 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 અથવા ટીએફ તરીકે આગામી વર્ષ.

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
ટકા જેવો હું એ બેકસ્લેશ.

461
00:20:11,380 --> 00:20:15,310
અથવા આપણે ટકા હું જેવી છાપી શકે છે
જગ્યા, ટકા હું, જગ્યા, ટકા i.

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
એટલે કે, અમે હોય છે કહે છે કે
percents સમગ્ર ટોળું,

469
00:20:39,390 --> 00:20:42,445
અને અમે પૂરતી ચલો ન હોય
વાસ્તવમાં તે percents માં ભરો.

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