1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [4 અઠવાડિયું]

2
00:00:03,000 --> 00:00:05,000
[ડેવિડ જે Malan] [હાર્વર્ડ યુનિવર્સિટી]

3
00:00:05,000 --> 00:00:08,000
[આ CS50 છે.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> બધા હક, આ CS50 છે, અને આ 4 સપ્તાહ શરૂઆત છે,

5
00:00:12,000 --> 00:00:16,000
અને આ એક સૌથી ધીમી શક્ય સોર્ટિંગ એલ્ગોરિધમ્સ છે.

6
00:00:16,000 --> 00:00:19,000
જે એક હતું કે અમે માત્ર ત્યાં જોયેલી?

7
00:00:19,000 --> 00:00:24,000
તે બબલના સૉર્ટ હતો, જેથી મોટા ઓ (n ^ 2) રકમ +

8
00:00:24,000 --> 00:00:28,000
અને ખરેખર અમે આ વિશ્વમાં માત્ર ચામાં જાણવા લાગે છે નથી

9
00:00:28,000 --> 00:00:30,000
બબલ સૉર્ટ શું છે અથવા તેના ચાલી સમય.

10
00:00:30,000 --> 00:00:33,000
ખરેખર, આ Google એરિક શ્મિટ એક મુલાકાતમાં હતી

11
00:00:33,000 --> 00:00:45,000
અને સેનેટર બરાક ઓબામા ભૂતપૂર્વ પહેલાં થોડા વર્ષો.

12
00:00:45,000 --> 00:00:48,000
>> હવે, સેનેટર, તમે Google પર અહીં છો,

13
00:00:48,000 --> 00:00:54,000
અને હું નોકરી ઇન્ટરવ્યૂ તરીકે રાષ્ટ્રપતિના લાગે ગમે છે.

14
00:00:54,000 --> 00:00:58,000
હવે, તે મુશ્કેલ પ્રમુખ તરીકે નોકરી મળી છે, અને તમે જીવનની મુશ્કેલીઓ મારફતે જઈ રહ્યાં છો હવે.

15
00:00:58,000 --> 00:01:00,000
તે પણ હાર્ડ Google પર નોકરી મેળવી.

16
00:01:00,000 --> 00:01:05,000
અમે પ્રશ્નો હોય, અને અમે અમારી ઉમેદવારો પ્રશ્નો પૂછી,

17
00:01:05,000 --> 00:01:10,000
અને આ એક લેરી Schwimmer છે.

18
00:01:10,000 --> 00:01:14,000
તમે ગાય્સ લાગે છે કે મેં મજાક કરું છું છું? તે અહીં છે.

19
00:01:14,000 --> 00:01:18,000
સૌથી વધુ અસરકારક મિલિયન 32-bit પૂર્ણાંકો સૉર્ટ રસ્તો શું છે?

20
00:01:18,000 --> 00:01:21,000
[અટ્ટહાસ્ય]

21
00:01:21,000 --> 00:01:24,000
સારી રીતે

22
00:01:24,000 --> 00:01:26,000
હું દિલગીર >> છું. ના, ના, ના, ના.

23
00:01:26,000 --> 00:01:34,000
મને લાગે છે કે આ પરપોટો સૉર્ટ ખોટી પર જાઓ રીત હોઈ શકે.

24
00:01:34,000 --> 00:01:39,000
>> પર આવે છે, જે તેમને આ કહ્યું?

25
00:01:39,000 --> 00:01:43,000
છેલ્લા અઠવાડિયે યાદ અમે એક દિવસ માટે ઓછામાં ઓછી કોડ માંથી વિરામ લીધો,,

26
00:01:43,000 --> 00:01:46,000
અને કેટલાક ઉચ્ચ સ્તર વિચારો અને સમસ્યા વધુ સામાન્ય ઉકેલ પર ધ્યાન કેન્દ્રિત કરવાનું શરૂ કર્યું

27
00:01:46,000 --> 00:01:49,000
શોધ અને સૉર્ટ સંદર્ભમાં,

28
00:01:49,000 --> 00:01:53,000
અને અમે કંઈક કે અમે છેલ્લા અઠવાડિયે પર આ નામ slap નહોતી રજૂઆત કરી હતી,

29
00:01:53,000 --> 00:01:56,000
પરંતુ ઉપગીય સંકેતલિપિ, બિગ ઓ, મોટા ઓમેગા,

30
00:01:56,000 --> 00:02:00,000
અને ક્યારેક મોટા થીટા નોટેશનમાં છે, અને આ ખાલી હતા રીતે

31
00:02:00,000 --> 00:02:02,000
અલગોરિથમ્સ ચાલી રહેલ સમય વર્ણન,

32
00:02:02,000 --> 00:02:05,000
કેટલો સમય તે માટે એલ્ગોરિધમ માટે લઈ જાય છે.

33
00:02:05,000 --> 00:02:08,000
>> અને તમે કે તમે ચાલી સમય વિશે વાત કરી કદ દ્રષ્ટિએ યાદ કરી શકે છે

34
00:02:08,000 --> 00:02:11,000
ઇનપુટ, જે અમે સામાન્ય રીતે n કૉલ, ગમે તે સમસ્યા હોઈ શકે છે,

35
00:02:11,000 --> 00:02:13,000
n એ રૂમ માં લોકોની સંખ્યા જ્યાં છે,

36
00:02:13,000 --> 00:02:17,000
એક ફોન પુસ્તક માં પૃષ્ઠો સંખ્યા, અને અમે વસ્તુઓ લખી બહાર શરૂ

37
00:02:17,000 --> 00:02:21,000
ઓ, જેમ કે (n ^ 2) અથવા (n O) અથવા ઓ (n લોગ એન)

38
00:02:21,000 --> 00:02:24,000
અને પણ જ્યારે ગણિતના તદ્દન ન હતું જેથી સંપૂર્ણપણે

39
00:02:24,000 --> 00:02:28,000
અને તે n એ હતી ચોરસ - એન / 2 અથવા કે કંઈક

40
00:02:28,000 --> 00:02:31,000
અમે તેના બદલે માત્ર દૂર નીચલા ક્રમમાં શરતો કેટલાક ફેંકવું હો,

41
00:02:31,000 --> 00:02:34,000
અને પ્રેરણા છે કે અમે ખરેખર એક માંગો છો

42
00:02:34,000 --> 00:02:37,000
મૂલ્યાંકન ઓફ ઉદ્દેશ માર્ગ જેવું

43
00:02:37,000 --> 00:02:39,000
કાર્યક્રમોની પ્રભાવ અથવા એલ્ગોરિધમ્સ કામગીરી

44
00:02:39,000 --> 00:02:42,000
કે દિવસ ઓવરને અંતે ઉદાહરણ માટે કરવા જેવું કશું છે,

45
00:02:42,000 --> 00:02:45,000
તમારા કમ્પ્યુટર ની ઝડપ આજે.

46
00:02:45,000 --> 00:02:47,000
>> હમણાં પૂરતું, જો તમે બબલ સૉર્ટ અમલમાં મૂકવા માટે,

47
00:02:47,000 --> 00:02:50,000
અથવા તમે આજના કમ્પ્યૂટર પર સૉર્ટ કરો અથવા પસંદ સૉર્ટ મર્જ અમલમાં મૂકવા માટે,

48
00:02:50,000 --> 00:02:53,000
એક 2 જીએચઝેડ કોમ્પ્યુટર, અને તમે તેને ચલાવવા માટે,

49
00:02:53,000 --> 00:02:56,000
અને તે સેકન્ડોમાં કેટલાક નંબર લે છે, આગામી વર્ષે ત્યાં 3 જીએચઝેડ છે

50
00:02:56,000 --> 00:02:59,000
અથવા 4 જીએચઝેડ કોમ્પ્યુટર, તમે અને પછી તે "વાહ, મારી અલ્ગોરિધમનો દાવો કરી શકે છે

51
00:02:59,000 --> 00:03:03,000
હવે ઝડપથી બે વાર છે, "જ્યારે હકીકત છે કે જે દેખીતી રીતે જ કેસ નથી.

52
00:03:03,000 --> 00:03:06,000
તે ફક્ત હાર્ડવેર ઝડપી મેળવેલ છે, પરંતુ તમારા કમ્પ્યુટર

53
00:03:06,000 --> 00:03:10,000
છે અને તેથી, અમે ખરેખર દૂર જેવી વસ્તુઓ કાઢી નાખવા માંગો છો

54
00:03:10,000 --> 00:03:13,000
2 ના ગુણાંકમાં અથવા 3 ગુણાંકમાં જ્યારે તે વર્ણન આવે છે

55
00:03:13,000 --> 00:03:17,000
ઝડપી કેવી રીતે કેવી રીતે ધીમી એક એલ્ગોરિધમ છે અને ખરેખર માત્ર ધ્યાન કેન્દ્રિત

56
00:03:17,000 --> 00:03:20,000
n અથવા અમુક તેના પરિબળ પર,

57
00:03:20,000 --> 00:03:24,000
કેટલીક સત્તા તેના તરીકે છેલ્લા અઠવાડિયે ના પ્રકારની કિસ્સામાં.

58
00:03:24,000 --> 00:03:27,000
અને મર્જ પ્રકારની મદદ સાથે યાદ

59
00:03:27,000 --> 00:03:31,000
અમે ખૂબ જ બબલ વર્ગીકરણ અને સમાવેશ પસંદગી સૉર્ટ કરતાં વધુ સારું કરવા સક્ષમ હતા

60
00:03:31,000 --> 00:03:33,000
અને પણ દાખલ સૉર્ટ કરો.

61
00:03:33,000 --> 00:03:36,000
>> અમે n એ લોગ n નોંધાયો હતો, ફરીથી અને,

62
00:03:36,000 --> 00:03:39,000
જણાવ્યું હતું કે લોગ n એ સામાન્ય રીતે કંઈક કે ઊગે સંદર્ભ લે છે

63
00:03:39,000 --> 00:03:43,000
ધીમે ધીમે તે પછી n એ, જેથી n લોગ n આમ અત્યાર સુધી સારી હતી

64
00:03:43,000 --> 00:03:45,000
કારણ કે તે n ચોરસ કરતાં ઓછી હતી.

65
00:03:45,000 --> 00:03:47,000
પરંતુ પ્રાપ્ત ન મર્જ સૉર્ટ સાથે n લૉગ

66
00:03:47,000 --> 00:03:51,000
એક વિચાર મૂળ સૂક્ષ્મજીવ કે અમે લાભ માટે હતી શું હતું

67
00:03:51,000 --> 00:03:54,000
કે અમે પણ 0 સપ્તાહમાં ફરી લિવરેજ?

68
00:03:54,000 --> 00:03:58,000
અમે સૉર્ટ સમસ્યા કેવી રીતે હલ ન હતી ચાલાકીપૂર્વક મર્જ સૉર્ટ સાથે?

69
00:03:58,000 --> 00:04:04,000
શું કી સૂઝ કદાચ?

70
00:04:04,000 --> 00:04:07,000
કોઈપણ અંતે તમામ.

71
00:04:07,000 --> 00:04:09,000
ઠીક છે, ચાલો એક પગલું પાછળ લઈ લો.

72
00:04:09,000 --> 00:04:11,000
તમારા પોતાના શબ્દોમાં સૉર્ટ મર્જ વર્ણવે છે.

73
00:04:11,000 --> 00:04:15,000
તે કેવી રીતે કામ કરી?

74
00:04:15,000 --> 00:04:17,000
ઠીક છે, અમે પાછા સપ્તાહ 0 થી પંક્તિ પડશે.

75
00:04:17,000 --> 00:04:19,000
ઠીક છે, હા.

76
00:04:19,000 --> 00:04:22,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

77
00:04:22,000 --> 00:04:26,000
ઠીક છે, સારુ, તેથી અમે 2 ટુકડાઓમાં સંખ્યાની એરે વહેંચાયેલી છે.

78
00:04:26,000 --> 00:04:29,000
અમે તે ટુકડાઓ દરેક છટણી, અને પછી અમે તેમને ભેળવી

79
00:04:29,000 --> 00:04:33,000
અને અમે આ વિચાર જોયેલા પહેલાં એક સમસ્યા છે કે આ મોટી છે લેતી

80
00:04:33,000 --> 00:04:36,000
અને તે એક સમસ્યા છે કે આ મોટું અથવા આ મોટું છે માં અપ કકડો.

81
00:04:36,000 --> 00:04:38,000
>> ફોન બુકમાં ઉદાહરણ યાદ અપાવે છે.

82
00:04:38,000 --> 00:04:42,000
અઠવાડિયા પહેલા ના અલ્ગોરિધમનો સ્વ ગણતરી યાદ,

83
00:04:42,000 --> 00:04:45,000
જેથી મર્જ સૉર્ટ કરો આ અહીં સ્યુડોકોડનો દ્વારા સારાંશ હતી.

84
00:04:45,000 --> 00:04:48,000
જ્યારે તમે n તત્વોના આપેલા કરી રહ્યાં છો, તો પ્રથમ તે સેનીટી તપાસો.

85
00:04:48,000 --> 00:04:51,000
જો n <2 પછી કંઈપણ બધા અંતે નથી

86
00:04:51,000 --> 00:04:55,000
જો n <2 પછી n એ 0 અથવા 1 ચોક્કસપણે છે કારણ કે,

87
00:04:55,000 --> 00:04:57,000
અને તેથી જો તે ક્યાં છે 0 અથવા 1 ત્યાં સૉર્ટ કરવા માટે કશું જ નથી.

88
00:04:57,000 --> 00:04:59,000
તમે કરી રહ્યાં છો.

89
00:04:59,000 --> 00:05:01,000
તમારા યાદી પહેલાથી જ સામાન્ય અને છૂટાં પાડવામાં આવે છે.

90
00:05:01,000 --> 00:05:04,000
પરંતુ અન્યથા જો તમે 2 અથવા વધુ તત્વો મળી છે આગળ જાઓ અને તેઓને વિભાજીત

91
00:05:04,000 --> 00:05:06,000
2 છિદ્ર હોય છે, જે ડાબા અને જમણા.

92
00:05:06,000 --> 00:05:09,000
તે છિદ્ર દરેક સૉર્ટ કરો, અને પછી છટણી અર્ધભાગ મર્જ.

93
00:05:09,000 --> 00:05:13,000
પરંતુ અહીં સમસ્યા એ છે કે પ્રથમ નજરમાં આ અનુભૂતિ જેવી અમે punting કરી રહ્યાં છો.

94
00:05:13,000 --> 00:05:17,000
આ કે એક પરિપત્ર વ્યાખ્યા છે જો હું તમને પૂછ્યું છે આ n તત્વોના સૉર્ટ

95
00:05:17,000 --> 00:05:22,000
અને તમે મને કહેતાં રહ્યાં છો "બધા અધિકાર, દંડ, અમે તે n / 2 અને તે એન / 2 તત્વો સૉર્ટ પડશે,"

96
00:05:22,000 --> 00:05:27,000
પછી મારી આગામી પ્રશ્ન હોય રહ્યું છે "ફાઇન, તો તમે એન / 2 તત્વો કેવી રીતે સૉર્ટ કરો છો?"

97
00:05:27,000 --> 00:05:30,000
>> પરંતુ કારણ કે આ કાર્યક્રમની માળખું,

98
00:05:30,000 --> 00:05:33,000
કારણ કે ત્યાં આ બેઝ કેસ છે, તેથી બોલે છે,

99
00:05:33,000 --> 00:05:39,000
આ ખાસ કેસ કહે છે કે જો n 2 વળતર જેવા કેટલાક નિશ્ચિત કિંમત <છે તરત.

100
00:05:39,000 --> 00:05:42,000
તે જ ગોળ જવાબ સાથે પ્રતિસાદ નથી.

101
00:05:42,000 --> 00:05:46,000
આ પ્રક્રિયા, આ cyclicity આખરે સમાપ્ત થશે.

102
00:05:46,000 --> 00:05:50,000
જો હું તમે "સૉર્ટ કરો આ n તત્વોના," પૂછો અને તમે કહી, "ફાઇન, આ એન / 2 સૉર્ટ"

103
00:05:50,000 --> 00:05:53,000
પછી તમે કહે છે, "ફાઇન, સૉર્ટ આ n એ / 4, 8 / n એ, n/16,"

104
00:05:53,000 --> 00:05:56,000
આખરે તમે એક મોટી પર્યાપ્ત સંખ્યા દ્વારા વિભાજીત પડશે

105
00:05:56,000 --> 00:05:59,000
કે તમે ફક્ત 1 તત્વ ડાબી છે જે બિંદુએ તમે કહી શકો છો, પડશે,

106
00:05:59,000 --> 00:06:02,000
"અહીં, અહીં એક સોર્ટ એક તત્વ છે."

107
00:06:02,000 --> 00:06:06,000
તો પછી આ અલ્ગોરિધમનો ના દીપ્તિ અહીં એ હકીકત પરથી લેવામાં છે

108
00:06:06,000 --> 00:06:09,000
કે એકવાર તમે આ વ્યક્તિગત રીતે છટણી યાદીઓ બધી,

109
00:06:09,000 --> 00:06:12,000
જે તમામ 1 કદ, છે કે જે નકામી લાગે છે,

110
00:06:12,000 --> 00:06:15,000
એક વાર તમે તેમને મર્જ અને તેમને મર્જ શરૂ

111
00:06:15,000 --> 00:06:19,000
તમે છેલ્લે બિલ્ડ તરીકે રોબ વિડિઓ છેવટે છટણી યાદી કર્યું હતું.

112
00:06:19,000 --> 00:06:22,000
>> પરંતુ આ વિચાર સોર્ટિંગ બહાર સુધી લંબાય છે.

113
00:06:22,000 --> 00:06:26,000
ત્યાં આ રિકર્ઝન તરીકે ઓળખાય કાર્યક્રમ માં એમ્બેડેડ વિચાર છે,

114
00:06:26,000 --> 00:06:29,000
આ વિચાર જેમાં તમે એક કાર્યક્રમ છે,

115
00:06:29,000 --> 00:06:32,000
અને કેટલાક સમસ્યા તમે પોતે કહી ઉકેલ

116
00:06:32,000 --> 00:06:36,000
અથવા પ્રોગ્રામિંગ ભાષાઓ તમે એક કાર્ય છે સંદર્ભમાં મૂકી,

117
00:06:36,000 --> 00:06:39,000
અને ક્રમમાં સમસ્યા ઉકેલવા માટે, તમે કાર્ય જાતે કૉલ

118
00:06:39,000 --> 00:06:42,000
ફરીથી અને ફરીથી અને ફરીથી, પણ તમે કાર્ય

119
00:06:42,000 --> 00:06:44,000
અનંત ઘણી વખત કહી ન જાતે કરી શકો છો.

120
00:06:44,000 --> 00:06:47,000
આખરે તો તમે નીચે હોય છે તેથી વાત કરવા માટે,

121
00:06:47,000 --> 00:06:49,000
અને કેટલાક આધાર હાર્ડ કોડેડ શરત કહે છે

122
00:06:49,000 --> 00:06:53,000
આ બિંદુએ જાતે જેથી ફોન રોકવા કે સમગ્ર પ્રક્રિયા

123
00:06:53,000 --> 00:06:56,000
છેવટે હકીકતમાં બંધ ન થાય.

124
00:06:56,000 --> 00:06:58,000
આ શું ખરેખર નથી recurse અર્થ?

125
00:06:58,000 --> 00:07:01,000
>> ચાલો જોવા માટે, જો આપણે સાથે સરળ, તુચ્છ ઉદાહરણ કરવા કહેવું, કરી શકો છો,

126
00:07:01,000 --> 00:07:03,000
અપ સ્ટેજ પર અહીં 3 મારી સાથે લોકો, જો કોઇ આરામદાયક છે.

127
00:07:03,000 --> 00:07:06,000
2 અપ, અને 3 પર 1, આવે છે.

128
00:07:06,000 --> 00:07:09,000
જો તમે 3 થી અહીં આવવા માંગો છો.

129
00:07:09,000 --> 00:07:12,000
જો તમે મને અધિકાર આગામી એક વાક્ય અહીં ઊભા કરવા માંગો છો ધારવું, હાથમાં જે સમસ્યા

130
00:07:12,000 --> 00:07:15,000
છે ખૂબ જ સામાન્ય અને લોકો અહીં છે સંખ્યા ગણતરી.

131
00:07:15,000 --> 00:07:18,000
પરંતુ પ્રમાણિકપણે, હું આ તમામ ગણતરી ઉદાહરણો થાકેલું છું.

132
00:07:18,000 --> 00:07:21,000
આ થોડો સમય, 1, 2, અને ડોટ, કોઈ, કોઈ લઇ રહ્યું છે.

133
00:07:21,000 --> 00:07:23,000
તે કાયમ માટે લઇ રહ્યું છે.

134
00:07:23,000 --> 00:07:25,000
હું બદલે માત્ર મદદ સાથે આ સમસ્યા સંપૂર્ણપણે વાંસડા વડે એવી હોડી ચલાવવી ઓફ શું તમારું નામ શું છે? છો

135
00:07:25,000 --> 00:07:27,000
સારા. >> સારા, બધા અધિકાર.

136
00:07:27,000 --> 00:07:29,000
કેલી. >> કેલી અને?

137
00:07:29,000 --> 00:07:31,000
>> વિલી >> વિલી, સારા, કેલી, અને વિલી..

138
00:07:31,000 --> 00:07:34,000
હમણાં હું કોઇને દ્વારા કરવામાં આવી છે પ્રશ્ન પૂછવામાં

139
00:07:34,000 --> 00:07:37,000
કેટલા લોકો આ મંચ પર હોય છે, અને હું કોઈ વિચાર હોય છે.

140
00:07:37,000 --> 00:07:40,000
આ એક ખરેખર લાંબી યાદી છે, અને તેથી તેના બદલે હું આ યુક્તિ કરવા જાઉં છું.

141
00:07:40,000 --> 00:07:43,000
હું મને આગળ વ્યક્તિ માટે કામ મોટા ભાગના કરવા પૂછો જાઉં છું,

142
00:07:43,000 --> 00:07:46,000
અને એકવાર તેમણે કામ સૌથી કરવાથી થાય છે

143
00:07:46,000 --> 00:07:49,000
હું કામ કરવાની ઓછામાં ઓછી રકમ શક્ય કરવા જાઉં છું અને ફક્ત 1 ઉમેરવા

144
00:07:49,000 --> 00:07:51,000
તેના જવાબ ગમે છે, તેથી છે અહીં અમે જાઓ.

145
00:07:51,000 --> 00:07:54,000
હું પૂછવામાં થઈ કેટલા લોકો સ્ટેજ પર હોય છે.

146
00:07:54,000 --> 00:07:57,000
કેટલા લોકો સ્ટેજ પર તમે ડાબી છે?

147
00:07:57,000 --> 00:08:00,000
મને ઓફ >> ડાબી? ઠીક છે, પરંતુ ઠગ નથી.

148
00:08:00,000 --> 00:08:04,000
કે સારા છે, કે જે સાચું છે, પરંતુ જો અમે આ તર્ક ચાલુ રાખવા માંગો છો

149
00:08:04,000 --> 00:08:08,000
ચાલો ધારે છે કે તમે એ જ રીતે તમે ડાબી આ સમસ્યા વાંસડા વડે એવી હોડી ચલાવવી કરવા માંગો છો,

150
00:08:08,000 --> 00:08:11,000
તેથી જવાબ બદલે સીધા આગળ વધો અને માત્ર નર હરણ પસાર કરે છે.

151
00:08:11,000 --> 00:08:14,000
ઓહ, કેટલા લોકો મને ડાબી છે?

152
00:08:14,000 --> 00:08:16,000
ઘણા લોકો આ રીતે ડાબી છે?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[અટ્ટહાસ્ય]

155
00:08:27,000 --> 00:08:30,000
ઠીક છે, તેથી 0, તેથી શું હવે વિલી કર્યું છે

156
00:08:30,000 --> 00:08:33,000
છે તમે તમારા જવાબ આ 0 કહેતા દિશામાં પરત કર્યું છે.

157
00:08:33,000 --> 00:08:36,000
હવે, તમે શું 1 >>? કરવું જોઈએ.

158
00:08:36,000 --> 00:08:39,000
, બધા અધિકાર, ઠીક છે, જેથી તમે 1 છે છો, જેથી તમે કહેવું "હું 1 ઉમેરવા જાઉં છું

159
00:08:39,000 --> 00:08:41,000
માટે વિલી ગણતરી હતું, "જેથી 1 0 + + ગમે.

160
00:08:41,000 --> 00:08:43,000
હવે તમે 1 જેથી તમારી જમણી જવાબ છે હવે

161
00:08:43,000 --> 00:08:45,000
1. >> ખાણ અને 2 હશે.

162
00:08:45,000 --> 00:08:48,000
ગુડ, જેથી તમે 1 પાછલા જવાબ વાત કરી રહ્યાં છે,

163
00:08:48,000 --> 00:08:51,000
કામ એ ન્યૂનતમ જથ્થો તમે કરવા માંગો છો ઉમેરી રહ્યા છે, કે જે +1 છે.

164
00:08:51,000 --> 00:08:55,000
તમે હવે 2 છે, અને પછી તમે મને કિંમત છે કે જે હાથથી?

165
00:08:55,000 --> 00:08:57,000
3, હું તેનો અર્થ, માફ કરશો, 2.

166
00:08:57,000 --> 00:08:59,000
ગુડ.

167
00:08:59,000 --> 00:09:02,000
>> વેલ, અમે ડાબી 0 હતી.

168
00:09:02,000 --> 00:09:05,000
તો પછી અમે 1 હતી, અને પછી અમે 2 ઉમેરવા માટે,

169
00:09:05,000 --> 00:09:07,000
અને હવે તમે મને 2 નંબર સોંપવામાં કરી રહ્યાં છો,

170
00:09:07,000 --> 00:09:10,000
અને તેથી હું જણાવ્યું હતું કે, છું ઠીક, +1, 3.

171
00:09:10,000 --> 00:09:13,000
ત્યાં ખરેખર છે 3 આ સ્ટેજ પર મને આગળ ઊભા લોકો,

172
00:09:13,000 --> 00:09:16,000
જેથી અમે ચોક્કસપણે આ હોઈ શકે છે ખૂબ linearly પૂર્ણ થાય,

173
00:09:16,000 --> 00:09:19,000
ખૂબ સ્પષ્ટ ફેશન ખૂબ, પરંતુ અમે ખરેખર શું કરો છો?

174
00:09:19,000 --> 00:09:21,000
અમે 3 કદ એક સમસ્યા શરૂઆતમાં લીધો હતો.

175
00:09:21,000 --> 00:09:24,000
અમે પછી તે 2 કદ એક સમસ્યા તૂટી પડી હતી,

176
00:09:24,000 --> 00:09:27,000
પછી 1 કદ એક સમસ્યા છે, અને પછી છેવટે આધાર કેસ

177
00:09:27,000 --> 00:09:29,000
ખરેખર હતી, ઓહ, કોઈ ત્યાં એક છે,

178
00:09:29,000 --> 00:09:33,000
આ વખતે વિલી અસરકારક રીતે હાર્ડ કોડેડ જવાબ વખત બે પાછો ફર્યો,

179
00:09:33,000 --> 00:09:36,000
અને બીજા એક પછી bubbled આવ્યો bubbled, અપ bubbled,

180
00:09:36,000 --> 00:09:39,000
અને પછી આ એક વધારાની 1 માં ઉમેરીને

181
00:09:39,000 --> 00:09:41,000
અમે પુનરાર્તનના આ મૂળભૂત વિચાર અમલમાં કર્યું છે.

182
00:09:41,000 --> 00:09:44,000
>> હવે, આ કિસ્સામાં તે ખરેખર એક સમસ્યા હલ ન હતી

183
00:09:44,000 --> 00:09:46,000
કોઈ વધુ અસરકારક રીતે તો અમે આમ અત્યાર સુધી જોઇ છે.

184
00:09:46,000 --> 00:09:48,000
પરંતુ એલ્ગોરિધમ્સ અમે સ્ટેજ પર કર્યું છે આમ દૂર વિશે વિચારો.

185
00:09:48,000 --> 00:09:51,000
અમે chalkboard પર કાગળ 8 ના ટુકડા હતા,

186
00:09:51,000 --> 00:09:55,000
વિડિઓ પર હોય ત્યારે સીન એ 7 નંબર માટે જોઈ હતી, અને તે શું ખરેખર કરી?

187
00:09:55,000 --> 00:09:58,000
વેલ, તેમણે વિભાજન કોઇ પણ પ્રકારની નથી અને તેણે જીતી.

188
00:09:58,000 --> 00:10:01,000
તેમણે પુનરાર્તનના કોઇ પણ પ્રકારની ન હતી.

189
00:10:01,000 --> 00:10:03,000
તેને બદલે તેમને ફક્ત આ રેખીય અલ્ગોરિધમનો હતી.

190
00:10:03,000 --> 00:10:07,000
પરંતુ જ્યારે અમે સ્ટેજ પર છટણી નંબરો વિચારને રજૂ કરવામાં છેલ્લા અઠવાડિયે રહે છે

191
00:10:07,000 --> 00:10:09,000
પછી અમે મધ્યમ જવા આ વૃત્તિ હતી,

192
00:10:09,000 --> 00:10:13,000
જે બિંદુએ અમે 4 કદ અથવા 4 માપ અન્ય યાદી એક નાની યાદી હતી,

193
00:10:13,000 --> 00:10:17,000
અને પછી અમે ચોક્કસ જ સમસ્યા હતી, તેથી અમે વારંવાર પુનરાવર્તન પુનરાવર્તન.

194
00:10:17,000 --> 00:10:19,000
અન્ય શબ્દોમાં, આપણે recursed.

195
00:10:19,000 --> 00:10:24,000
તમે ખૂબ ખૂબ અમારા 3 સ્વયંસેવકો અહીં આભાર અમારી સાથે રિકર્ઝન દર્શાવવા માટે.

196
00:10:24,000 --> 00:10:28,000
>> ચાલો જોવા જો આપણે આ ન હવે થોડી વધુ કોંક્રિટ બનાવવા કરી શકો છો,

197
00:10:28,000 --> 00:10:30,000
એક સમસ્યા છે કે ફરી અમે ખૂબ સરળતાથી કરી શકે છે ઉકેલ,

198
00:10:30,000 --> 00:10:34,000
પરંતુ અમે તે વેગ આ મૂળભૂત વિચાર અમલમાં પથ્થર તરીકે ઉપયોગમાં લઈશું.

199
00:10:34,000 --> 00:10:37,000
જો હું નંબરો સમૂહ ના શ્રેઢી ગણતરી કરવા માંગો છો,

200
00:10:37,000 --> 00:10:39,000
દાખલા તરીકે, જો તમે 3 નંબર પાસ,

201
00:10:39,000 --> 00:10:42,000
હું તમારી 3 સિગ્મા કિંમત આપવા માંગો છો,

202
00:10:42,000 --> 00:10:46,000
જેથી 3 સરવાળા 2 + 1 + 0 +.

203
00:10:46,000 --> 00:10:48,000
હું પાછળ 6 જવાબ મેળવવા માંગો છો,

204
00:10:48,000 --> 00:10:51,000
તેથી અમે આ સિગ્મા કાર્ય, આ શ્રેઢી કાર્ય અમલમાં પડશે

205
00:10:51,000 --> 00:10:54,000
કે, ફરી, ઇનપુટ લે છે, અને પછી શ્રેઢી આપે છે

206
00:10:54,000 --> 00:10:57,000
તે નંબરના તમામ નીચે 0 રસ્તો.

207
00:10:57,000 --> 00:10:59,000
અમે આ ખૂબ સરળ કરવા માટે, યોગ્ય શકે છે?

208
00:10:59,000 --> 00:11:01,000
અમે રહ્યાં માળખું અમુક પ્રકારના સાથે આવું કરી શકે છે,

209
00:11:01,000 --> 00:11:04,000
જેથી દો મને આગળ વધો અને વિચાર આ શરૂઆત કરી હતી.

210
00:11:04,000 --> 00:11:07,000
>> Stdio.h સમાવેશ થાય છે.

211
00:11:07,000 --> 00:11:09,000
મને મારી મુખ્ય પ્રવેશ મેળવવા માટે અહીં સાથે કામ કરે છે.

212
00:11:09,000 --> 00:11:12,000
ચાલો sigma.c તરીકે આ સંગ્રહો.

213
00:11:12,000 --> 00:11:14,000
પછી હું અહીં જાઓ જાઉં છું, અને હું પૂર્ણાંક n એ જાહેર જાઉં છું,

214
00:11:14,000 --> 00:11:18,000
અને હું નીચે હો ત્યારે વપરાશકર્તાને સહકાર આપતું નથી જાઉં છું.

215
00:11:18,000 --> 00:11:22,000
જ્યારે વપરાશકર્તા મને હકારાત્મક નંબર આપી નથી

216
00:11:22,000 --> 00:11:26,000
દો મને આગળ જાઓ અને તેઓને = n GetInt માટે પૂછવા માટે,

217
00:11:26,000 --> 00:11:28,000
દો અને મને તેમને શું કરવા માટે કેટલાક સૂચનો આપવા માટે,

218
00:11:28,000 --> 00:11:33,000
જેથી printf ("હકારાત્મક પૂર્ણાંક કૃપા કરીને").

219
00:11:33,000 --> 00:11:39,000
જસ્ટ પ્રમાણમાં આ જેવા સરળ જેથી કંઈક કે જે સમય દ્વારા અમે 14 લીટી ફટકો

220
00:11:39,000 --> 00:11:42,000
આપણે હવે n એ એક સકારાત્મક કદાચ પૂર્ણાંક હોય છે.

221
00:11:42,000 --> 00:11:44,000
>> હવે તેની સાથે કંઈક દો.

222
00:11:44,000 --> 00:11:50,000
મને આગળ વધો અને શ્રેઢી ગણતરી છે, તેથી પૂર્ણાંક રકમ = સિગ્મા (n).

223
00:11:50,000 --> 00:11:54,000
સિગ્મા ફક્ત શ્રેઢી છે, તેથી હું ફક્ત પારખુ રીતે છું તે લખી.

224
00:11:54,000 --> 00:11:56,000
અમે હમણાં જ તે ત્યાં સિગ્મા કહી શકશો.

225
00:11:56,000 --> 00:11:58,000
કે રકમ છે, અને હવે હું બહાર પરિણામ છાપો જાઉં છું,

226
00:11:58,000 --> 00:12:08,000
printf (સરવાળો, "આ રકમ% d, \ n છે").

227
00:12:08,000 --> 00:12:11,000
અને પછી હું સારા પગલા 0 પરત મળશે.

228
00:12:11,000 --> 00:12:15,000
અમે રસપ્રદ ભાગ સિવાય બધું જ છે કે આ કાર્યક્રમ જરૂર કર્યું છે,

229
00:12:15,000 --> 00:12:18,000
જે વાસ્તવમાં સિગ્મા કાર્ય અમલમાં છે.

230
00:12:18,000 --> 00:12:22,000
>> દો મને નીચે અહીં નીચે જવું અને દો મને કાર્ય સિગ્મા જાહેર.

231
00:12:22,000 --> 00:12:26,000
તે ચલ છે કે જે પ્રકાર પૂર્ણાંક હતો લઈ મળ્યું છે,

232
00:12:26,000 --> 00:12:30,000
અને માહિતી પ્રકાર શું હું સિગ્મા માંથી કદાચ પાછા માંગો છો?

233
00:12:30,000 --> 00:12:34,000
ઈન્, કારણ કે હું તે 15 લીટી પર મારી અપેક્ષાઓ સાથે મેળ ખાતું કરવા માંગો છો.

234
00:12:34,000 --> 00:12:37,000
અહીં દો મને આગળ વધો અને આ અમલ

235
00:12:37,000 --> 00:12:41,000
એક સુંદર સરળ માર્ગ છે.

236
00:12:41,000 --> 00:12:45,000
>> ચાલો આગળ વધો અને પૂર્ણાંક રકમ = 0 કહેવું,

237
00:12:45,000 --> 00:12:47,000
અને હવે હું લૂપ માટે અહીં થોડું હોય જાઓ જાઉં છું

238
00:12:47,000 --> 00:12:50,000
કે આ કંઈક કહી રહ્યું છે,

239
00:12:50,000 --> 00:13:01,000
માટે (પૂર્ણાંક હું = 0; હું <નંબર =; i + +) + + રકમ હું =.

240
00:13:01,000 --> 00:13:05,000
અને પછી હું રકમ પરત જઇ રહ્યો છું.

241
00:13:05,000 --> 00:13:07,000
હું રીતે કોઈપણ સંખ્યાની આ છે અમલ કરી શકે છે.

242
00:13:07,000 --> 00:13:09,000
હું જ્યારે લૂપ ઉપયોગ કરી શકે.

243
00:13:09,000 --> 00:13:11,000
હું રકમ ચલ મદદથી જો હું ખરેખર કરવા માગે છૂટી હોઈ શકે છે,

244
00:13:11,000 --> 00:13:15,000
પરંતુ ટૂંકા, અમે માત્ર એક કાર્ય છે કે જો હું નથી goof જાહેર રકમ 0 ધરાવે છે.

245
00:13:15,000 --> 00:13:18,000
પછી તે પર 0 થી નંબર મારફતે iterates,

246
00:13:18,000 --> 00:13:23,000
અને દરેક ઇટરેશન પર તે રકમ કે વર્તમાન કિંમત ઉમેરે છે અને પછી રકમ પાછી આપે છે.

247
00:13:23,000 --> 00:13:25,000
>> હવે, ત્યાં થોડો ઓપ્ટિમાઇઝેશન અહીં છે.

248
00:13:25,000 --> 00:13:29,000
આ કદાચ પામે પગલું છે, પરંતુ તેથી તે છે. કે દંડ છે હવે.

249
00:13:29,000 --> 00:13:32,000
અમે ઓછામાં ઓછા છો સંપૂર્ણ છે અને પર 0 બધી રીતે જવું.

250
00:13:32,000 --> 00:13:34,000
હાર્ડ નથી અને ખૂબ ખૂબ સરળ,

251
00:13:34,000 --> 00:13:37,000
પરંતુ તે તારણ છે કે જે સિગ્મા કાર્ય સાથે અમે જ તક છે

252
00:13:37,000 --> 00:13:39,000
અમે મંચ પર અહીં કર્યું હતું.

253
00:13:39,000 --> 00:13:42,000
સ્ટેજ પર અમે ફક્ત ગણાશે કેટલા લોકો મને આગળ હતા,

254
00:13:42,000 --> 00:13:47,000
પરંતુ તેના બદલે જો આપણે 3 + 2 + 1 નંબર ગણતરી માગે છે

255
00:13:47,000 --> 00:13:51,000
0 નીચે પર અમે કાર્ય જેમ જ વાંસડા વડે એવી હોડી ચલાવવી કરી શકે

256
00:13:51,000 --> 00:13:55,000
કે હું બદલે ફરી યાદ આવવું હોવાથી વર્ણન કરીશું.

257
00:13:55,000 --> 00:13:57,000
અહીં આપણે એક ઝડપી સેનીટી અને તપાસ નથી ખાતરી છે કે હું goof ન કરો.

258
00:13:57,000 --> 00:14:00,000
>> મને ખબર છે કે આ કાર્યક્રમ ઓછામાં ઓછો એક વસ્તુ છે કે હું ખોટું કરી છે.

259
00:14:00,000 --> 00:14:04,000
જ્યારે હું દાખલ ફટકો હું મને અંતે yelling કોઇ પણ પ્રકારના વિચાર જાઉં છું?

260
00:14:04,000 --> 00:14:06,000
મારે શું લગભગ yelled કરી જાઉં છું?

261
00:14:06,000 --> 00:14:11,000
અરે વાહ, હું તે પ્રોટોટાઇપ ભૂલી ગયા છો, જેથી હું 15 વાક્ય પર સિગ્મા કહેવાય કાર્ય ઉપયોગ કરું છું,

262
00:14:11,000 --> 00:14:16,000
પરંતુ તે 22 વાક્ય સુધી જાહેર કરવામાં આવ્યું છે જેથી હું શ્રેષ્ઠ સક્રિય અહીં જાઓ

263
00:14:16,000 --> 00:14:22,000
અને અસલ જાહેર, અને હું પૂર્ણાંક સિગ્મા (પૂર્ણાંક સંખ્યા) કહેવું પડશે, અને તે છે.

264
00:14:22,000 --> 00:14:24,000
તે નીચે અમલમાં છે.

265
00:14:24,000 --> 00:14:27,000
>> અથવા બીજી રીતે હું આ હલ કરી શકે છે,

266
00:14:27,000 --> 00:14:30,000
હું ત્યાં સુધી કાર્ય ખસેડવા માટે, કે જે ખરાબ નથી શકે છે,

267
00:14:30,000 --> 00:14:32,000
પરંતુ ઓછામાં ઓછા જ્યારે તમારા કાર્યક્રમો માટે લાંબા વિચાર પ્રમાણિકપણે શરૂ કરવા માટે,

268
00:14:32,000 --> 00:14:35,000
મને લાગે છે ત્યાં હંમેશા શીર્ષ પર મુખ્ય કર્યા કેટલાક કિંમત છે

269
00:14:35,000 --> 00:14:38,000
જેથી તમે રીડર માં ફાઇલ ખોલો અને તે પછી તરત જ જોઈ શકે છે

270
00:14:38,000 --> 00:14:40,000
કાર્યક્રમ શું તે મારફતે શોધવા કર્યા વગર કરી છે

271
00:14:40,000 --> 00:14:42,000
કે મુખ્ય કાર્ય માટે જોઈ.

272
00:14:42,000 --> 00:14:49,000
ચાલો મારી ટર્મિનલ વિન્ડોમાં ઘટીને અહીં જાઓ, જેથી સિગ્મા સિગ્મા બનાવવા પ્રયાસ કરો,

273
00:14:49,000 --> 00:14:51,000
અને હું અહીં ખૂબ ખરાબ કર્યું.

274
00:14:51,000 --> 00:14:55,000
કાર્ય GetInt અભિપ્રેત ઘોષણા અર્થ છે મને શું બીજું શું ભૂલી ગયા છો?

275
00:14:55,000 --> 00:14:57,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

276
00:14:57,000 --> 00:15:00,000
ગુડ, જેથી એક સામાન્ય ભૂલ દેખીતી રીતે, તેથી આપણે આ અહીં મૂકી

277
00:15:00,000 --> 00:15:04,000
cs50.h, અને હવે આપણે મારા ટર્મિનલ વિન્ડોમાં પાછા જાઓ.

278
00:15:04,000 --> 00:15:08,000
>> હું સ્ક્રીન સાફ અને પડશે હું સિગ્મા બનાવવા પુનઃ ચલાવો પડશે.

279
00:15:08,000 --> 00:15:11,000
તે સંકલિત હોય તેમ લાગે છે. મને હવે સિગ્મા ચલાવો.

280
00:15:11,000 --> 00:15:15,000
હું સંખ્યા 3 માં લખો અને પડશે હું 6 વિચાર નહોતો, તેથી સખત નથી ચેક એક,

281
00:15:15,000 --> 00:15:18,000
પરંતુ ઓછામાં ઓછા તે પ્રથમ નજરમાં કામ કરી રહ્યું છે, પરંતુ હવે આપણે તેના ફાડી સિવાય,

282
00:15:18,000 --> 00:15:21,000
અને ચાલો ખરેખર રિકર્ઝન વિચારને ફરી લાભ,

283
00:15:21,000 --> 00:15:24,000
ખૂબ સરળ સંદર્ભ છે કે જેથી થોડા અઠવાડિયા સમય

284
00:15:24,000 --> 00:15:27,000
જ્યારે અમે એરે કરતાં પારખુ માહિતી માળખાં અન્વેષણ શરૂ

285
00:15:27,000 --> 00:15:30,000
અમે ટૂલકીટ બીજા સાધન કે જેની સાથે હોય છે

286
00:15:30,000 --> 00:15:33,000
તે માહિતી માળખાં ચાલાકી આપણે જોઈ શકશો.

287
00:15:33,000 --> 00:15:36,000
આ અભિગમ પુનરાવર્તન, આ અભિગમ લૂપ આધારિત છે.

288
00:15:36,000 --> 00:15:39,000
>> મને બદલે દો હવે આ કામ કરે છે.

289
00:15:39,000 --> 00:15:44,000
મને દો બદલે કહે છે કે સંખ્યાબંધ શ્રેઢી

290
00:15:44,000 --> 00:15:48,000
નીચે 0 પર ખરેખર જેવા જ વસ્તુ છે

291
00:15:48,000 --> 00:15:53,000
+ નંબર સિગ્મા (સંખ્યા - 1).

292
00:15:53,000 --> 00:15:57,000
અન્ય શબ્દોમાં, સ્ટેજ પર જેમ જ હું મારા માટે આગામી લોકો દરેક punted,

293
00:15:57,000 --> 00:16:00,000
અને તેઓ બદલામાં punting સુધી અમે આખરે વિલી અંતે આઉટ તળીયે રાખવામાં આવે છે,

294
00:16:00,000 --> 00:16:03,000
જેઓ 0 જેવા જવાબ હાર્ડ કોડેડ પાછા હતી.

295
00:16:03,000 --> 00:16:07,000
અહીં હવે આપણે જ રીતે સિગ્મા માટે punting કરી રહ્યાં છો

296
00:16:07,000 --> 00:16:10,000
એ જ કાર્ય તરીકે મૂળ બોલાવવામાં આવ્યો પણ કી સૂઝ અહીં

297
00:16:10,000 --> 00:16:12,000
છે કે અમે સિગ્મા સરખું નથી કૉલ કરી રહ્યાં છો.

298
00:16:12,000 --> 00:16:14,000
અમે n એ નથી પસાર કરી રહ્યાં છે.

299
00:16:14,000 --> 00:16:17,000
અમે સ્પષ્ટ સંખ્યામાં પસાર કરી રહ્યાં છો - 1,

300
00:16:17,000 --> 00:16:20,000
જેથી થોડી નાની સમસ્યા, થોડી નાની સમસ્યા.

301
00:16:20,000 --> 00:16:23,000
>> કમનસીબે, આ તદ્દન ઉકેલ હજુ સુધી નથી, અને તે પહેલાં અમે ઠીક

302
00:16:23,000 --> 00:16:26,000
સ્પષ્ટ તરીકે શું આઉટ થઈ શકે છે તમે કેટલીક જમ્પિંગ

303
00:16:26,000 --> 00:16:28,000
દો મને આગળ વધો અને બનાવવા પુનઃ ચલાવો.

304
00:16:28,000 --> 00:16:30,000
તે ઠીક કમ્પાઇલ લાગે છે.

305
00:16:30,000 --> 00:16:32,000
મને 6 સાથે સિગ્મા પુનઃ ચલાવો.

306
00:16:32,000 --> 00:16:37,000
દેખીતી ભૂલ માટે માફી (માગવી તે) દો, મને 6 સાથે સિગ્મા પુનઃ ચલાવો.

307
00:16:37,000 --> 00:16:42,000
અમે આ જોઇ છે, તે પહેલાં, આકસ્મિક છેલ્લા સમય યદ્યપિ છે.

308
00:16:42,000 --> 00:16:48,000
હું આ ભેદી સેગ્મેન્ટેશન ક્ષતિમાં કેમ મળ્યો? યાહ.

309
00:16:48,000 --> 00:16:50,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

310
00:16:50,000 --> 00:16:53,000
ત્યાં કોઈ આધાર કેસ છે, અને વધુ ચોક્કસ રીતે, શું કદાચ થયું?

311
00:16:53,000 --> 00:16:58,000
આ વર્તણૂક શું એક લક્ષણ છે?

312
00:16:58,000 --> 00:17:00,000
તે થોડું વધુ જોશથી કહો.

313
00:17:00,000 --> 00:17:02,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

314
00:17:02,000 --> 00:17:05,000
તે અનંત અસરકારક રીતે લૂપ, અને અનંત આંટીઓ સાથે સમસ્યા છે

315
00:17:05,000 --> 00:17:08,000
જ્યારે તેઓ આ કિસ્સામાં રિકર્ઝન થાય છે, એક કાર્ય પોતે ફોન,

316
00:17:08,000 --> 00:17:10,000
શું દર વખતે તમે એક કાર્ય કૉલ થાય છે?

317
00:17:10,000 --> 00:17:13,000
વેલ, અમે કેવી રીતે બહાર કમ્પ્યુટર માં મેમરી નાખ્યો પાછા વિચારો.

318
00:17:13,000 --> 00:17:16,000
અમે જણાવ્યું હતું કે મેમરી આ ભાગ સ્ટેક કે તળિયે છે કહેવાય છે,

319
00:17:16,000 --> 00:17:19,000
અને દર વખતે તમે એક કાર્ય થોડું વધારે મેમરી કૉલ મૂકવામાં નહીં

320
00:17:19,000 --> 00:17:24,000
આ કહેવાતા કે કાર્ય સ્થાનિક ચલો અથવા પરિમાણો સમાવતી સ્ટેક પર,

321
00:17:24,000 --> 00:17:27,000
તેથી જો સિગ્મા સિગ્મા કોલ્સ કહે સિગ્મા સિગ્મા કહે છે

322
00:17:27,000 --> 00:17:29,000
 સિગ્મા કહે છે જ્યાં આ વાર્તા ઓવરને કરે છે?

323
00:17:29,000 --> 00:17:31,000
>> વેલ, તે છેવટે કુલ જથ્થો મર્યાદાને વટાવ્યા

324
00:17:31,000 --> 00:17:33,000
મેમરી કે જે તમે તમારા કમ્પ્યુટર પર ઉપલબ્ધ હોય.

325
00:17:33,000 --> 00:17:37,000
તમે સેગમેન્ટ છે કે તમે અંદર રહેવાનું ધારતા કરી રહ્યાં છો રોળાઈ,

326
00:17:37,000 --> 00:17:40,000
અને તમે આ સેગ્મેન્ટેશન ક્ષતિમાં વિચાર, કોર ડમ્પ,

327
00:17:40,000 --> 00:17:43,000
અને કોર ડમ્પ શું અર્થ થાય છે કે હવે હું કોર તરીકે ઓળખાતી ફાઈલ છે

328
00:17:43,000 --> 00:17:46,000
જે zeros અને મુદ્દાઓ સમાવતી ફાઇલ છે

329
00:17:46,000 --> 00:17:49,000
કે ભવિષ્યમાં ખરેખર diagnostically ઉપયોગી થશે.

330
00:17:49,000 --> 00:17:52,000
જો તે તમે સ્પષ્ટ નથી કે જ્યાં તમારા ભૂલ છે

331
00:17:52,000 --> 00:17:54,000
તમે ખરેખર ફોરેન્સિક વિશ્લેષણ એક બીટ કરવું જેથી વાત કરવા માટે કરી શકો છો,,

332
00:17:54,000 --> 00:17:58,000
આ કોર ડમ્પ ફાઈલ પર ફરીથી, કે જે માત્ર zeros અને શૈલીઓનો સમગ્ર જથ્થો છે

333
00:17:58,000 --> 00:18:02,000
કે અનિવાર્યપણે મેમરી તમારા કાર્યક્રમ રાજ્યના પ્રતિનિધિત્વ

334
00:18:02,000 --> 00:18:05,000
જે ક્ષણે આ રીતે ક્રેશ થયું.

335
00:18:05,000 --> 00:18:11,000
>> અહીં સુધારો છે કે અમે માત્ર અકારણ સિગ્મા નથી પરત ફરી શકે છે,

336
00:18:11,000 --> 00:18:14,000
એક + નંબર થોડી નાની સમસ્યા સિગ્મા.

337
00:18:14,000 --> 00:18:16,000
અમે આધાર કેસ અમુક પ્રકારના અહીં જરૂર પડે છે,

338
00:18:16,000 --> 00:18:19,000
અને આધાર કેસ શું કદાચ હોવું જોઈએ?

339
00:18:19,000 --> 00:18:22,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

340
00:18:22,000 --> 00:18:25,000
ઠીક છે, તેથી લાંબા તરીકે નંબર હકારાત્મક છે અમે ખરેખર આ પાછા જોઈએ,

341
00:18:25,000 --> 00:18:29,000
અથવા બીજી રીતે મૂકી કે, જો નંબર છે, કહો, <= 0 ને

342
00:18:29,000 --> 00:18:32,000
તમને ખબર શું, હું આગળ જાઓ અને 0 પાછા પડશે,

343
00:18:32,000 --> 00:18:36,000
ખૂબ જેવા વિલી હતી, અને બીજું, હું આગળ જઈ રહ્યો છું

344
00:18:36,000 --> 00:18:41,000
અને આ પાછા છે, તેથી તે ટૂંકા ખૂબ નથી

345
00:18:41,000 --> 00:18:44,000
આવૃત્તિ પુનરાવર્તન કે અમે ચાબૂક મારી પ્રથમ લૂપ માટે એક કરતાં વધારે,

346
00:18:44,000 --> 00:18:48,000
નોટિસ પરંતુ ત્યાં તેને લાવણ્ય આ પ્રકારની છે.

347
00:18:48,000 --> 00:18:51,000
તેના બદલે અમુક નંબર પરત અને આ તમામ ગણિત પ્રદર્શન

348
00:18:51,000 --> 00:18:54,000
અને વસ્તુઓ સ્થાનિક ચલો સાથે ઉમેરીને

349
00:18:54,000 --> 00:18:57,000
તો તમે તેની જગ્યાએ કહી રહ્યાં છે "ઠીક છે, જો આ સુપર સરળ સમસ્યા છે,

350
00:18:57,000 --> 00:19:01,000
જેમ નંબર 0 <છે દો, મને તાત્કાલિક 0 આવો. "

351
00:19:01,000 --> 00:19:03,000
>> અમે ટેકો નકારાત્મક નંબરો સંતાપ નથી જઈ રહ્યાં છો,

352
00:19:03,000 --> 00:19:05,000
જેથી હું હાર્ડ કોડ 0 કિંમત જાઉં છું.

353
00:19:05,000 --> 00:19:08,000
પરંતુ અન્યથા, એકત્ર આ વિચાર અમલમાં માટે

354
00:19:08,000 --> 00:19:11,000
આ નંબરો ભેગા તમે અસરકારક રીતે નાના ડંખ લાગી શકે છે

355
00:19:11,000 --> 00:19:14,000
આ સમસ્યા બહાર ખૂબ જેવા અમે મંચ પર અહીં કર્યું,

356
00:19:14,000 --> 00:19:18,000
પછી વાંસડા વડે એવી હોડી ચલાવવી એ સમસ્યા આગામી વ્યક્તિ માટે બાકીના,

357
00:19:18,000 --> 00:19:20,000
પરંતુ આ કિસ્સામાં આગામી વ્યક્તિ પોતાને છે.

358
00:19:20,000 --> 00:19:22,000
તે સરખું નામ આપવામાં આવ્યું કાર્ય છે.

359
00:19:22,000 --> 00:19:25,000
બસ એક નાના અને નાના અને નાની સમસ્યા દરેક સમય પસાર કરવા માટે,

360
00:19:25,000 --> 00:19:28,000
અને છતાં પણ અમે કોડ નથી વસ્તુઓ તદ્દન ઔપચારિક અહીં છે

361
00:19:28,000 --> 00:19:33,000
આ છે બરાબર શું ફોન પુસ્તક સાથે 0 સપ્તાહમાં થઇ રહ્યા હતા.

362
00:19:33,000 --> 00:19:36,000
આ બરાબર શું ભૂતકાળ અઠવાડિયામાં સીન સાથે ચાલુ હતું

363
00:19:36,000 --> 00:19:39,000
અને નંબરો માટે શોધ અમારી દેખાવો સાથે.

364
00:19:39,000 --> 00:19:42,000
તે એક સમસ્યા લઈ રહ્યો છે અને તેને ફરીથી અને ફરીથી વિભાજન.

365
00:19:42,000 --> 00:19:44,000
>> બીજા શબ્દોમાં કહીએ તો, ત્યાં રસ્તો હવે અનુવાદ ઓફ

366
00:19:44,000 --> 00:19:47,000
આ વાસ્તવિક દુનિયા રચના, આ ઊંચુ સ્તર રચના

367
00:19:47,000 --> 00:19:51,000
ના ભાગલા પાડવા અને અને કબજે કંઈક ફરીથી અને ફરીથી કરી

368
00:19:51,000 --> 00:19:56,000
કોડ છે, તેથી આ કંઈક ફરીથી સમય પર જોવા મળશે છે.

369
00:19:56,000 --> 00:20:00,000
હવે, એક અલગ તરીકે, જો તમે રિકર્ઝન કરવા માટે નવા છો તમે ઓછામાં ઓછા હવે સમજવા જોઈએ

370
00:20:00,000 --> 00:20:02,000
આ રમૂજી શા માટે છે.

371
00:20:02,000 --> 00:20:05,000
હું google.com પર જાઓ જાઉં છું,

372
00:20:05,000 --> 00:20:17,000
અને હું કેટલાક રિકર્ઝન પર અને ટીપ્સ યુક્તિઓ શોધવા માટે જાઉં છું દાખલ કરો.

373
00:20:17,000 --> 00:20:21,000
તમારા માટે આગામી વ્યક્તિ કહો જો તેઓ માત્ર હવે નથી હસતી હતી.

374
00:20:21,000 --> 00:20:23,000
શું તમે રિકર્ઝન અર્થ આ છે?

375
00:20:23,000 --> 00:20:25,000
શું તમારો અર્થ-હેં, ત્યાં અમે જાઓ.

376
00:20:25,000 --> 00:20:28,000
ઠીક છે, હવે જે દરેક બાકીના છે.

377
00:20:28,000 --> 00:20:30,000
થોડું ઇસ્ટર એગ Google માં ક્યાંક ત્યાં એમ્બેડ.

378
00:20:30,000 --> 00:20:33,000
એક અલગ રીતે, એક કડીઓ અમે આ કોર્સ વેબસાઇટ પર મૂકવા એક તરીકે

379
00:20:33,000 --> 00:20:36,000
આજે માટે જ વિવિધ સોર્ટિંગ એલ્ગોરિધમ્સ આ ગ્રિડ છે,

380
00:20:36,000 --> 00:20:39,000
જેમાંથી કેટલાક અમે ગયા સપ્તાહે જોયું હતું, પરંતુ આ શું વિઝ્યુલાઇઝેશન વિશે સારું છે

381
00:20:39,000 --> 00:20:43,000
જેમ તમે વિવિધ ગાણિતીક નિયમો સંબંધિત બાબતો આસપાસ તમારા મન લપેટી પ્રયાસ

382
00:20:43,000 --> 00:20:46,000
ખબર છે કે તમે ખૂબ જ સરળતાથી હવે ઇનપુટ્સ વિવિધ પ્રકારના સાથે શરૂ કરી શકો છો.

383
00:20:46,000 --> 00:20:50,000
આ ઇનપુટ્સ તમામ ઇનપુટ્સ મોટે ભાગે છટણી, ઉલટી કે ઇનપુટ્સ રેન્ડમ અને તેથી આગળ.

384
00:20:50,000 --> 00:20:53,000
જેમ તમે, ફરીથી પ્રયત્ન કરો, તમારા ધ્યાનમાં આ વસ્તુઓ તફાવત

385
00:20:53,000 --> 00:20:57,000
સમજો કે વ્યાખ્યાનો પૃષ્ઠ પર આ કોર્સ વેબસાઇટ પર આ URL

386
00:20:57,000 --> 00:21:00,000
તમે તે કેટલાક મારફતે કારણ મદદ કરી શકે છે.

387
00:21:00,000 --> 00:21:05,000
>> આજે આપણે છેલ્લે એક જ્યારે આ સમસ્યા હલ પાછા મેળવવા માટે,

388
00:21:05,000 --> 00:21:08,000
જે કે આ સ્વેપ કાર્ય માત્ર કામ નહોતી,

389
00:21:08,000 --> 00:21:12,000
અને શું આ કાર્ય સ્વેપ સાથે મૂળભૂત સમસ્યા હતી,

390
00:21:12,000 --> 00:21:15,000
ધ્યેય જે હતો, ફરીથી માટે કિંમત અહીં અને અહીં બદલી

391
00:21:15,000 --> 00:21:17,000
જેમ કે આ શું થાય છે?

392
00:21:17,000 --> 00:21:20,000
આ વાસ્તવમાં કામ ન હતી. શા માટે?

393
00:21:20,000 --> 00:21:22,000
યાહ.

394
00:21:22,000 --> 00:21:28,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

395
00:21:28,000 --> 00:21:31,000
બરાબર, આ bugginess માટે સમજૂતી

396
00:21:31,000 --> 00:21:34,000
માત્ર હતો કારણ કે જ્યારે તમે સી કાર્યો કૉલ

397
00:21:34,000 --> 00:21:38,000
અને તે વિધેયો દલીલો a અને b અહીં જેમ, લેવા,

398
00:21:38,000 --> 00:21:42,000
તમે ગમે કિંમત છે કે જે તમને કાર્ય માટે પૂરી કરી રહ્યાં છે નકલો માં પસાર કરવામાં આવે છે.

399
00:21:42,000 --> 00:21:46,000
તમે મૂળ કિંમતો નથી પૂરી પોતાને થાય છે,

400
00:21:46,000 --> 00:21:49,000
તેથી અમે buggyc સંદર્ભમાં આ જોયું,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, કે જે આ જેવી થોડી કંઈક હતા.

402
00:21:52,000 --> 00:21:57,000
>> યાદ છે કે અમે હતો એક્સ અને વાય 1 અને 2 માટે આરંભ, અનુક્રમે.

403
00:21:57,000 --> 00:21:59,000
પછી અમે છપાયેલ તેઓ શું હતા.

404
00:21:59,000 --> 00:22:03,000
હું પછી દાવો કર્યો હતો કે હું તેમને એક્સ, વાય ના સ્વેપ ફોન દ્વારા જેઓ આવી હતી.

405
00:22:03,000 --> 00:22:06,000
પરંતુ સમસ્યા એ હતી કે જેઓ કામ કર્યું હતું,

406
00:22:06,000 --> 00:22:10,000
પરંતુ પોતે સ્વેપ તક જ કાર્ય કરે છે.

407
00:22:10,000 --> 00:22:13,000
જલદી અમે 40 લીટી તે સ્વૅપ કિંમતો ફટકો

408
00:22:13,000 --> 00:22:16,000
હતા બગાઙ, અને તેથી કશું

409
00:22:16,000 --> 00:22:21,000
મૂળ કાર્ય મુખ્ય ખરેખર બધા બદલવામાં આવી હતી,

410
00:22:21,000 --> 00:22:26,000
તેથી જો તમે પાછા પછી લાગે છે કે આ શું અમારી મેમરી દ્રષ્ટિએ જેવો દેખાય છે માટે

411
00:22:26,000 --> 00:22:29,000
જો બોર્ડના આ બાજુ ડાબા હાથથી પ્રતિનિધિત્વ

412
00:22:29,000 --> 00:22:33,000
અને હું દરેક માટે મારા શ્રેષ્ઠ કરવું જોશો આ જો બોર્ડના આ બાજુ ડાબી બાજુની

413
00:22:33,000 --> 00:22:37,000
જેમ કે, તમારી RAM, રજૂ કરે છે અને સ્ટેક આ રીતે પર વધવા રહ્યું છે,

414
00:22:37,000 --> 00:22:43,000
અને અમે મુખ્ય જેમ કાર્ય કહી, અને મુખ્ય 2 સ્થાનિક ચલો, એક્સ અને વાય છે,

415
00:22:43,000 --> 00:22:48,000
ચાલો એક્સ તરીકે તે અહીં વર્ણન અને ચાલો વાય તરીકે આ અહીં વર્ણન

416
00:22:48,000 --> 00:22:55,000
દો અને તે 1 કિંમતો અને 2 માં મૂકી, જેથી આ અહીં મુખ્ય છે,

417
00:22:55,000 --> 00:22:58,000
અને જ્યારે મુખ્ય સ્વેપ કાર્ય ઓપરેટિંગ સિસ્ટમ કોલ્સ

418
00:22:58,000 --> 00:23:02,000
સ્વેપ કાર્ય સ્ટેક પર તેની મેમરી પોતાના swath આપે છે,

419
00:23:02,000 --> 00:23:04,000
તેના સ્ટેક પર પોતાના ફ્રેમ, તેથી વાત કરવા માટે.

420
00:23:04,000 --> 00:23:08,000
તે પણ આ ints માટે 32 બિટ્સ ફાળવે છે.

421
00:23:08,000 --> 00:23:11,000
તેને a અને b કૉલ થાય છે, પરંતુ તે તદ્દન મનસ્વી છે.

422
00:23:11,000 --> 00:23:13,000
તે તેમની કહેવાય હોઈ શકે છે ગમે તે કરવા ઇચ્છે છે, પરંતુ શું થાય છે જ્યારે મુખ્ય

423
00:23:13,000 --> 00:23:19,000
કોલ્સ સ્વેપ છે તે 1 આ લે છે, એક ત્યાં નકલ મૂકે છે, નકલ ત્યાં મૂકે છે.

424
00:23:19,000 --> 00:23:23,000
>> ત્યાં 1 સ્વેપ અન્ય સ્થાનિક ચલ છે, જોકે, શું >> tmp કહેવાય.

425
00:23:23,000 --> 00:23:27,000
Tmp, તેથી દો મને મારી જાતને અન્ય 32 બિટ્સ અહીં આપી,

426
00:23:27,000 --> 00:23:29,000
અને હું શું આ કાર્ય કરતા હતા?

427
00:23:29,000 --> 00:23:34,000
મેં કહ્યું પૂર્ણાંક tmp એક, તેથી 1 છે નોંધાયો નહીં, તેથી હું આ કરી હતી જ્યારે અમે છેલ્લે આ ઉદાહરણ સાથે રમી હતી.

428
00:23:34,000 --> 00:23:39,000
પછી બો નહીં, તેથી બો 2 છે, તેથી હવે આ 2 બને છે,

429
00:23:39,000 --> 00:23:42,000
અને હવે બોલ્ડ કામચલાઉ નોકર નહીં, તેથી temp 1,

430
00:23:42,000 --> 00:23:44,000
તેથી હવે b આ બને છે.

431
00:23:44,000 --> 00:23:46,000
કે મહાન છે. તે કામ કર્યું હતું.

432
00:23:46,000 --> 00:23:49,000
પછી પણ ટૂંક સમયમાં કાર્ય વળતર

433
00:23:49,000 --> 00:23:52,000
ની સ્વેપ મેમરી અસરકારક રીતે અદૃશ્ય થઈ જાય છે કે જેથી તેનો ફરી ઉપયોગ કરી શકાય છે

434
00:23:52,000 --> 00:23:58,000
ભવિષ્યમાં અમુક અન્ય કાર્ય દ્વારા, અને મુખ્ય દેખીતી રીતે સંપૂર્ણપણે યથાવત છે.

435
00:23:58,000 --> 00:24:00,000
અમે મૂળભૂત આ સમસ્યા હલ કરવાની એક રીત જરૂર છે,

436
00:24:00,000 --> 00:24:03,000
અને આજે આપણે છેલ્લે આવું જેમાં એક માર્ગ પડશે

437
00:24:03,000 --> 00:24:06,000
અમે નિર્દેશક તરીકે ઓળખાય છે કંઈક દાખલ કરી શકો છો.

438
00:24:06,000 --> 00:24:09,000
તે તારણ છે કે અમે આ સમસ્યાનો ઉકેલ કરી શકો છો

439
00:24:09,000 --> 00:24:12,000
એક્સ અને વાય નકલો ન પસાર કરીને

440
00:24:12,000 --> 00:24:18,000
પરંતુ માં પસાર કરીને તેના બદલે, તમે સ્વેપ કાર્ય કરવા માટે વિચારો છો?

441
00:24:18,000 --> 00:24:20,000
અરે વાહ, આ સરનામું વિશે શું?

442
00:24:20,000 --> 00:24:22,000
અમે ખરેખર ખૂબ વિગતવાર સરનામાં વિશે વાત કરી છે,

443
00:24:22,000 --> 00:24:25,000
પરંતુ જો આ વર્ગમાં વપરાતું કાળું પાટિયું મારા કમ્પ્યુટર મેમરી પ્રતિનિધિત્વ

444
00:24:25,000 --> 00:24:28,000
અમે ચોક્કસપણે મારી RAM માં બાઇટ્સ નંબરવાળી શરૂ કરી શકે છે

445
00:24:28,000 --> 00:24:31,000
અને કહે છે આ # 1 બાઇટ છે, આ બાઇટ છે 2 #, બાઇટ 3 #,

446
00:24:31,000 --> 00:24:35,000
# 4, બાઇટ # ... 2 અબજ જો હું RAM ની 2 ગીગાબાઇટ્સ હોય બાઇટ,

447
00:24:35,000 --> 00:24:38,000
જેથી અમે ચોક્કસપણે અમુક મનસ્વી નંબર યોજના સાથે બન્યું

448
00:24:38,000 --> 00:24:41,000
મારા કમ્પ્યુટર મેમરી બધી વ્યક્તિગત બાઇટ્સ છે.

449
00:24:41,000 --> 00:24:43,000
>> જો તેના બદલે ત્યારે શું હું સ્વેપ કૉલ

450
00:24:43,000 --> 00:24:47,000
એક્સ અને વાય નકલો બદલે પાસ

451
00:24:47,000 --> 00:24:51,000
હું ને બદલે એક્સ ના અહીં સરનામું શા માટે પાસ કરતું નથી,

452
00:24:51,000 --> 00:24:55,000
વાય ના અહીં સરનામું, જરૂરીયાતમાં પોસ્ટલ સરનામા

453
00:24:55,000 --> 00:24:59,000
એક્સ અને વાય કારણે તે પછી સ્વેપ, જો તે માહિતગાર છે

454
00:24:59,000 --> 00:25:01,000
એક્સ અને વાય મેમરી માં સરનામું,

455
00:25:01,000 --> 00:25:04,000
પછી સ્વેપ, જો અમે તેને થોડો તાલીમ આપી,

456
00:25:04,000 --> 00:25:07,000
તેમણે સંભવિત છે કે સરનામા માટે વાહન જેથી વાત કરવા માટે કરી શકે છે,

457
00:25:07,000 --> 00:25:11,000
એક્સ, અને ત્યાં નંબર બદલવા માટે, તે પછી વાય ના સરનામા માટે વાહન,

458
00:25:11,000 --> 00:25:16,000
સંખ્યા ત્યાં બદલવા માટે, ત્યારે પણ તે પોતાની જાતને કિંમતો નકલો ખરેખર નથી મળતું,

459
00:25:16,000 --> 00:25:19,000
તેથી ભલે અમે મુખ્ય મેમરી હોવાથી આ અંગે વાત કરી

460
00:25:19,000 --> 00:25:23,000
અને આ છે તે સ્વેપ મેમરી શક્તિશાળી અને C ની ખતરનાક ભાગ

461
00:25:23,000 --> 00:25:28,000
છે કે જે કોઈપણ કાર્ય મેમરી કમ્પ્યુટર ગમે ત્યાં સ્પર્શ કરી શકે છે,

462
00:25:28,000 --> 00:25:32,000
અને આ શક્તિશાળી છે કે તમે સી માં કોમ્પ્યુટર પ્રોગ્રામ સાથે ખૂબ ફેન્સી વસ્તુઓ કરી શકો છો

463
00:25:32,000 --> 00:25:36,000
આ ખતરનાક છે કારણ કે તમે પણ ખૂબ જ સરળતાથી સ્ક્રૂ કરી શકો છો.

464
00:25:36,000 --> 00:25:39,000
હકીકતમાં, એક પ્રોગ્રામ માટે સૌથી સામાન્ય રીતે આ દિવસ શોષણ કરવા

465
00:25:39,000 --> 00:25:42,000
હજુ પણ છે પ્રોગ્રામર ખ્યાલ નથી

466
00:25:42,000 --> 00:25:45,000
કે તે અથવા તેણી એક માહિતી પરવાનગી આપી છે

467
00:25:45,000 --> 00:25:49,000
મેમરી માં સ્થાન ન કરવાનો ઈરાદો હતો લખવામાં આવે છે.

468
00:25:49,000 --> 00:25:51,000
>> હમણાં પૂરતું, તે અથવા તેણી 10 કદ ઝાકઝમાળ ઘોષણા

469
00:25:51,000 --> 00:25:56,000
પરંતુ પછી આકસ્મિક મેમરી કે એરે માં 11 બાઇટ્સ મૂકવા પ્રયાસ કરે છે,

470
00:25:56,000 --> 00:25:59,000
અને તમે મેમરી ભાગો છે કે જે લાંબા સમય સુધી માન્ય સ્પર્શ કરવાનું શરૂ કરો.

471
00:25:59,000 --> 00:26:02,000
જસ્ટ સંદર્ભ આ કરવા માટે, તમારે અમુક ખબર છે કે

472
00:26:02,000 --> 00:26:06,000
સોફ્ટવેર ઘણીવાર તમે સીરીયલ નંબર અથવા નોંધણી કીઓ માટે પૂછે છે,

473
00:26:06,000 --> 00:26:08,000
ફોટોશોપ અને વર્ડ અને આ જેવા કાર્યક્રમો.

474
00:26:08,000 --> 00:26:12,000
ત્યાં તિરાડો અસ્તિત્વ ધરાવે છે, જેમ તમે કેટલાક ખબર, ઓનલાઇન જ્યાં તમે થોડી કાર્યક્રમ ચલાવી શકો છો,

475
00:26:12,000 --> 00:26:14,000
અને વોઇલા Query, સીરીયલ નંબર માટે આ બોલ પર કોઈ વધુ વિનંતી.

476
00:26:14,000 --> 00:26:16,000
કેવી રીતે કામ કરે છે?

477
00:26:16,000 --> 00:26:21,000
ઘણા કિસ્સાઓમાં આ વસ્તુઓ સરળ કોમ્પ્યુટરો શોધી રહ્યાં છે

478
00:26:21,000 --> 00:26:24,000
આ કોમ્પ્યુટર ખરેખર zeros અને મુદ્દાઓ પર ટેક્સ્ટ સેગમેન્ટો

479
00:26:24,000 --> 00:26:28,000
જ્યાં કાર્ય કે જ્યાં સીરીયલ નંબર વિનંતી છે,

480
00:26:28,000 --> 00:26:31,000
અને તમે તે જગ્યા પર ફરીથી લખી, અથવા જ્યારે કાર્યક્રમ ચાલી રહ્યો છે

481
00:26:31,000 --> 00:26:33,000
તમે આકૃતિ જ્યાં કી વાસ્તવમાં સંગ્રહાયેલ છે કરી શકો છો

482
00:26:33,000 --> 00:26:37,000
કંઈક ઉપયોગ કરીને ડીબગર તરીકે ઓળખાય છે, અને તમે સોફ્ટવેર કે જે રીતે ક્રેક કરી શકો છો.

483
00:26:37,000 --> 00:26:40,000
આ દિવસ તો આગલા બે માટે કહે છે કે આ અમારી ઉદ્દેશ નથી,

484
00:26:40,000 --> 00:26:42,000
પણ તે ખૂબ જ વાસ્તવિક વિશ્વમાં વિભાગીકરણ છે.

485
00:26:42,000 --> 00:26:45,000
કે જે એક સોફ્ટવેર ચોરી સમાવેશ થાય છે,

486
00:26:45,000 --> 00:26:47,000
પરંતુ ત્યાં પણ સમગ્ર મશીનો સમાધાન છે.

487
00:26:47,000 --> 00:26:50,000
>> હકીકતમાં, વેબસાઇટ્સ આ દિવસોમાં જ્યારે લેવાતા હોય છે

488
00:26:50,000 --> 00:26:53,000
અને ગડબડ અને માહિતી લીક છે અને પાસવર્ડો ચોરી થાય છે

489
00:26:53,000 --> 00:26:58,000
આ ઘણી વાર એક મેમરી ખરાબ સંલગ્ન,

490
00:26:58,000 --> 00:27:01,000
અથવા, ડેટાબેઝો કિસ્સામાં, નિષ્ફળતા પૂર્વાનુમાન માટે

491
00:27:01,000 --> 00:27:03,000
વિરોધી ઇનપુટ, તેથી અઠવાડિયામાં પર વધુ આવે છે,

492
00:27:03,000 --> 00:27:07,000
પરંતુ હવે માત્ર નુકસાન ના પ્રકારના એક ઝલક પૂર્વદર્શન કે તમે શું કરી શકો છો

493
00:27:07,000 --> 00:27:11,000
સમજવા કેવી રીતે વસ્તુઓ હૂડ નીચે કામ નથી તદ્દન દ્વારા.

494
00:27:11,000 --> 00:27:14,000
ચાલો સમજ્યા શા માટે આ ભાંગી છે તે વિશે જાઓ

495
00:27:14,000 --> 00:27:17,000
એ સાધન છે કે વધુ અને વધુ ઉપયોગી બનશે

496
00:27:17,000 --> 00:27:19,000
આપણા કાર્યક્રમો વધુ જટિલ છે.

497
00:27:19,000 --> 00:27:21,000
આમ અત્યાર સુધીમાં જ્યારે તમે તમારા કાર્યક્રમ માં ભૂલ હતી

498
00:27:21,000 --> 00:27:23,000
તમે તેને ડિબગીંગ વિશે કેવી રીતે ગયા છો?

499
00:27:23,000 --> 00:27:25,000
તમારા યુકિતઓ શું આમ દૂર કરવામાં આવી છે, ભલે તે તમારી ટીએફ દ્વારા શીખવવામાં

500
00:27:25,000 --> 00:27:27,000
અથવા માત્ર આત્મ શીખવવામાં?

501
00:27:27,000 --> 00:27:29,000
[વિદ્યાર્થી] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, તેથી printf કદાચ કે તમારા મિત્ર જો તમે જોવા માંગો છો

503
00:27:31,000 --> 00:27:33,000
શું થઈ રહ્યું છે તે અંદર તમારા કાર્યક્રમ

504
00:27:33,000 --> 00:27:36,000
તમે હમણાં printf અહીં મૂકો, printf અહીં, printf અહીં.

505
00:27:36,000 --> 00:27:38,000
પછી તમે તેને ચલાવવા માટે છે, અને તમે સ્ક્રીન પર સામગ્રી સમગ્ર જથ્થો વિચાર

506
00:27:38,000 --> 00:27:43,000
કે જે તમે પછી જાણી શું ખરેખર તમારા કાર્યક્રમ છે ખોટું થઈ રહ્યું છે ઉપયોગ કરી શકો છો.

507
00:27:43,000 --> 00:27:45,000
>> Printf ખૂબ શક્તિશાળી વસ્તુ હોઈ શકે છે,

508
00:27:45,000 --> 00:27:47,000
પરંતુ તે એક ખૂબ જ જાતે પ્રક્રિયા છે.

509
00:27:47,000 --> 00:27:49,000
તમે એક printf અહીં મૂકો પાસે printf અહીં,

510
00:27:49,000 --> 00:27:51,000
અને જો તમે તે લૂપની અંદર મૂકવામાં તમે 100 લીટીઓ વિચાર કરી શકે છે

511
00:27:51,000 --> 00:27:53,000
આઉટપુટ કે જે તમે પછી મારફતે સત્ય હકીકત તારવવી હોય.

512
00:27:53,000 --> 00:27:58,000
તે ડિબગીંગ કાર્યક્રમો માટે ખૂબ વપરાશકર્તા મૈત્રીપૂર્ણ અથવા અરસપરસ પદ્ધતિ નથી,

513
00:27:58,000 --> 00:28:00,000
પરંતુ thankfully ત્યાં વિકલ્પો હાજર છે.

514
00:28:00,000 --> 00:28:03,000
ત્યાં હમણાં માટે એક કાર્યક્રમ, GDB તરીકે ઓળખાય છે, એ GNU ડિબગર છે,

515
00:28:03,000 --> 00:28:06,000
જે તમે કેવી રીતે તેનો ઉપયોગ માં થોડો arcane છે.

516
00:28:06,000 --> 00:28:08,000
તે થોડી જટિલ છે, પ્રમાણિકપણે પરંતુ,

517
00:28:08,000 --> 00:28:11,000
આ તે વસ્તુઓ જ્યાં જો તમે આ સપ્તાહમાં મૂક્યો અને એક પછી આવે છે

518
00:28:11,000 --> 00:28:14,000
વધારાની માટે GDB કંઈક સમજવું કલાક

519
00:28:14,000 --> 00:28:18,000
તે તમને લાંબા ગાળે કલાકો કદાચ દસ બચાવે છે,

520
00:28:18,000 --> 00:28:21,000
જેથી સાથે દો, મને તમે કેવી રીતે આ વસ્તુ કામ કરે છે તે કઠણ પ્રશ્ન આપે છે.

521
00:28:21,000 --> 00:28:23,000
>> હું મારા ટર્મિનલ વિન્ડોમાં છું.

522
00:28:23,000 --> 00:28:26,000
મને આગળ વધો અને આ કાર્યક્રમ, buggy3 કમ્પાઇલ.

523
00:28:26,000 --> 00:28:28,000
તે પહેલાથી જ છે તારીખ છે.

524
00:28:28,000 --> 00:28:31,000
દો મને તેને ચલાવવા માટે જેમ અમે જ્યારે પાછળ હતી, અને ખરેખર, તે ભાંગી છે.

525
00:28:31,000 --> 00:28:34,000
પરંતુ આ શા માટે છે? કદાચ હું સ્વેપ કાર્ય ખરાબ કર્યું.

526
00:28:34,000 --> 00:28:37,000
કદાચ તે અને બોલ્ડ છે. હું તદ્દન તેમને ખસેડવા છું યોગ્ય રીતે આસપાસ.

527
00:28:37,000 --> 00:28:39,000
મને આગળ વધો અને આ કરવા માટે.

528
00:28:39,000 --> 00:28:43,000
બદલે માત્ર buggy3 સ્કોર દો મને બદલે આ કાર્યક્રમ GDB ચલાવવા માટે,

529
00:28:43,000 --> 00:28:48,000
અને હું તેને કહી buggy3 સ્કોર જાઉં છું,

530
00:28:48,000 --> 00:28:52,000
અને હું એક આદેશ વાક્ય દલીલ, તૂઇ સમાવેશ જાઉં છું,

531
00:28:52,000 --> 00:28:55,000
અને અમે સ્પેક અંતે ભાવિ સમસ્યાઓ યાદ માં આ મૂકીશું.

532
00:28:55,000 --> 00:28:57,000
અને હવે આ કાળા અને સફેદ ઈન્ટરફેસ ઉપર પોપ કે ફરીથી,

533
00:28:57,000 --> 00:28:59,000
પ્રથમ થોડો જબરજસ્ત છે કારણ કે ત્યાં આ તમામ

534
00:28:59,000 --> 00:29:02,000
અહીં નીચે વોરંટી માહિતી, પરંતુ ઓછામાં ઓછા ત્યાં પરિચિત કંઈક છે.

535
00:29:02,000 --> 00:29:04,000
વિન્ડોની ટોચ મારા વાસ્તવિક કોડ છે,

536
00:29:04,000 --> 00:29:08,000
અને જો હું અહીં સ્ક્રોલ દો મને ખૂબ જ મારા ફાઈલ શીર્ષ સરકાવવા,

537
00:29:08,000 --> 00:29:11,000
અને ખરેખર, આ વિન્ડોની તળિયે buggy3.c, અને સૂચના છે

538
00:29:11,000 --> 00:29:13,000
હું આ GDB પ્રોમ્પ્ટ હોય છે.

539
00:29:13,000 --> 00:29:16,000
>> આ મારો સામાન્ય જ્હોન હાર્વર્ડ પ્રોમ્પ્ટ તરીકે જ નથી.

540
00:29:16,000 --> 00:29:19,000
આ પ્રોમ્પ્ટ કરે છે કે જે મને GDB નિયંત્રિત કરવા માટે પરવાનગી આપે છે ચાલી રહ્યું છે છે.

541
00:29:19,000 --> 00:29:21,000
GDB એક ડીબગર છે.

542
00:29:21,000 --> 00:29:24,000
એક ડીબગર એક કાર્યક્રમ છે કે જે તમને લઈ જવામાં આવે છે

543
00:29:24,000 --> 00:29:27,000
તમારા કાર્યક્રમ વાક્ય વાક્ય દ્વારા વાક્ય દ્વારા મૃત્યુદંડ,

544
00:29:27,000 --> 00:29:30,000
જે રીતે તમે કંઈપણ કાર્યક્રમ કરવા માંગો છો કરી સાથે,

545
00:29:30,000 --> 00:29:33,000
પણ વિધેયો કૉલ, અથવા looking વધુ અગત્યનું,

546
00:29:33,000 --> 00:29:35,000
વિવિધ ચલ કિંમતો છે.

547
00:29:35,000 --> 00:29:37,000
ચાલો આગળ વધો અને આ કરવા માટે.

548
00:29:37,000 --> 00:29:40,000
હું આગળ જાઓ અને GDB પ્રોમ્પ્ટ પર લખો રન જાઉં છું,

549
00:29:40,000 --> 00:29:43,000
જેથી સ્ક્રીન હું લખ્યો રન કર્યા છે તળિયે ડાબી બાજુએ નોટિસ,

550
00:29:43,000 --> 00:29:45,000
અને હું દાખલ ફટકો કર્યું છે, અને તે શું હતી?

551
00:29:45,000 --> 00:29:50,000
તે શાબ્દિક મારા કાર્યક્રમ ચાલી હતી, પરંતુ હું ખરેખર ખૂબ અહીં પર જાઓ નથી દેખાતી

552
00:29:50,000 --> 00:29:55,000
કારણ કે હું ખરેખર ડીબગર નથી કહે છે

553
00:29:55,000 --> 00:29:57,000
સમય ચોક્કસ ક્ષણે વિરામ છે.

554
00:29:57,000 --> 00:29:59,000
જસ્ટ રન લખીને કાર્યક્રમ ચાલે છે.

555
00:29:59,000 --> 00:30:01,000
હું ખરેખર કંઈપણ દેખાતી નથી. મેં તે કામ કરી શકે છે.

556
00:30:01,000 --> 00:30:03,000
>> તેના બદલે દો મને આ કરવા માટે.

557
00:30:03,000 --> 00:30:08,000
આ GDB પ્રોમ્પ્ટ પર દો મને બદલે વિરામ લખો દાખલ કરો.

558
00:30:08,000 --> 00:30:10,000
કે નથી હું શું લખો હતો.

559
00:30:10,000 --> 00:30:13,000
ની જગ્યાએ દો વિરામ મુખ્ય લખો.

560
00:30:13,000 --> 00:30:15,000
અન્ય શબ્દોમાં, હું એક બ્રેકપોઇન્ટ કહેવાય કંઈક સેટ કરવા માંગો છો,

561
00:30:15,000 --> 00:30:18,000
જે યોગ્ય રીતે કારણ કે તે ભંગ અથવા વિરામ કરશે આવ્યું છે

562
00:30:18,000 --> 00:30:21,000
તમારા કાર્યક્રમ છે કે ચોક્કસ જગ્યાએ અમલ.

563
00:30:21,000 --> 00:30:23,000
મુખ્ય મારું કાર્ય નામ છે.

564
00:30:23,000 --> 00:30:25,000
નોંધ કરો કે GDB ખૂબ સ્માર્ટ છે.

565
00:30:25,000 --> 00:30:28,000
તે figured છે કે મુખ્ય થી 18 વાક્ય પર આશરે શરૂ થાય છે

566
00:30:28,000 --> 00:30:32,000
buggy3.c, અને પછી શીર્ષ પર ડાબે અહીં નોટિસ

567
00:30:32,000 --> 00:30:34,000
B + અધિકાર 18 વાક્ય આગામી છે.

568
00:30:34,000 --> 00:30:38,000
કે મને યાદ છે કે હું 18 વાક્ય પર એક બ્રેકપોઇન્ટ સેટ છે.

569
00:30:38,000 --> 00:30:42,000
આ સમય છે જ્યારે હું રન લખો, હું મારું કાર્યક્રમ ચલાવવા જાઉં છું

570
00:30:42,000 --> 00:30:45,000
અપ સુધી તે બ્રેકપોઇન્ટ બનાવ્યા,

571
00:30:45,000 --> 00:30:48,000
જેથી કાર્યક્રમ મારા માટે 18 વાક્ય પર વિરામ કરશે.

572
00:30:48,000 --> 00:30:50,000
અહીં અમે જાઓ, ચલાવો.

573
00:30:50,000 --> 00:30:53,000
કંઈ થયું હોવાનું જણાય છે, પરંતુ તળિયે નોટિસ બાકી

574
00:30:53,000 --> 00:30:58,000
શરૂ કાર્યક્રમ, buggy3, મુખ્ય માં buggy3.c 18 વાક્ય પર 1 બ્રેકપોઇન્ટ.

575
00:30:58,000 --> 00:31:00,000
હું શું હવે કરી શકો છો?

576
00:31:00,000 --> 00:31:03,000
>> નોંધ હું પ્રિન્ટ જેવી વસ્તુઓ લખીને શરૂ કરી શકો છો,

577
00:31:03,000 --> 00:31:08,000
printf નથી, પ્રિન્ટ એક્સ, અને હવે એ વિચિત્ર છે.

578
00:31:08,000 --> 00:31:11,000
આ $ 1 માત્ર એક જિજ્ઞાસા છે, કારણ કે અમે જોશો

579
00:31:11,000 --> 00:31:14,000
દરેક વખતે જ્યારે તમે કંઈક પ્રિન્ટ તમે નવી કિંમત $ મેળવો.

580
00:31:14,000 --> 00:31:18,000
કે જેથી છે કે તમે પાછા કેસ ફક્ત અગાઉના કિંમતો ઉલ્લેખ કરી શકે છે,

581
00:31:18,000 --> 00:31:21,000
પરંતુ હવે માટે પ્રિન્ટ મને કહેવાની છે શું એ છે કે વાર્તામાં આ બિંદુએ x ની કિંમત

582
00:31:21,000 --> 00:31:26,000
દેખીતી રીતે છે 134514032.

583
00:31:26,000 --> 00:31:29,000
શું? જ્યાં પણ નહોતી આવે?

584
00:31:29,000 --> 00:31:31,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

585
00:31:31,000 --> 00:31:34,000
ખરેખર, આ છે જેને આપણે કચરો કિંમત કહી શકશો, અને અમે આ વિશે હજુ સુધી વાત કરી છે,

586
00:31:34,000 --> 00:31:37,000
પરંતુ કારણ કે તમે ચલો પ્રારંભ

587
00:31:37,000 --> 00:31:40,000
દેખીતી રીતે કે જેથી તેઓ કેટલાક કિંમત છે કે જે તમે તેમને કરવા માંગો છો હોય છે.

588
00:31:40,000 --> 00:31:44,000
પરંતુ કેચ યાદ છે કે તમે ચલો જાહેર કરી શકો છો

589
00:31:44,000 --> 00:31:46,000
જેમ હું મારી સિગ્મા ઉદાહરણ એક ક્ષણ પહેલા કર્યું

590
00:31:46,000 --> 00:31:48,000
વાસ્તવમાં તેમને કિંમત આપ્યા વગર.

591
00:31:48,000 --> 00:31:50,000
યાદ મને શું પર સિગ્મા અહીં કર્યું હતું.

592
00:31:50,000 --> 00:31:52,000
હું n એ જાહેર, પરંતુ કિંમત શું હું તેને આપી હતી?

593
00:31:52,000 --> 00:31:56,000
કંઈ નહિં, કારણ કે મને ખબર છે કે આગામી થોડા રેખાઓ

594
00:31:56,000 --> 00:31:59,000
GetInt n ના અંદર કિંમત મૂકી સમસ્યા કાળજી લેશે.

595
00:31:59,000 --> 00:32:02,000
>> પરંતુ 11 લીટી વાર્તા આ બિંદુએ

596
00:32:02,000 --> 00:32:05,000
અને રેખા 12 અને 13 લાઇન અને 14 લાઇન

597
00:32:05,000 --> 00:32:08,000
તે અનેક રેખાઓ સમગ્ર n ના કિંમત શું છે?

598
00:32:08,000 --> 00:32:10,000
સી માં તમે માત્ર ખબર નથી.

599
00:32:10,000 --> 00:32:14,000
તે સામાન્ય રીતે કેટલાક કચરો કિંમત, કેટલાક સંપૂર્ણપણે રેન્ડમ નંબર છે

600
00:32:14,000 --> 00:32:17,000
કે બાકી છે અનિવાર્યપણે અગાઉની કેટલીક વિધેય માંથી

601
00:32:17,000 --> 00:32:21,000
એવું ચલાવવા માટે, કરવામાં આવી છે જેથી તમારા કાર્યક્રમ ચલાવે છે

602
00:32:21,000 --> 00:32:24,000
જણાવ્યું હતું કે કાર્ય કાર્ય, કાર્ય કાર્ય, નોંધાયો નહીં.

603
00:32:24,000 --> 00:32:27,000
આ તમામ ફ્રેમ્સ મેમરી પર મૂકવા માટે, અને પછી તે વિધેયો વળતર,

604
00:32:27,000 --> 00:32:31,000
અને જેમ હું ભૂંસવા માટેનું રબર તેમના મેમરી છેવટે ફરીથી સાથે સૂચવ્યું છે.

605
00:32:31,000 --> 00:32:37,000
વેલ, તે માત્ર જેથી આ કાર્યક્રમ છે કે જે આ ચલ x થાય છે

606
00:32:37,000 --> 00:32:41,000
માટે 134514032 જેવા કેટલાક કચરો કિંમત સમાયેલ હોય તેમ લાગે છે

607
00:32:41,000 --> 00:32:44,000
અગાઉની કેટલીક કાર્ય છે, એક નથી કે હું લખી હતી.

608
00:32:44,000 --> 00:32:47,000
તે કંઈક કે જે ઓપરેટીંગ સિસ્ટમ સાથે અસરકારક રીતે આવે હોઇ શકે છે,

609
00:32:47,000 --> 00:32:49,000
હૂડ નીચે કેટલાક કાર્ય કરે છે.

610
00:32:49,000 --> 00:32:52,000
>> ઠીક છે, કે દંડ છે, પરંતુ હવે દો આગામી વાક્ય આગળ.

611
00:32:52,000 --> 00:32:55,000
જો હું મારો GDB પ્રોમ્પ્ટ પર "આગામી" લખો અને હું દાખલ દબાવો,

612
00:32:55,000 --> 00:32:58,000
નોંધ્યું છે કે ચાલ હાયલાઇટ 19 વાક્ય ડાઉન

613
00:32:58,000 --> 00:33:01,000
પરંતુ લોજિકલ સૂચિતાર્થ છે કે 18 વાક્ય છે

614
00:33:01,000 --> 00:33:06,000
હવે સમાપ્ત "પ્રિન્ટ એક્સ" ચલાવવા, તેથી જો હું ફરી લખો

615
00:33:06,000 --> 00:33:10,000
હવે હું 1 જોવા જોઈએ અને ખરેખર, હું નથી.

616
00:33:10,000 --> 00:33:14,000
ફરીથી, આ સામગ્રી $ GDB તમે યાદ એક માર્ગ છે

617
00:33:14,000 --> 00:33:17,000
પ્રિન્ટ ઇતિહાસ શું છે કે તમે પૂર્ણ કર્યું છે.

618
00:33:17,000 --> 00:33:21,000
હવે મને આગળ વધો અને બહાર વાય છાપો, અને ખરેખર, વાય કેટલાક ઉન્મત્ત કિંમત તેમજ છે,

619
00:33:21,000 --> 00:33:24,000
પરંતુ કોઇ મોટો સોદો છે કારણ કે 19 વાક્ય આપણે શું સોંપવા માટે કરશો

620
00:33:24,000 --> 00:33:27,000
આ કિંમત 2, તેથી દો મને "આગામી" ફરીથી લખો.

621
00:33:27,000 --> 00:33:29,000
અને હવે અમે printf વાક્ય પર છો.

622
00:33:29,000 --> 00:33:31,000
મને પ્રિન્ટ એક્સ નથી.

623
00:33:31,000 --> 00:33:34,000
મને પ્રિન્ટ વાય નથી. પ્રમાણિકપણે, હું થોડો આ પ્રિન્ટિંગ થાકેલું મેળવવામાં છું.

624
00:33:34,000 --> 00:33:38,000
મને ને બદલે "ડિસ્પ્લે એક્સ" અને "ડિસ્પ્લે વાય," લખો

625
00:33:38,000 --> 00:33:41,000
અને હવે દર વખતે હું ભવિષ્યમાં આદેશ લખો

626
00:33:41,000 --> 00:33:45,000
હું શું ની યાદ આવશે એક્સ અને વાય શું એક્સ અને વાય એક્સ અને વાય શું છે.

627
00:33:45,000 --> 00:33:48,000
>> હું પણ, એક અલગ પ્રકાર, જેમ કે "માહિતી સ્થાનિકો." કરી શકો છો

628
00:33:48,000 --> 00:33:50,000
ઈન્ફો ખાસ આદેશ છે.

629
00:33:50,000 --> 00:33:52,000
સ્થાનિક અર્થ એ થાય કે તે મને સ્થાનિક ચલો બતાવે છે.

630
00:33:52,000 --> 00:33:55,000
જસ્ટ કિસ્સામાં હું ભૂલી ગયા હો અથવા આ ઉન્મત્ત, જટિલ કાર્ય છે

631
00:33:55,000 --> 00:33:57,000
કે હું અથવા કોઈએ લખ્યું માહિતી સ્થાનિકો તમે કહેશે

632
00:33:57,000 --> 00:34:00,000
આ સ્થાનિક કાર્ય અંદર તમામ સ્થાનિક ચલો શું છે

633
00:34:00,000 --> 00:34:03,000
કે તમે જો તમે આસપાસ થેલી, કોથળી માંગો છો વિશે કાળજી શકે છે.

634
00:34:03,000 --> 00:34:07,000
હવે, printf એક્ઝેક્યુટ કરવા માટે છે, તેથી દો મને આગળ અને માત્ર પ્રકાર જાઓ "આગામી".

635
00:34:07,000 --> 00:34:10,000
કારણ કે અમે આ પર્યાવરણમાં છો તો અમે ખરેખર તે નથી જોઈ રહ્યાં છો

636
00:34:10,000 --> 00:34:14,000
નીચે અહીં ચલાવો, પરંતુ નોટિસ તે થોડો mangled દર્શાશે અહીં.

637
00:34:14,000 --> 00:34:17,000
નોટિસ પરંતુ તે સ્ક્રીન ઓવરરાઈડીંગ છે ત્યાં,

638
00:34:17,000 --> 00:34:21,000
જેથી તે એક સંપૂર્ણ અહીં કાર્યક્રમ, નથી પરંતુ તે ઠીક છે કારણ કે હું હંમેશા આસપાસ થેલી, કોથળી કરી શકો છો

639
00:34:21,000 --> 00:34:23,000
પ્રિન્ટ મદદથી જો હું માંગો છો.

640
00:34:23,000 --> 00:34:26,000
>> મને આગામી ફરીથી લખો, અને હવે અહીં રસપ્રદ ભાગ છે.

641
00:34:26,000 --> 00:34:29,000
વાર્તામાં આ બિંદુએ વાય 2 છે, અને એક્સ 1,

642
00:34:29,000 --> 00:34:32,000
અહીં સૂચવ્યું હતું, અને ફરી,

643
00:34:32,000 --> 00:34:35,000
કારણ આ આપોઆપ હવે દર્શાવી છે કારણ કે હું આદેશ વાપરવામાં

644
00:34:35,000 --> 00:34:40,000
ડિસ્પ્લે એક્સ અને વાય પ્રદર્શન, તેથી ક્ષણ હું આગામી લખો

645
00:34:40,000 --> 00:34:43,000
સિદ્ધાંત એક્સ અને વાય માં સ્વૅપ બનવા જોઈએ.

646
00:34:43,000 --> 00:34:45,000
હવે, અમે પહેલાથી જ જાણો છો કે આ કેસ નથી ચાલી રહ્યું છે,

647
00:34:45,000 --> 00:34:49,000
પરંતુ અમે એક ક્ષણ જોઇ અમે કેવી રીતે ઊંડા ડાઇવ બહાર આકૃતિ શા માટે છે કે જે સાચું કરી શકો.

648
00:34:49,000 --> 00:34:54,000
આગળ, અને દુર્ભાગ્યે, વાય હજુ 2 અને એક્સ હજુ પણ 1, અને મને ખૂબ ખાતરી કરવા કરી શકો છો.

649
00:34:54,000 --> 00:34:56,000
પ્રિંટ એક્સ, વાય પ્રિન્ટ.

650
00:34:56,000 --> 00:34:59,000
ખરેખર, જેઓ કોઈ ખરેખર થયું છે, તેથી આપણે આ બોલ શરૂ કરો.

651
00:34:59,000 --> 00:35:01,000
સ્પષ્ટ રીતે સ્વેપ તૂટી જાય છે.

652
00:35:01,000 --> 00:35:04,000
ચાલો ને બદલે "રન" ફરીથી લખો.

653
00:35:04,000 --> 00:35:07,000
મને હા કહી, હું તેને શરૂઆતથી ફરી શરૂ કરવા માંગો દાખલ કરો.

654
00:35:07,000 --> 00:35:09,000
>> હવે હું પાછી 18 વાક્ય પર અપ છું.

655
00:35:09,000 --> 00:35:11,000
હવે નોટિસ એક્સ અને વાય કચરો કિંમતો ફરી છે.

656
00:35:11,000 --> 00:35:15,000
આગળ, આગામી, આગામી, આગામી.

657
00:35:15,000 --> 00:35:17,000
જો હું કંટાળી વિચાર હું પણ આગળના n ટાઈપ કરી શકો છો.

658
00:35:17,000 --> 00:35:21,000
તમે તેને અક્ષરોની ટૂંકી શક્ય ક્રમ માટે ટૂંકાવવું કરી શકો છો.

659
00:35:21,000 --> 00:35:23,000
સ્વેપ હવે તૂટી ગયો છે.

660
00:35:23,000 --> 00:35:25,000
માતાનો ડાઈવ માં, દો જેથી તેના બદલે આગામી લખીને છે,

661
00:35:25,000 --> 00:35:30,000
હવે હું પગલું લખો જાઉં છું કે જેથી હું અંદરથી આ કાર્યનો એક પગ છું

662
00:35:30,000 --> 00:35:33,000
જેથી હું તેને લઈ જવામાં કરી શકો છો, કે જેથી હું પગલું હિટ કરો અને પછી દાખલ કરો.

663
00:35:33,000 --> 00:35:37,000
નોંધ આ હાયલાઇટ જમ્પ મારા કાર્યક્રમ માં 36 વાક્ય નીચા છે.

664
00:35:37,000 --> 00:35:39,000
હવે સ્થાનિક ચલો શું છે?

665
00:35:39,000 --> 00:35:41,000
ઈન્ફો સ્થાનિકો.

666
00:35:41,000 --> 00:35:43,000
હજી સુધી કંઈ કારણ કે અમે તે લીટી નથી મેળવેલ કરી લીધી છે,

667
00:35:43,000 --> 00:35:47,000
તેથી આપણે આગળ વધીશું અને કહે છે "આગામી".

668
00:35:47,000 --> 00:35:50,000
હવે અમે tmp, પ્રિન્ટ tmp હોય એવું લાગે છે.

669
00:35:50,000 --> 00:35:52,000
કચરો કિંમત, અધિકાર? મને એવું લાગે છે.

670
00:35:52,000 --> 00:35:55,000
કેવી રીતે તે અંગે, પ્રિન્ટ બો 1 અને 2 છાપી?

671
00:35:55,000 --> 00:35:58,000
એક ક્ષણ માં, જલદી હું આગામી ફરી લખો

672
00:35:58,000 --> 00:36:02,000
tmp માટે 1 ની કિંમત પર લઇ, આસ્થાપૂર્વક રહ્યું છે,

673
00:36:02,000 --> 00:36:05,000
કારણ કે tmp માટે ની કિંમત સોંપાયેલ રહ્યું છે.

674
00:36:05,000 --> 00:36:08,000
>> હવે આપણે એક, પ્રિન્ટ બો છાપી નથી,

675
00:36:08,000 --> 00:36:11,000
પરંતુ હવે tmp છાપો, અને તે ખરેખર છે 1.

676
00:36:11,000 --> 00:36:14,000
મને આગામી નથી. મને આગામી નથી.

677
00:36:14,000 --> 00:36:16,000
હું સ્વેપ કાર્ય પૂર્ણ કરી લો છો.

678
00:36:16,000 --> 00:36:19,000
હું હજુ પણ અંદર 40 લીટી માં તે છું, જેથી દો મને એક છાપો,

679
00:36:19,000 --> 00:36:22,000
પ્રિન્ટ બો, હું અને પડી નથી tmp શું છે.

680
00:36:22,000 --> 00:36:27,000
એવું લાગે છે કે સ્વેપ યોગ્ય છે જ્યારે તે બોલ્ડ અને જેઓ માટે આવે છે.

681
00:36:27,000 --> 00:36:31,000
પરંતુ જો હું હવે આગામી લખો, હું 25 લીટી પર પાછા આવો,

682
00:36:31,000 --> 00:36:34,000
અને અલબત્ત, હું એક્સ અને વાય પ્રિન્ટ પ્રકાર જો

683
00:36:34,000 --> 00:36:38,000
તેઓ હજી પણ યથાવત છે, તેથી અમે સમસ્યા નિશ્ચિત નથી છે.

684
00:36:38,000 --> 00:36:41,000
પરંતુ diagnostically હવે કદાચ આ GDB કાર્યક્રમ સાથે

685
00:36:41,000 --> 00:36:44,000
અમે ઓછામાં ઓછા એક પગલું સમજ નજીક મેળવેલ કર્યા છે

686
00:36:44,000 --> 00:36:47,000
શું કચરા માટે printf અહીં મૂકીને અમારી કોડ વગર ખોટું ચાલી રહ્યું છે,

687
00:36:47,000 --> 00:36:50,000
printf અહીં, printf અહીં અને પછી તેને ફરીથી અને ફરીથી ચાલી

688
00:36:50,000 --> 00:36:52,000
બહાર આકૃતિ શું ખોટું થઈ રહ્યું છે તે પ્રયાસ કરે છે.

689
00:36:52,000 --> 00:36:55,000
>> હું આગળ વધો અને આ બહાર નીકળી જાઓ બહાર નીકળવા સાથે સંપૂર્ણપણે જાઉં છું.

690
00:36:55,000 --> 00:36:57,000
, "કોઈપણ રીતે છોડો?" તે પછી કહેવું રહ્યું છે હા.

691
00:36:57,000 --> 00:37:00,000
હવે હું મારા સામાન્ય પ્રોમ્પ્ટ પર પાછા છું, અને હું GDB ની મદદથી કરી રહ્યો છું.

692
00:37:00,000 --> 00:37:03,000
એક અલગ તરીકે, તમે આ તૂઇ ધ્વજ ઉપયોગ કરવાની જરૂર નથી.

693
00:37:03,000 --> 00:37:07,000
હકીકતમાં, જો તમે તેને ભૂલી જવું તમે અનિવાર્યપણે સ્ક્રીનના તળિયે અડધા મેળવો.

694
00:37:07,000 --> 00:37:11,000
જો હું તે પછી વિરામ મુખ્ય લખો અને પછી ચલાવો

695
00:37:11,000 --> 00:37:15,000
હું હજુ પણ મારા કાર્યક્રમ ચલાવવા શકો છો, પરંતુ તે શું કરશે શું વધુ ટેક્સ્ટ છે

696
00:37:15,000 --> 00:37:18,000
ફક્ત મને એક સમયે વર્તમાન લીટી એક બતાવે છે.

697
00:37:18,000 --> 00:37:21,000
ધ તૂઇ, શાબ્દિક વપરાશકર્તા ઇન્ટરફેસ,

698
00:37:21,000 --> 00:37:25,000
હમણાં જ તમને બતાવે છે એક વખત, કે જે કદાચ થોડી સરળ સરળ ખાતે કાર્યક્રમ વધુ.

699
00:37:25,000 --> 00:37:27,000
પરંતુ ખરેખર, હું હમણાં જ આગામી, આગામી, આગામી કરી શકો છો,

700
00:37:27,000 --> 00:37:30,000
અને હું એક સમયે એક લીટી જોવા જાઉં છું, અને જો હું ખરેખર શું થઈ રહ્યું છે તે કરવા માંગો છો

701
00:37:30,000 --> 00:37:35,000
હું યાદી લખો અને પડોશી રેખાઓ સંપૂર્ણ ટોળું જોઇ શકો છો.

702
00:37:35,000 --> 00:37:39,000
>> ત્યાં એક વિડિઓ કે અમે પૂછ્યું છે કે તમે જુઓ સમસ્યા 3 સુયોજિત કરે છે

703
00:37:39,000 --> 00:37:43,000
જેમાં Nate GDB જટિલતાઓ કેટલાક આવરી લે છે,

704
00:37:43,000 --> 00:37:46,000
અને આ એક એ વસ્તુઓ છે, પ્રામાણિકપણે, જ્યાં તમે અમુક ટકાવારી નગણ્ય

705
00:37:46,000 --> 00:37:49,000
સ્પર્શ, ક્યારેય GDB અને એક ખરાબ વસ્તુ હશે

706
00:37:49,000 --> 00:37:53,000
કારણ કે શાબ્દિક તમે અંત વધારે સમય આ સત્ર પછી વીતાવતા કરશે

707
00:37:53,000 --> 00:37:56,000
નીચે ભૂલો પીછો પછી તમે જો તમે કે અડધા કલાક / કલાક મૂકવા આવશે

708
00:37:56,000 --> 00:38:00,000
આ અઠવાડિયે અને આગામી શિક્ષણ GDB સાથે આરામદાયક વિચાર.

709
00:38:00,000 --> 00:38:02,000
Printf તમારા મિત્ર હતા.

710
00:38:02,000 --> 00:38:05,000
GDB હવે તમારા મિત્ર પ્રયત્ન કરીશું.

711
00:38:05,000 --> 00:38:08,000
>> GDB પર કોઈપણ પ્રશ્ન છે?

712
00:38:08,000 --> 00:38:12,000
અને અહીં સૌથી શક્તિશાળી અને ઉપયોગી આદેશો કેટલાક ઝડપી યાદી છે.

713
00:38:12,000 --> 00:38:15,000
યાહ. >> તમે શબ્દમાળા છાપી શકે છે?

714
00:38:15,000 --> 00:38:17,000
તમે શબ્દમાળા છાપી શકો છો? ચોક્કસ.

715
00:38:17,000 --> 00:38:19,000
તે માત્ર પૂર્ણાંકો નથી.

716
00:38:19,000 --> 00:38:22,000
જો ચલ ઓ પ્રિન્ટ s માં ફક્ત પ્રકાર શબ્દમાળા છે.

717
00:38:22,000 --> 00:38:24,000
તે તમને દર્શાવે છે કે શબ્દમાળા ચલ શું છે.

718
00:38:24,000 --> 00:38:26,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

719
00:38:26,000 --> 00:38:28,000
તે તમને સરનામા અને શબ્દમાળા પોતે આપશે.

720
00:38:28,000 --> 00:38:32,000
તે તમે બંને બતાવશે.

721
00:38:32,000 --> 00:38:34,000
અને એક છેલ્લા વસ્તુ, માત્ર કારણ કે આ પણ ખબર સારું છે.

722
00:38:34,000 --> 00:38:37,000
બેકસ્ટ્રેસ અને ફ્રેમ દો, મને આ એક છેલ્લો સમય માં ડાઇવ

723
00:38:37,000 --> 00:38:39,000
GDB સાથે જ ચોક્કસ કાર્યક્રમ.

724
00:38:39,000 --> 00:38:44,000
મને આગળ વધો અને શાબ્દિક વપરાશકર્તા ઈન્ટરફેસ આવૃત્તિ ચલાવવા માટે,

725
00:38:44,000 --> 00:38:46,000
મુખ્ય તૂટી જાય છે.

726
00:38:46,000 --> 00:38:49,000
મને આગળ વધો અને ફરી ચલાવો. અહીં હું છું.

727
00:38:49,000 --> 00:38:55,000
હવે મને આગામી, આગામી, આગામી, આગામી, આગામી જાઓ, પગલું દાખલ કરો.

728
00:38:55,000 --> 00:39:00,000
>> અને હવે કદાચ હું સ્વેપ હવે ઇરાદાપૂર્વક છું, પણ મને જેમ છું "ધુત્કારી કાઢવું, x ની કિંમત શું હતું?"

729
00:39:00,000 --> 00:39:02,000
હું એક્સ કંઈ પણ કરી શકે છે.

730
00:39:02,000 --> 00:39:05,000
હું વાય નથી કારણ કે તેઓ અવકાશ માં નથી કરી શકો છો.

731
00:39:05,000 --> 00:39:07,000
તેઓ સંદર્ભમાં, નથી પરંતુ કોઇ સમસ્યા નથી.

732
00:39:07,000 --> 00:39:09,000
હું બેકસ્ટ્રેસ ટાઈપ કરી શકો છો.

733
00:39:09,000 --> 00:39:13,000
કે મને વિધેયો કે જે સમયે આ બોલ પર ચલાવવામાં આવ્યા છે, તમામ બતાવે છે.

734
00:39:13,000 --> 00:39:16,000
નોંધ કરો કે મુખ્ય સાથે નીચે એક, મુખ્ય, અપ લાઇન

735
00:39:16,000 --> 00:39:18,000
અમારા ચિત્ર તળિયે અહીં છે.

736
00:39:18,000 --> 00:39:22,000
હકીકત એ છે કે તે સ્વેપ રેખાઓ ઉપર સ્વેપ મેમરી તે ઉપર અહીં હોવા સાથે છે,

737
00:39:22,000 --> 00:39:26,000
અને જો હું મુખ્ય પાછા કામચલાઉ મેળવવા માંગો છો હું "ફ્રેમ." કહી શકો છો

738
00:39:26,000 --> 00:39:30,000
નંબર શું છે? મુખ્ય # 1 ફ્રેમ હોય છે.

739
00:39:30,000 --> 00:39:32,000
હું આગળ વધો અને કહે જાઉં છું "1 ફ્રેમ."

740
00:39:32,000 --> 00:39:36,000
>> હવે હું મુખ્ય ફરી છું, અને હું એક્સ છાપી શકો છો, અને હું વાય છાપી શકો છો,

741
00:39:36,000 --> 00:39:40,000
પણ હું એક બો અથવા છાપી શકતા નથી.

742
00:39:40,000 --> 00:39:43,000
પરંતુ હું તો હું કહી શકો છો, "ઠીક છે, એક મિનિટ રાહ જુઓ સ્વેપ ક્યાં હતી.?"

743
00:39:43,000 --> 00:39:46,000
મને આગળ વધો અને કહે છે "ફ્રેમ 0."

744
00:39:46,000 --> 00:39:48,000
હવે હું પાછી છું જ્યાં હું પ્રયત્ન કરવા માંગો છો, અને પૃથક એક તરીકે,

745
00:39:48,000 --> 00:39:52,000
ત્યાં અન્ય આદેશો પણ છે, જો કે તમે ખરેખર કંટાળી ટાઈપ આગામી, આગામી, આગામી, આગામી મળી રહ્યા હોય,

746
00:39:52,000 --> 00:39:56,000
તમે સામાન્ય રીતે જેવી વસ્તુઓ કહી શકીએ "10 આગામી," અને તે આગામી 10 રેખાઓ દ્વારા કૂદી જશે.

747
00:39:56,000 --> 00:39:59,000
તમે પણ લખી "ચાલુ" જ્યારે તમે ખરેખર તેને મારફતે વેગ સાથે ખવડાવી શકો છો.

748
00:39:59,000 --> 00:40:05,000
ચાલુ રાખો વિક્ષેપ વગર તમારા કાર્યક્રમ ચલાવવા ત્યાં સુધી તેને બીજી બ્રેકપોઇન્ટ બનાવ્યા કરશે,

749
00:40:05,000 --> 00:40:07,000
લુપ માં કે તમારા કાર્યક્રમ નીચે ઘટે.

750
00:40:07,000 --> 00:40:11,000
>> આ કિસ્સામાં અમે અંત સુધી ચાલુ રાખ્યું, અને કાર્યક્રમ સામાન્ય રીતે બહાર.

751
00:40:11,000 --> 00:40:13,000
આ એક ફેન્સી માર્ગ, ઊતરતી પ્રક્રિયા છે.

752
00:40:13,000 --> 00:40:16,000
ફક્ત તમારી કાર્યક્રમ સામાન્ય રીતે બહાર.

753
00:40:16,000 --> 00:40:24,000
વિડિઓ અને સત્રો ડિબગીંગ આવવા કે પર વધુ.

754
00:40:24,000 --> 00:40:26,000
ઘણી હતી.

755
00:40:26,000 --> 00:40:35,000
ચાલો અમારી વિરામ 5-મિનિટ અહીં લે છે, અને અમે સ્ટ્ર્ક્ટ્સ અને ફાઈલો સાથે પરત મળશે.

756
00:40:35,000 --> 00:40:38,000
>> જો તમે આ સપ્તાહ pset માં પહેલેથી dived છે

757
00:40:38,000 --> 00:40:41,000
તમે જાણશો કે અમે વિતરણ કોડ ઉપયોગ,

758
00:40:41,000 --> 00:40:45,000
સ્ત્રોત કોડ કે અમે પ્રારંભ બિંદુ, અમુક નવી ટેકનિકો તરીકે તમને પૂરી પાડે છે.

759
00:40:45,000 --> 00:40:50,000
ખાસ કરીને, અમે માળખું આ નવું સ્ટ્રક્ટ કહેવાય કીવર્ડ, રજૂઆત કરી હતી,

760
00:40:50,000 --> 00:40:53,000
તેથી અમે પ્રકારની વૈવિધ્યપૂર્ણ ચલો બનાવી શકો છો.

761
00:40:53,000 --> 00:40:57,000
અમે પણ ફાઈલ ફાઈલ I / O, ઇનપુટ અને આઉટપુટ કલ્પના કરવામાં આવી હતી,

762
00:40:57,000 --> 00:41:00,000
અને આ છે જેથી અમે રાજ્ય સંગ્રહી શકો છો

763
00:41:00,000 --> 00:41:03,000
તમારા ભાંખોડિયાંભર થઈને બોર્ડ ઓફ ડિસ્ક પર ફાઈલ માટે

764
00:41:03,000 --> 00:41:06,000
જેથી શિક્ષણ ફેલો અને હું સમજી શકે

765
00:41:06,000 --> 00:41:09,000
શું તમારા કાર્યક્રમ ની અંદર પર જાતે રમવા કર્યા વગર ચાલી રહ્યું છે

766
00:41:09,000 --> 00:41:11,000
ભાંખોડિયાંભર થઈને ઓફ રમતો ડઝન.

767
00:41:11,000 --> 00:41:13,000
અમે આ વધુ automatedly કરી શકો છો.

768
00:41:13,000 --> 00:41:18,000
>> એક સ્ટ્રક્ટ આ વિચાર ખૂબ જ આકર્ષક સમસ્યા નિવારે છે.

769
00:41:18,000 --> 00:41:21,000
ધારો કે અમે કેટલાક કાર્યક્રમ અમલમાં માંગો છો

770
00:41:21,000 --> 00:41:25,000
કે કોઈક વિદ્યાર્થીઓ પર જાણકારી સાચવી રાખે છે,

771
00:41:25,000 --> 00:41:28,000
અને વિદ્યાર્થીઓ, હમણાં પૂરતું, એક પાસે ID છે, હોઈ શકે છે એક નામ

772
00:41:28,000 --> 00:41:31,000
અને હાર્વર્ડ જેવી સ્થળે એક ઘર છે, તેથી આ જાણકારી 3 ટુકડાઓ છે

773
00:41:31,000 --> 00:41:34,000
અમે આસપાસ રાખવા માંગો છો, તેથી દો મને આગળ વધો અને થોડો કાર્યક્રમ અહીં લખી શરૂ કરવા માટે,

774
00:41:34,000 --> 00:41:38,000
stdio.h સમાવેશ થાય છે.

775
00:41:38,000 --> 00:41:42,000
મને cs50.h. સમાવેશ કરવા

776
00:41:42,000 --> 00:41:44,000
અને પછી મારી મુખ્ય કાર્ય શરૂ કરો.

777
00:41:44,000 --> 00:41:46,000
હું કોઇ પણ આદેશ વાક્ય દલીલો સાથે ગૂંચવવું કરશે,

778
00:41:46,000 --> 00:41:49,000
અને અહીં હું એક વિદ્યાર્થી માંગો છો, તેથી હું કહેવા જાઉં છું

779
00:41:49,000 --> 00:41:54,000
એક વિદ્યાર્થી એક નામ ધરાવે છે, તેથી હું કહેવા જાઉં છું "શબ્દમાળા નામ."

780
00:41:54,000 --> 00:41:59,000
પછી હું કહેવા વિદ્યાર્થી પણ એક ID છે, તેથી પૂર્ણાંક આઈડી જાઉં છું,

781
00:41:59,000 --> 00:42:03,000
અને એક વિદ્યાર્થી એક મકાન ધરાવે છે, જેથી હું પણ કહેવું જાઉં છું "શબ્દમાળા મકાન છે."

782
00:42:03,000 --> 00:42:06,000
પછી હું આ થોડું આ જેવા વધુ સ્વચ્છ ઓર્ડર પડશે.

783
00:42:06,000 --> 00:42:11,000
ઠીક છે, હવે હું 3 જેની સાથે એક વિદ્યાર્થી પ્રતિનિધિત્વ માટે ચલો હોય છે, તેથી "એક વિદ્યાર્થી."

784
00:42:11,000 --> 00:42:15,000
>> અને હવે હું આ કિંમતો રચના કરવા માંગો છો, તેથી દો મને આગળ વધો અને કંઈક કહેવું

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
નામ ડેવિડ વિચાર રહ્યું છે.

787
00:42:21,000 --> 00:42:24,000
હવે કહો કે ઘર માટે માથેર વિચાર રહ્યું છે,

788
00:42:24,000 --> 00:42:31,000
અને પછી હું printf જેમ આપખુદ કંઈક કરવા જાઉં છું ("% s,

789
00:42:31,000 --> 00:42:37,000
ID ને કે જેના% d છે,% s માં રહે છે.

790
00:42:37,000 --> 00:42:41,000
અને હવે, હું શું અહીં પ્લગ કરવા માંગો છો, એક અન્ય બાદ?

791
00:42:41,000 --> 00:42:47,000
નામ, id ઘર; વળતર 0.

792
00:42:47,000 --> 00:42:50,000
ઠીક છે, જ્યાં સુધી હું ક્યાંક અહીં ખરાબ

793
00:42:50,000 --> 00:42:54,000
મને લાગે છે કે અમે ખૂબ સારી કાર્યક્રમ છે કે જે એક વિદ્યાર્થી સંગ્રહ કરે છે.

794
00:42:54,000 --> 00:42:57,000
અલબત્ત, આ છે કે જે બધી રસપ્રદ નથી. તો શું હું 2 વિદ્યાર્થીઓ માંગો છો?

795
00:42:57,000 --> 00:42:59,000
કે કોઇ મોટો સોદો છે. હું 2 લોકો આધાર આપી શકે છે.

796
00:42:59,000 --> 00:43:03,000
મને આગળ વધો અને આ પ્રકાશિત કરો અને નીચે અહીં જાઓ,

797
00:43:03,000 --> 00:43:09,000
અને હું "id 456 =" રોબ જેવી કોઇ વ્યક્તિએ કિર્કલૅંડ રહે માટે કહી શકો છો.

798
00:43:09,000 --> 00:43:12,000
>> ઠીક છે, રાહ જુઓ, પણ હું એ જ વસ્તુ આ કૉલ કરી શકતા નથી,

799
00:43:12,000 --> 00:43:15,000
અને લાગે છે કે હું આ નકલ હોય જાઉં છું,

800
00:43:15,000 --> 00:43:19,000
જેથી દો મને કહે છે કે આ હિસ્સો ડેવિડ ચલો હશે,

801
00:43:19,000 --> 00:43:23,000
દો અને મને રોબ માટે આ અમુક નકલો મેળવી.

802
00:43:23,000 --> 00:43:27,000
અમે આ રોબ કૉલ પરંતુ આ કામ હવે નથી રહ્યું છે પડશે

803
00:43:27,000 --> 00:43:33,000
કારણ કે હું રાહ છે, ચાલો મને id1 બદલવા માટે, NAME1 અને house1.

804
00:43:33,000 --> 00:43:35,000
રોબ 2 હોવું, 2 આવશે.

805
00:43:35,000 --> 00:43:42,000
હું આ અહીં, અહીં, અહીં, અહીં, અહીં અહીં બદલી મેળવ્યા છે.

806
00:43:42,000 --> 00:43:45,000
રાહ જુઓ, શું ટોમી વિશે શું? માતાનો આ ફરીથી દો.

807
00:43:45,000 --> 00:43:49,000
દેખીતી રીતે જો તમે હજુ પણ લાગે છે કે આ આવું કરવાનો આ સારો માર્ગ છે તેને નથી,

808
00:43:49,000 --> 00:43:52,000
જેથી નકલ / ખરાબ પેસ્ટ કરો.

809
00:43:52,000 --> 00:43:55,000
પરંતુ અમે આ સપ્તાહ પહેલા ઉકેલી.

810
00:43:55,000 --> 00:43:59,000
>> અમારા ઉકેલ શું હતું જ્યારે અમે જ માહિતી પ્રકાર અનેક ઉદાહરણો માગતો?

811
00:43:59,000 --> 00:44:01,000
[વિદ્યાર્થીઓ] હારમાળા.

812
00:44:01,000 --> 00:44:03,000
ઝાકઝમાળ, તેથી દો મને આ સાફ કરવાનો પ્રયાસ કરો.

813
00:44:03,000 --> 00:44:07,000
મને ટોચ પર જાતે માટે અમુક જગ્યા બનાવે છે, અને દો મને બદલે આ અહીં કરો.

814
00:44:07,000 --> 00:44:12,000
અમે આ લોકો કહે છે, અને પડશે બદલે હું કહેવા જાઉં છું "પૂર્ણાંક ids"

815
00:44:12,000 --> 00:44:14,000
અને હું હવે માટે 3 ના આધાર જાઉં છું.

816
00:44:14,000 --> 00:44:18,000
હું "શબ્દમાળા નામો," કહેવું અને હું 3 ના આધાર પડશે જાઉં છું,

817
00:44:18,000 --> 00:44:22,000
અને પછી હું "શબ્દમાળા ગૃહો," કહેવું અને હું 3 ના આધાર જાઉં છું જાઉં છું.

818
00:44:22,000 --> 00:44:26,000
હવે ડેવિડ પોતાના સ્થાનિક ચલો મેળવવાની બદલે અહીં

819
00:44:26,000 --> 00:44:28,000
અમે તે છૂટકારો મેળવી શકે છે.

820
00:44:28,000 --> 00:44:30,000
કે સારા કે જે આપણે આ સફાઈ હોવ લાગે છે.

821
00:44:30,000 --> 00:44:35,000
હું પછી કહેવું ડેવિડ નામો અને [0] [0] પ્રયત્ન રહ્યું છે કરી શકો છો

822
00:44:35,000 --> 00:44:38,000
અને ઘરો. [0]

823
00:44:38,000 --> 00:44:41,000
અને પછી રોબ અમે જ રીતે આ બચાવી શકો છો.

824
00:44:41,000 --> 00:44:46,000
ચાલો આ નીચે અહીં મૂકો, જેથી તેઓ આપખુદ [1] જાહેરાતો જ હશે.

825
00:44:46,000 --> 00:44:50,000
તેમણે નામો જ હશે [1],

826
00:44:50,000 --> 00:44:53,000
અને પછી છેલ્લે, ઘરો. [1]

827
00:44:53,000 --> 00:44:57,000
>> હજુ થોડું જટિલ, અને હવે હું આ બહાર આકૃતિ હોય છે,

828
00:44:57,000 --> 00:45:03,000
તેથી આપણે કહેવું "નામો [0], id [0], ઘરો [0]

829
00:45:03,000 --> 00:45:06,000
દો અને આ pluralize.

830
00:45:06,000 --> 00:45:09,000
Ids, જાહેરાતો, જાહેરાતો.

831
00:45:09,000 --> 00:45:12,000
અને ફરી, હું તે કરી રહ્યો છું, તેથી ફરી, હું પહેલેથી / નકલ ફરીથી પેસ્ટ આશ્રય છું,

832
00:45:12,000 --> 00:45:14,000
તેથી મતભેદ છે ત્યાં બીજી ઉકેલ અહીં છે.

833
00:45:14,000 --> 00:45:18,000
હું કદાચ આ અથવા તે જેમ લૂપ કંઈક કરી શકો છો સાફ વધુ અપ

834
00:45:18,000 --> 00:45:21,000
જેથી ટૂંકા, તે થોડું સારું છે પરંતુ હજુ પણ જેવી લાગે છે

835
00:45:21,000 --> 00:45:24,000
હું / નકલ કરીને પેસ્ટ કરો આશ્રય છું, પણ આ, હું દાવો,

836
00:45:24,000 --> 00:45:27,000
ખરેખર મૂળભૂત અધિકાર ઉકેલ નથી કારણ કે

837
00:45:27,000 --> 00:45:29,000
જો કયારેક અમે નક્કી તમે શું જાણો છો?

838
00:45:29,000 --> 00:45:32,000
અમે ખરેખર ડેવિડ અને રોબ માટે ગયેલ હોવા જોઈએ ઇમેઇલ સરનામાંઓ સ્ટોર

839
00:45:32,000 --> 00:45:34,000
અને આ કાર્યક્રમ માં બીજું દરેકને.

840
00:45:34,000 --> 00:45:36,000
અમે પણ ફોન નંબરો સ્ટોર કરીશું.

841
00:45:36,000 --> 00:45:39,000
અમે પણ કટોકટી સંપર્ક નંબરો સ્ટોર કરીશું.

842
00:45:39,000 --> 00:45:41,000
અમે માહિતી આ બધા ટુકડાઓ કે અમે સંગ્રહવા માંગો તો,

843
00:45:41,000 --> 00:45:43,000
તેથી તમે જે અંગે કેવી રીતે જવું છે?

844
00:45:43,000 --> 00:45:46,000
>> તમે ટોચ પર અન્ય એરે જાહેર કરો, અને પછી તમે જાતે ઉમેરવા

845
00:45:46,000 --> 00:45:49,000
ઇમેઇલ સરનામું [0] ઇમેઇલ [1] સરનામા

846
00:45:49,000 --> 00:45:51,000
ડેવિડ અને રોબ અને તેથી આગળ.

847
00:45:51,000 --> 00:45:56,000
પરંતુ ખરેખર એક માત્ર આ ડિઝાઇનમાં રહેલી ધારણા છે

848
00:45:56,000 --> 00:45:59,000
કે હું સન્માન સિસ્ટમ વાપરી છું કે ખબર

849
00:45:59,000 --> 00:46:03,000
[I] કેટલાક એરે દરેક

850
00:46:03,000 --> 00:46:06,000
ફક્ત તેથી જ વ્યક્તિ નો સંદર્ભ લો થાય છે,

851
00:46:06,000 --> 00:46:10,000
તેથી [0] જાહેરાતો માં 123 સંખ્યા છે,

852
00:46:10,000 --> 00:46:13,000
અને હું નામો ધારણ જાઉં છું [0]

853
00:46:13,000 --> 00:46:16,000
એ જ વ્યક્તિ નામ અને [0] ગૃહો

854
00:46:16,000 --> 00:46:21,000
એ જ વ્યક્તિ અને વિવિધ એરે કે હું બનાવવા તમામ ઘર તેથી આગળ છે.

855
00:46:21,000 --> 00:46:24,000
નોટિસ પરંતુ ત્યાં કોઈ મૂળભૂત જોડાણ છે

856
00:46:24,000 --> 00:46:27,000
માહિતી, id નામ, અને ઘરની તે 3 ટુકડાઓ વચ્ચે,

857
00:46:27,000 --> 00:46:32,000
તેમ છતાં એન્ટિટી અમે આ કાર્યક્રમ માં મોડેલ પ્રયાસ કરી રહ્યા છો એરે નથી.

858
00:46:32,000 --> 00:46:35,000
એરે ફક્ત આ કરવાથી આ કાર્યક્રમ વિષયક રીત છે.

859
00:46:35,000 --> 00:46:38,000
શું ખરેખર આપણે આપણા કાર્યક્રમમાં મોડલ માંગો છો વ્યક્તિ છે

860
00:46:38,000 --> 00:46:41,000
ડેવિડ, જે અંદર રોબ જેવી વ્યક્તિ જેવી

861
00:46:41,000 --> 00:46:46,000
અથવા પ્રાવૃત એક નામ અને ID અને એક ઘર છે.

862
00:46:46,000 --> 00:46:49,000
>> અમે કોઈક ઇનકેપ્સ્યુલેશન આ વિચાર વ્યક્ત કરી શકો છો

863
00:46:49,000 --> 00:46:52,000
જેમાં એક વ્યક્તિ એક ID, એક નામ અને એક ઘર હોય છે

864
00:46:52,000 --> 00:46:55,000
ખરેખર આ ચૂંથવું આશરો નથી અને માત્ર અમે જેમાં

865
00:46:55,000 --> 00:46:58,000
કે કૌંસ કંઈક વિશ્વાસ

866
00:46:58,000 --> 00:47:02,000
આ વિષમ એરે દરેક એ જ માનવ એન્ટિટી સંદર્ભ લે છે?

867
00:47:02,000 --> 00:47:04,000
અમે ખરેખર આ કરી શકો છો.

868
00:47:04,000 --> 00:47:08,000
મને ઉપર હવે મુખ્ય જાઓ, અને દો મને મારી પોતાની માહિતી પ્રકાર બનાવો

869
00:47:08,000 --> 00:47:10,000
ખરેખર પ્રથમ વખત.

870
00:47:10,000 --> 00:47:14,000
અમે ચઢાઇને માં આ પદ્ધતિનો ઉપયોગ,

871
00:47:14,000 --> 00:47:17,000
પરંતુ અહીં હું આગળ જાઓ અને માહિતી પ્રકાર બનાવો જાઉં છું,

872
00:47:17,000 --> 00:47:19,000
અને તમે જાણો છો શું, હું તે વિદ્યાર્થી અથવા વ્યક્તિ કૉલ જાઉં છું,

873
00:47:19,000 --> 00:47:23,000
અને હું typedef ઉપયોગ માટે એક પ્રકાર વ્યાખ્યાયિત જાઉં છું.

874
00:47:23,000 --> 00:47:25,000
હું કહે છે કે આ માળખું છે જાઉં છું,

875
00:47:25,000 --> 00:47:29,000
અને પછી આ માળખું પ્રકાર વિદ્યાર્થી હોઈ શકે છે, અમે કહીએ છીએ પડશે રહ્યું છે,

876
00:47:29,000 --> 00:47:31,000
છતાં પણ તે મારા માટે હવે ક્ર થોડું છે.

877
00:47:31,000 --> 00:47:33,000
અમે "પૂર્ણાંક id." કહેવું પડશે

878
00:47:33,000 --> 00:47:35,000
અમે "શબ્દમાળા નામ." કહેવું પડશે

879
00:47:35,000 --> 00:47:37,000
તો પછી અમે "શબ્દમાળા ઘર," કહેવું પડશે

880
00:47:37,000 --> 00:47:40,000
હવે જેથી કોડ આ થોડા લીટીઓ ના અંત સુધીમાં

881
00:47:40,000 --> 00:47:45,000
મેં હમણાં જ રણકાર શીખવ્યું કે અસ્તિત્વમાં

882
00:47:45,000 --> 00:47:49,000
ints ઉપરાંત એક માહિતી પ્રકાર, શબ્દમાળાઓ ઉપરાંત, ઉપરાંત ફ્લોટ્સ ઉપરાંત ડબલ્સ.

883
00:47:49,000 --> 00:47:54,000
>> સમય 11 લીટી માં આ ક્ષણ મુજબ, હવે એક નવી માહિતી વિદ્યાર્થીઓ કહેવાય પ્રકાર છે,

884
00:47:54,000 --> 00:47:58,000
અને હવે હું એક વિદ્યાર્થી ચલ હું માંગો છો ગમે ત્યાં જાહેર કરી શકે છે,

885
00:47:58,000 --> 00:48:01,000
જેથી દો મને સરકાવો લોકો અહીં.

886
00:48:01,000 --> 00:48:05,000
હવે હું આ છૂટકારો મેળવવા શકો છો, અને હું પાછળ જવા માટે નીચે ડેવિડ કરી શકો છો અહીં,

887
00:48:05,000 --> 00:48:10,000
અને ડેવિડ માટે હું ખરેખર ડેવિડ એમ કહે કરી શકો છો,

888
00:48:10,000 --> 00:48:13,000
અમે શાબ્દિક જાતે પછી ચલ નામ કરી શકો છો,

889
00:48:13,000 --> 00:48:16,000
છે પ્રકાર વિદ્યાર્થી હશે.

890
00:48:16,000 --> 00:48:18,000
આ થોડો વિચિત્ર લાગે છે, પરંતુ આ છે કે જે બધી અલગ નથી

891
00:48:18,000 --> 00:48:22,000
પૂર્ણાંક અથવા સ્ટ્રિંગ અથવા ફ્લોટ તરીકે કંઈક જાહેર છે.

892
00:48:22,000 --> 00:48:24,000
તે માત્ર જેથી વિદ્યાર્થી કહેવાય હવે થાય છે,

893
00:48:24,000 --> 00:48:28,000
અને જો હું આ માળખાની અંદર કંઈક મૂકેલ

894
00:48:28,000 --> 00:48:31,000
હું હવે વાક્યરચના એક નવી ટુકડો ઉપયોગ કરે છે, પરંતુ તે યોગ્ય સરળ છે,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = મૂડી ડી માં "ડેવિડ",

896
00:48:39,000 --> 00:48:42,000
અને david.house = "માથેર,"

897
00:48:42,000 --> 00:48:46,000
અને હવે હું આ સામગ્રી છૂટકારો અહીં મેળવી શકો છો.

898
00:48:46,000 --> 00:48:51,000
નોટીસને આપણે હવે ખરેખર એક વધુ સારું રીતે કર્યું છે અમારા કાર્યક્રમ ફરીથી ડિઝાઇન

899
00:48:51,000 --> 00:48:54,000
કે હવે અમારા કાર્યક્રમ વાસ્તવિક વિશ્વમાં પ્રતિબિંબ.

900
00:48:54,000 --> 00:48:57,000
>> ત્યાં એક વ્યક્તિ અથવા એક વિદ્યાર્થી એક ખ્યાલ વાસ્તવિક દુનિયાની છે.

901
00:48:57,000 --> 00:49:02,000
અહીં અમે હવે એક વ્યક્તિ અથવા વધુ સ્પષ્ટતાપૂર્વક એક વિદ્યાર્થી એક સી આવૃત્તિ હોય.

902
00:49:02,000 --> 00:49:05,000
તે વ્યક્તિ ની અંદર આ સંબંધિત લાક્ષણિકતાઓ હોય છે,

903
00:49:05,000 --> 00:49:10,000
ID ને નામ, અને ઘર છે, તેથી રોબ આવશ્યક સમાન વસ્તુ નીચે અહીં બને છે,

904
00:49:10,000 --> 00:49:14,000
વિદ્યાર્થી લૂંટવું, અને તેથી હવે 456 = rob.id,

905
00:49:14,000 --> 00:49:17,000
rob.name = "રોબ."

906
00:49:17,000 --> 00:49:20,000
હકીકત એ છે કે ચલ રોબ કહે છે અર્થહીન જેવું છે.

907
00:49:20,000 --> 00:49:22,000
અમે તેના એક્સ અથવા વાય અથવા z કહે છે શકે છે.

908
00:49:22,000 --> 00:49:25,000
અમે હમણાં જ તે અર્થનિર્ધારણ સુસંગત હોવું રોબ નામ આપવામાં આવ્યું,

909
00:49:25,000 --> 00:49:28,000
પરંતુ ખરેખર તે નામ છે કે જે ક્ષેત્ર જાતે અંદર છે,

910
00:49:28,000 --> 00:49:30,000
તેથી હવે હું આ છે.

911
00:49:30,000 --> 00:49:33,000
આ ખૂબ શ્રેષ્ઠ ડિઝાઈન કે હું હાર્ડ ડેવિડ કોડેડ કર્યા છે, જેમ કે ન જણાય નથી.

912
00:49:33,000 --> 00:49:35,000
હું હાર્ડ રોબ કોડેડ થઈ છે.

913
00:49:35,000 --> 00:49:39,000
અને હું હજુ પણ કેટલાક નકલ આશરો અને દર વખતે હું નવા ચલો માંગો છો પેસ્ટ હોય છે.

914
00:49:39,000 --> 00:49:43,000
વધુમાં, હું દેખીતી રીતે આ ચલો દરેક એક નામ આપો હોય છે,

915
00:49:43,000 --> 00:49:46,000
છતાં પણ હું ખૂબ બદલે આ ચલો વર્ણવવા છો

916
00:49:46,000 --> 00:49:48,000
 વધુ સામાન્ય વિદ્યાર્થીઓ.

917
00:49:48,000 --> 00:49:52,000
>> હવે અમે વિચારો કે આપણા માટે કરવામાં આવી છે તેમજ કામ મર્જ કરી શકો છો

918
00:49:52,000 --> 00:49:56,000
અને તેની જગ્યાએ કહે છે, "તમે જાણવા, મને ચલ કહેવાતા વિદ્યાર્થીઓ આપવા માટે,

919
00:49:56,000 --> 00:50:01,000
દો અને તેથી તે 3 કદ હોવા છે "હવે હું આ વધુ રિફાઇન કરી શકો છો,

920
00:50:01,000 --> 00:50:04,000
જાતે જાહેર ડેવિડ છૂટકારો મેળવવા માટે,

921
00:50:04,000 --> 00:50:08,000
અને હું તેના બદલે વિદ્યાર્થીઓને જેવા [0] અહીં કંઈક કહી શકો છો.

922
00:50:08,000 --> 00:50:11,000
હું પછી વિદ્યાર્થીઓ [0] અહીં કહી શકીએ,

923
00:50:11,000 --> 00:50:14,000
અહીં, અને તેથી આગળ [0] વિદ્યાર્થીઓ, હું અને આસપાસ જઈ શકે છે

924
00:50:14,000 --> 00:50:16,000
અને તે રોબ માટે સાફ.

925
00:50:16,000 --> 00:50:19,000
હું પણ હવે કદાચ કોઇ લૂપ ઉમેરવા જઈ શકે છે

926
00:50:19,000 --> 00:50:23,000
અને GetString અને GetInt મદદથી ખરેખર વપરાશકર્તા પાસેથી આ કિંમતો મેળવો.

927
00:50:23,000 --> 00:50:27,000
હું સતત ઉમેરવા જઈ કારણ કે સામાન્ય રીતે આ પદ્ધતિ ખરાબ છે શકે છે

928
00:50:27,000 --> 00:50:29,000
હાર્ડ કોડ 3 જેવા કેટલાક મનસ્વી અહીં નંબર

929
00:50:29,000 --> 00:50:33,000
અને પછી ફક્ત યાદ રાખો કે તમે તેને કોઈ વધુ 3 કરતાં વિદ્યાર્થીઓ મૂકવા જોઇએ.

930
00:50:33,000 --> 00:50:36,000
તે કદાચ વધુ સારી રીતે થઈ # મારા ફાઈલ ટોચ પર વ્યાખ્યાયિત ઉપયોગ કરશે

931
00:50:36,000 --> 00:50:40,000
અને પરિબળ છે કે બહાર, તેથી ખરેખર દો, મને આગળ વધો અને આ સામાન્યીકરણ.

932
00:50:40,000 --> 00:50:43,000
>> દો મને એક ઉદાહરણ છે કે આજે એક છે ખોલવા

933
00:50:43,000 --> 00:50:46,000
અગાઉથી ઉદાહરણો માટે, structs1.

934
00:50:46,000 --> 00:50:49,000
આ એક વધુ સંપૂર્ણ કાર્યક્રમ છે કે જે વાપરે # અહીં વ્યાખ્યાયિત છે

935
00:50:49,000 --> 00:50:51,000
કહે છે અને અમે મૂળભૂત રીતે 3 વિદ્યાર્થીઓ પાસે જઈ રહ્યાં છો.

936
00:50:51,000 --> 00:50:54,000
અહીં હું વિદ્યાર્થીઓ એક વર્ગ વર્થ જાહેર છું,

937
00:50:54,000 --> 00:50:57,000
વિદ્યાર્થીઓ એક વર્ગખંડમાં, અને તેથી હવે હું એક લૂપ ઉપયોગ કરું છું

938
00:50:57,000 --> 00:51:00,000
ફક્ત કોડ થોડી વધુ ભવ્ય બનાવવા માટે, વર્ગ રચના

939
00:51:00,000 --> 00:51:05,000
વપરાશકર્તાની ઇનપુટ સાથે છે, તેથી હું = 0 થી વિદ્યાર્થીઓ, જે 3 છે અપ ફરી વળવું.

940
00:51:05,000 --> 00:51:07,000
અને પછી હું આ આવૃત્તિ માં વપરાશકર્તા પૂછવા

941
00:51:07,000 --> 00:51:10,000
 શું આ વિદ્યાર્થી ID ને, અને હું તેને GetInt સાથે મળે છે.

942
00:51:10,000 --> 00:51:13,000
શું આ વિદ્યાર્થી નામ છે, અને પછી હું તેને GetString સાથે મળે છે.

943
00:51:13,000 --> 00:51:15,000
જે વિદ્યાર્થી ઘર શું છે? હું તેને GetString સાથે મળે છે.

944
00:51:15,000 --> 00:51:19,000
અને પછી અહીં નીચે હું માત્ર ફેરફાર કરવાનો નિર્ણય લીધો

945
00:51:19,000 --> 00:51:22,000
કેવી રીતે હું આ છાપવા છું બહાર અને ખરેખર લૂપ ઉપયોગ

946
00:51:22,000 --> 00:51:24,000
અને હું જે છાપવા છું?

947
00:51:24,000 --> 00:51:27,000
આ ટિપ્પણી અનુસાર હું માથેર કોઈને છાપવા છું,

948
00:51:27,000 --> 00:51:30,000
અને તે છે રોબ અને ટોમી તેથી અને જેથી કરીને ખરેખર ટોમી માથેર માં.

949
00:51:30,000 --> 00:51:34,000
ટોમી અને ડેવિડ આ કેસ માં મુદ્રિત થઈ શકે છે, પરંતુ આ કેવી રીતે કામ કરે છે?

950
00:51:34,000 --> 00:51:40,000
અમે આ કાર્ય કરતાં પહેલાં જોઇ ન હોય, પરંતુ આ શું કરે છે માટે એક અનુમાન લો.

951
00:51:40,000 --> 00:51:42,000
શબ્દમાળાઓ સરખાવે છે.

952
00:51:42,000 --> 00:51:45,000
>> તે થોડો બિન સ્પષ્ટ તે કેવી રીતે શબ્દમાળાઓ સરખાવે છે કારણ કે તે તારણ

953
00:51:45,000 --> 00:51:49,000
જો તે આપે છે કે 0 અર્થ એ થાય કે શબ્દમાળાઓ સમાન છે.

954
00:51:49,000 --> 00:51:53,000
જો તે -1 આપે છે તેનો અર્થ એ કે એક અન્ય પહેલા મૂળાક્ષરોના ક્રમમાં આવે છે,

955
00:51:53,000 --> 00:51:57,000
અને જો તે +1 આપે છે કે જે અન્ય શબ્દ અર્થ છે મૂળાક્ષરોના ક્રમમાં આવે છે

956
00:51:57,000 --> 00:52:00,000
અન્ય પહેલા, અને તમે ઑનલાઇન અથવા મદદ પાનાં જોવા માટે કરી શકો છો

957
00:52:00,000 --> 00:52:04,000
જોવા માટે બરાબર રીતે જે છે, પરંતુ આ તમામ હવે કરવાનું છે તે કહેતા છે

958
00:52:04,000 --> 00:52:09,000
જો [i]. ઘર "માથેર" સમાન છે

959
00:52:09,000 --> 00:52:13,000
પછી આગળ વધો અને તેથી છાપી અને તેથી માથેર છે.

960
00:52:13,000 --> 00:52:16,000
પરંતુ અહીં કંઈક પહેલા જોઇ ન હોય, અને અમે પાછા આ આવવું પડશે.

961
00:52:16,000 --> 00:52:21,000
હું ક્યારેય મારા કાર્યક્રમો કોઈપણ આવું કર્યા નથી યાદ નથી.

962
00:52:21,000 --> 00:52:24,000
મફત દેખીતી રીતે મેમરી ઉલ્લેખ છે, મેમરી મુક્ત કરીને,

963
00:52:24,000 --> 00:52:31,000
પરંતુ મેમરી હું દેખીતી રીતે છું આ કાર્યક્રમ તળિયે આ લુપમાં મુક્ત કરીને?

964
00:52:31,000 --> 00:52:34,000
એવું લાગે છે કે હું એક વ્યક્તિ નામ ખાલી છું

965
00:52:34,000 --> 00:52:37,000
અને એક વ્યક્તિ ઘર, પરંતુ શા માટે છે કે જે છે?

966
00:52:37,000 --> 00:52:41,000
>> આ તમામ અઠવાડિયા તારણ આપે છે કે તમે GetString નો ઉપયોગ કરી

967
00:52:41,000 --> 00:52:45,000
અમે પ્રકારની દરેક તમારા કાર્યક્રમો એકમાં કરી રહ્યો એક ભૂલ પરિચય કરાવ્યો.

968
00:52:45,000 --> 00:52:51,000
ડિઝાઇન ફાળવે મેમરી દ્વારા GetString કે જેથી તે તમે શબ્દમાળા પાછા આવી શકો છો,

969
00:52:51,000 --> 00:52:55,000
જેમ ડેવિડ, અથવા, રોબ તમે અને પછી શું કરવું ગમે તમે શકો છો

970
00:52:55,000 --> 00:52:59,000
તમારા કાર્યક્રમ છે કે જેઓ શબ્દમાળા કારણ કે અમે તમારા માટે મેમરી અનામત કર્યું છે સાથે.

971
00:52:59,000 --> 00:53:02,000
આ સમસ્યા આ બધા સમય દરેક વખતે તમે GetString કહી છે

972
00:53:02,000 --> 00:53:05,000
અમે, GetString ના લેખકો, ઓપરેટિંગ સિસ્ટમ કરવામાં પુછે છે

973
00:53:05,000 --> 00:53:07,000
અમને આ શબ્દમાળા માટે RAM ની થોડી આપે છે.

974
00:53:07,000 --> 00:53:09,000
અમને આ આગામી શબ્દમાળા માટે RAM ની થોડી આપો.

975
00:53:09,000 --> 00:53:11,000
અમને આ આગામી શબ્દમાળા માટે કેટલાક વધુ RAM આપો.

976
00:53:11,000 --> 00:53:13,000
તમે, પ્રોગ્રામર કરવાનું, ક્યારેય છે શું

977
00:53:13,000 --> 00:53:15,000
છે અમને કે મેમરી પાછા આપ્યા,

978
00:53:15,000 --> 00:53:17,000
તેથી આ કેટલાંક અઠવાડિયા માટે બધા જ કાર્યક્રમો તમે તેવા પરચૂરણ ખર્ચ કર્યો છે

979
00:53:17,000 --> 00:53:20,000
કરી શું મેમરી લીપ કહેવામાં આવે છે જેમાં તેઓ ઉપયોગ ચાલુ રાખી

980
00:53:20,000 --> 00:53:24,000
વધુ અને વધુ મેમરી દર વખતે તમે GetString કહી છે, અને તે લલિત છે.

981
00:53:24,000 --> 00:53:27,000
અમે ઈરાદાપૂર્વક પ્રથમ સપ્તાહો કે નથી કારણ કે તે રસપ્રદ નથી

982
00:53:27,000 --> 00:53:29,000
માટે જ્યાં શબ્દમાળા આવે છે ચિંતા કરવાની જરૂર નથી.

983
00:53:29,000 --> 00:53:34,000
બધા તમે કરવા માંગો છો તે શબ્દ પર પાછા જાઓ જ્યારે વપરાશકર્તા તેને પ્રકારના સાઇન રોબ

984
00:53:34,000 --> 00:53:38,000
>> પરંતુ આગળ વધવા આપણે હવે વધુ આ વિશે વ્યવહારદક્ષ મેળવવાનું શરૂ હોય છે.

985
00:53:38,000 --> 00:53:42,000
કોઈપણ સમયે અમે મેમરીને ફાળવવા અમે વધુ સારી રીતે છેવટે તેને પાછા સોંપી.

986
00:53:42,000 --> 00:53:45,000
અન્યથા તમારા Mac અથવા પીસી પર વાસ્તવિક વિશ્વમાં તમે ક્યારેક ક્યારેક અનુભવી હોય શકે છે

987
00:53:45,000 --> 00:53:50,000
લક્ષણો છે કે જ્યાં તમારા કમ્પ્યુટર halt માટે ગ્રાઇન્ડીંગ છે છેવટે

988
00:53:50,000 --> 00:53:54,000
અથવા મૂર્ખ સ્પિનિંગ બીચ બોલ માત્ર કમ્પ્યુટર પર કબજો છે

989
00:53:54,000 --> 00:53:56,000
સમગ્ર ધ્યાન તમે અને વસ્તુઓ ન કરી શકો.

990
00:53:56,000 --> 00:54:00,000
કે ભૂલો કોઈપણ સંખ્યાની દ્વારા સમજાવી શકાય છે, પરંતુ તે શક્ય બગ્સ વચ્ચે

991
00:54:00,000 --> 00:54:03,000
છે વસ્તુઓ મેમરી લીક્સ કહેવાય જેમાં વ્યકિત સોફ્ટવેર કે ટુકડો લખ્યું હતું

992
00:54:03,000 --> 00:54:07,000
તમે મુક્ત મેમરી માટે યાદ ન ઉપયોગ કરી રહ્યાં છો

993
00:54:07,000 --> 00:54:10,000
કે તે અથવા તેણી ઓપરેટિંગ સિસ્ટમ માટે પૂછ્યું છે,

994
00:54:10,000 --> 00:54:14,000
મદદથી નથી, GetString કારણ કે તે એક CS50 વાત છે, પરંતુ સમાન વિધેયો મદદથી

995
00:54:14,000 --> 00:54:16,000
કે મેમરી માટે ઓપરેટિંગ સિસ્ટમ પૂછો.

996
00:54:16,000 --> 00:54:19,000
જો તમે તેઓ અથવા પેચ અને તે મેમરી ખરેખર ક્યારેય પાછા

997
00:54:19,000 --> 00:54:24,000
એક લક્ષણ છે કે હોઇ શકે છે કે જે કાર્યક્રમ ધીમો પડી જાય છે અને ધીમો પડે છે અને નીચે ધીમો પડી જાય છે

998
00:54:24,000 --> 00:54:26,000
જ્યાં સુધી તમે મફત કૉલ યાદ કરે છે.

999
00:54:26,000 --> 00:54:28,000
>> અમે પાછા આવવા જ્યારે શા માટે અને તમે મફત કૉલ કરશે પડશે,

1000
00:54:28,000 --> 00:54:32,000
દો પરંતુ સારા પગલા માટે જ આગળ વધો અને આ ચોક્કસ કાર્યક્રમ ચાલી પ્રયાસ કરો.

1001
00:54:32,000 --> 00:54:35,000
આ structs1 તરીકે ઓળખાતું હતું દાખલ કરો.

1002
00:54:35,000 --> 00:54:40,000
મને આગળ વધો અને structs1 રન, 123, ડેવિડ માથેર,

1003
00:54:40,000 --> 00:54:47,000
456, રોબ કિર્કલૅંડ, 789,

1004
00:54:47,000 --> 00:54:50,000
ટોમી માથેર, અને અમે માથેર માં ડેવિડ જુઓ, ટોમી માથેર માં.

1005
00:54:50,000 --> 00:54:53,000
આ થોડી સેનીટી ચેક કે કાર્યક્રમ કામ છે.

1006
00:54:53,000 --> 00:54:56,000
હવે, દુર્ભાગ્યે, આ કાર્યક્રમ થોડો કે નિરાશાજનક છે

1007
00:54:56,000 --> 00:55:00,000
હું કે બધા કામ કરી ન હતી, હું 9 વિવિધ શબ્દમાળાઓ માં લખ્યો દાખલ કરો, દબાવો,

1008
00:55:00,000 --> 00:55:04,000
તેને જણાવવામાં આવ્યું હતું જે માથેર હતો, હજુ સુધી ચોક્કસપણે હું જાણતો હતો જે માથેર પહેલેથી જ હતી કારણ કે હું તે લખ્યો.

1009
00:55:04,000 --> 00:55:07,000
તે ઓછામાં ઓછા સરસ પ્રયત્ન જો આ કાર્યક્રમ ડેટાબેઝ જેવા વધુ છે કરશે

1010
00:55:07,000 --> 00:55:10,000
અને તે ખરેખર યાદ હું શું લખેલ છે

1011
00:55:10,000 --> 00:55:12,000
તેથી હું આ વિદ્યાર્થી રેકોર્ડ ઇનપુટ માટે ફરી ક્યારેય હોય છે.

1012
00:55:12,000 --> 00:55:15,000
કદાચ તે registrarial સિસ્ટમ જેવું છે.

1013
00:55:15,000 --> 00:55:21,000
>> અમે આ કરવા માટે આ ફાઇલને ફાઈલ I / O, ઇનપુટ અને આઉટપુટ તરીકે ઓળખાય ટેકનીકની મદદથી કરી શકો છો,

1014
00:55:21,000 --> 00:55:24,000
કોઈપણ સમયે તમને ફાઈલો વાંચવા અથવા ફાઈલો લખવા માંગો છો કહેતા ખૂબ જ સામાન્ય રીત

1015
00:55:24,000 --> 00:55:26,000
તમે કાર્યો ચોક્કસ સમૂહ સાથે કરી શકો છો.

1016
00:55:26,000 --> 00:55:29,000
મને આગળ વધો અને આ ઉદાહરણ structs2.c ખોલો,

1017
00:55:29,000 --> 00:55:33,000
જે લગભગ સમાન હોય છે, પરંતુ આપણે જોઈ તે શું હવે કરે છે.

1018
00:55:33,000 --> 00:55:36,000
ફાઇલ ટોચ પર હું વિદ્યાર્થીઓ એક વર્ગ જાહેર.

1019
00:55:36,000 --> 00:55:38,000
હું પછી વપરાશકર્તા ઈનપુટ સાથે વર્ગ રચના કરો,

1020
00:55:38,000 --> 00:55:41,000
જેથી કોડ તે રેખાઓ બરાબર પહેલાં જેવી જ છે.

1021
00:55:41,000 --> 00:55:45,000
પછી જો હું નીચે સ્ક્રોલ અહીં હું છાપો દરેક વ્યક્તિ માથેર છે આપખુદ પહેલાં ગમે,

1022
00:55:45,000 --> 00:55:47,000
પરંતુ આ રસપ્રદ નવી લક્ષણ છે.

1023
00:55:47,000 --> 00:55:51,000
કોડ આ રેખાઓ નવા હોય, અને તેઓ કંઈક અહીં દાખલ,

1024
00:55:51,000 --> 00:55:55,000
FILE, બધા કેપ્સ, અને તે અહીં * તેમજ ધરાવે છે.

1025
00:55:55,000 --> 00:55:58,000
મને અહીં પર આ ખસેડવા માટે, અહીં ઉપર * છે.

1026
00:55:58,000 --> 00:56:00,000
>> આ કાર્ય અમે પહેલા જોઇ ન હોય, fopen,

1027
00:56:00,000 --> 00:56:03,000
પરંતુ તે ફાઇલ અર્થ છે ખુલ્લા છે, તેથી આ મારફતે ચાલો મલાઈહીન,

1028
00:56:03,000 --> 00:56:05,000
અને આ કંઈક અમે પાછા ભાવિ psets આવે પડશે છે,

1029
00:56:05,000 --> 00:56:10,000
પરંતુ આ વાક્ય અહીં અનિવાર્યપણે ડેટાબેઝ તરીકે ઓળખાતી ફાઈલ ખોલે છે,

1030
00:56:10,000 --> 00:56:13,000
અને તે ખાસ કરીને તે એવી રીતે કે તે શું કરી શકો છો ખુલે છે?

1031
00:56:13,000 --> 00:56:15,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

1032
00:56:15,000 --> 00:56:19,000
અધિકાર છે, તેથી ફક્ત "વાઇડ" નો અર્થ તે ઓપરેટિંગ સિસ્ટમ કહેવાની છે

1033
00:56:19,000 --> 00:56:21,000
એવી રીતે કે હું તેને લખી શકો છો આ ફાઈલ ખોલો.

1034
00:56:21,000 --> 00:56:23,000
હું તે વાંચી નથી માંગતા. હું હમણાં જ તે જોવા નથી માંગતા.

1035
00:56:23,000 --> 00:56:26,000
હું તેને બદલવા માટે અને સામગ્રી તે સંભવિત ઍડ કરવા માંગો છો,

1036
00:56:26,000 --> 00:56:28,000
અને ફાઈલ ડેટાબેઝ કહેવાય રહ્યું છે.

1037
00:56:28,000 --> 00:56:30,000
આ કંઈપણ કહી શકાય.

1038
00:56:30,000 --> 00:56:32,000
આ database.txt હોઈ શકે છે. આ db. હોઇ શકે છે.

1039
00:56:32,000 --> 00:56:37,000
આ foo જેવો શબ્દ હોય છે, પણ હું આપખુદ ફાઇલને ડેટાબેઝ નામ પસંદ કર્યું હતું.

1040
00:56:37,000 --> 00:56:42,000
આ થોડો સેનીટી ચેક કે અમે પાછળ સમય પર મહાન વિગતવાર આવે પડશે છે,

1041
00:56:42,000 --> 00:56:47,000
જો fp, ફાઈલ નિર્દેશક માટે સમાન NULL નથી તેનો અર્થ એ કે બધા સારી છે.

1042
00:56:47,000 --> 00:56:51,000
>> લાંબા વાર્તા ટૂંકી, fopen જેવા કાર્યો ક્યારેક નિષ્ફળ જાય છે.

1043
00:56:51,000 --> 00:56:53,000
કદાચ ફાઈલ અસ્તિત્વમાં નથી. કદાચ તમે ડિસ્ક જગ્યા નથી.

1044
00:56:53,000 --> 00:56:55,000
કદાચ તમે તે ફોલ્ડર માટે પરવાનગી નહિં હોય,

1045
00:56:55,000 --> 00:56:58,000
તેથી જો fopen નલ કંઈક આપે ખરાબ થયું.

1046
00:56:58,000 --> 00:57:02,000
તેનાથી વિપરીત, જો fopen નલ નહિં આપે તમામ સારી છે

1047
00:57:02,000 --> 00:57:04,000
અને હું આ ફાઇલ લખવા શરૂ કરી શકો છો.

1048
00:57:04,000 --> 00:57:06,000
અહીં એક નવી યુક્તિ છે.

1049
00:57:06,000 --> 00:57:08,000
આ માટે લૂપ કે ઉપર મારા વિદ્યાર્થીઓ દરેક વારો છે છે,

1050
00:57:08,000 --> 00:57:10,000
અને તેથી આપણે શું પહેલાં કર્યું છે જેવું જ દેખાય છે,

1051
00:57:10,000 --> 00:57:15,000
પરંતુ આ કાર્ય એક પિતરાઇ printf printf ફાઈલ માટે fprintf કહેવાય છે,

1052
00:57:15,000 --> 00:57:18,000
નોટિસ અને તે માત્ર 2 રીતે અલગ છે.

1053
00:57:18,000 --> 00:57:20,000
તે એક, પૃ બદલે એફ સાથે શરૂ થાય છે,

1054
00:57:20,000 --> 00:57:23,000
પરંતુ તે પછી તેના પ્રથમ દલીલ શું દેખીતી રીતે છે?

1055
00:57:23,000 --> 00:57:25,000
[વિદ્યાર્થીઓ] ફાઇલ. >> એ એક ફાઈલ છે.

1056
00:57:25,000 --> 00:57:30,000
આ fp કહેવાય વસ્તુ છે, કે જે અમે આખરે સિવાય પીંજવું ફાઈલ નિર્દેશક શું છે પડશે,

1057
00:57:30,000 --> 00:57:35,000
પરંતુ હવે માટે fp ફક્ત ફાઇલ કે હું ખોલી છે રજૂ કરે છે,

1058
00:57:35,000 --> 00:57:41,000
જેથી fprintf અહીં કહી રહ્યાં છે આ વપરાશકર્તા ફાઈલ ID ને છાપો, નહીં કે સ્ક્રીન છે.

1059
00:57:41,000 --> 00:57:44,000
આ વપરાશકર્તા ફાઈલ માટે નામ નથી, સ્ક્રીન પર છાપો,

1060
00:57:44,000 --> 00:57:47,000
ફાઇલ માટે છે, નહીં કે સ્ક્રીન પર, અને પછી અહીં નીચે, દેખીતી રીતે આ ઘર,

1061
00:57:47,000 --> 00:57:50,000
ફાઇલ બંધ કરો અને પછી નીચે મફત મેમરી અહીં.

1062
00:57:50,000 --> 00:57:53,000
>> આ સંસ્કરણ 2 અને 1 આવૃત્તિ વચ્ચે માત્ર એટલો જ તફાવત

1063
00:57:53,000 --> 00:57:58,000
fopen રજૂઆત અને * સાથે આ ફાઈલ છે

1064
00:57:58,000 --> 00:58:01,000
અને fprintf આ ખ્યાલ છે, તેથી આપણે જોઈ ઓવરને પરિણામ શું છે.

1065
00:58:01,000 --> 00:58:03,000
મને મારી ટર્મિનલ વિન્ડોમાં જાઓ.

1066
00:58:03,000 --> 00:58:06,000
મને structs2 ચલાવવા માટે, દાખલ કરો.

1067
00:58:06,000 --> 00:58:09,000
એવુ લાગે છે કે તમામ સારી છે. ચાલો structs2 પુનઃ ચલાવો.

1068
00:58:09,000 --> 00:58:15,000
123, ડેવિડ માથેર, 456, રોબ કિર્કલૅંડ,

1069
00:58:15,000 --> 00:58:19,000
789, ટોમી માથેર દાખલ કરો.

1070
00:58:19,000 --> 00:58:23,000
જેમ તે જ વર્ત્યા લાગે છે, પરંતુ જો હું હવે ls કરવું

1071
00:58:23,000 --> 00:58:28,000
નોટિસ ફાઈલ શું મારા તમામ કોડ વચ્ચે અહીં છે, ડેટાબેઝ,

1072
00:58:28,000 --> 00:58:32,000
તેથી આપણે કે, તે અંતે ડેટાબેઝના gedit, અને દેખાવ ખોલો.

1073
00:58:32,000 --> 00:58:34,000
તે ફાઈલ બંધારણો સેકસી નથી.

1074
00:58:34,000 --> 00:58:38,000
તે ખરેખર લાઇન દીઠ લાઇન દીઠ માહિતી લીટી એક ભાગ છે,

1075
00:58:38,000 --> 00:58:42,000
પરંતુ તમે તે છે, જે Excel અથવા CSV ફાઇલો ઉપયોગ અલ્પવિરામ કિંમતો અલગ

1076
00:58:42,000 --> 00:58:47,000
હું ચોક્કસપણે fprintf ઉપયોગ કરી હોય તેના બદલે કદાચ આ કંઈક કરવું

1077
00:58:47,000 --> 00:58:50,000
જેથી હું ખરેખર એક એક્સેલ ફાઈલ સમકક્ષ બનાવી શક્યા

1078
00:58:50,000 --> 00:58:53,000
, ફક્ત નવી પંક્તિઓ નથી અલ્પવિરામથી અલગ વસ્તુઓ છે.

1079
00:58:53,000 --> 00:58:56,000
>> આ કિસ્સામાં જો હું તેની જગ્યાએ બદલે અલ્પવિરામ નવી પંક્તિઓ ઉપયોગ કર્યો હતો

1080
00:58:56,000 --> 00:59:01,000
હું શાબ્દિક Excel માં આ ડેટાબેઝ ફાઈલ ખોલવા માટે કરી શકે છે જો હું તેની જગ્યાએ કરવામાં આ જેવા જુઓ.

1081
00:59:01,000 --> 00:59:03,000
ટૂંકમાં, હવે આપણે માટે એક ફાઈલો લખવા માટે પાવર ધરાવે છે

1082
00:59:03,000 --> 00:59:07,000
આપણે હવે સતત માહિતી શરૂ કરી શકો છો, તે ડિસ્ક પર આસપાસ રાખવા

1083
00:59:07,000 --> 00:59:10,000
તેથી અમે માહિતી આસપાસ ફરીથી અને ફરીથી રાખી શકો છો.

1084
00:59:10,000 --> 00:59:14,000
અન્ય વસ્તુઓ છે કે જે હવે થોડી વધુ પરિચિત એક દંપતી નોટિસ.

1085
00:59:14,000 --> 00:59:16,000
આ સી ફાઈલ ટોચ પર અમે typedef છે

1086
00:59:16,000 --> 00:59:21,000
કારણ કે અમે એક માહિતી પ્રકારની છે કે જે શબ્દ પ્રતિનિધિત્વ બનાવવા માગતા હતા,

1087
00:59:21,000 --> 00:59:25,000
જેથી આ પ્રકારની શબ્દ કહેવાય છે, અને અંદર આ માળખું

1088
00:59:25,000 --> 00:59:27,000
તે થોડો પારખુ હવે છે.

1089
00:59:27,000 --> 00:59:30,000
એક શબ્દ દેખીતી રીતે એક ઍરેની શા બનેલો છે?

1090
00:59:30,000 --> 00:59:33,000
માત્ર એક તર્ક શબ્દ શું છે?

1091
00:59:33,000 --> 00:59:35,000
>> તે અક્ષરો ઝાકઝમાળ છે.

1092
00:59:35,000 --> 00:59:37,000
તે અક્ષરો ક્રમ પાછળ છે માટે બેકઅપ બેક.

1093
00:59:37,000 --> 00:59:41,000
બધા કેપ્સ અક્ષરોને માટે પ્રયત્ન કરીએ છીએ આપખુદ કહેવું થાય છે મહત્તમ લંબાઈ

1094
00:59:41,000 --> 00:59:44,000
શબ્દકોષમાં કે અમે ભાંખોડિયાંભર થઈને માટે ઉપયોગ કરી રહ્યા છો કોઈ પણ શબ્દ.

1095
00:59:44,000 --> 00:59:46,000
હું +1 કરો શા માટે છે?

1096
00:59:46,000 --> 00:59:48,000
આ નલ પાત્ર.

1097
00:59:48,000 --> 00:59:51,000
યાદ છે જ્યારે અમે Bananagrams ઉદાહરણ કર્યું અમે ખાસ કિંમત જરૂરી

1098
00:59:51,000 --> 00:59:55,000
શબ્દ ઓવરને અંતે ક્રમમાં ટ્રેક રાખવા માટે

1099
00:59:55,000 --> 00:59:59,000
જ્યાં શબ્દો ખરેખર અંત એક તરીકે, અને સમસ્યા સેટ સ્પષ્ટીકરણ કહે છે

1100
00:59:59,000 --> 01:00:03,000
અહીં અમે આપેલ શબ્દ સાથે બુલિયન કિંમત સાંકળી રહ્યા છીએ,

1101
01:00:03,000 --> 01:00:05,000
એક ફ્લેગ છે, તેથી વાત સાચી કે ખોટી.

1102
01:00:05,000 --> 01:00:09,000
શું તમે આ શબ્દ પહેલાથી જ જોવા મળે છે, કારણ કે અમે ખ્યાલ

1103
01:00:09,000 --> 01:00:13,000
અમે ખરેખર યાદ એક રસ્તો જરૂર જ નથી કે કયા શબ્દ ભાંખોડિયાંભર થઈને છે

1104
01:00:13,000 --> 01:00:15,000
પરંતુ કે તમે નથી, માનવ, તે જાણવા મળ્યું છે

1105
01:00:15,000 --> 01:00:20,000
જેથી જો તમે શોધવા આમ શબ્દ "ધી" તમે હમણાં જ નથી ટાઈપ કરી શકો છો દાખલ કરવા માટે, દાખલ કરવા માટે, દાખલ કરો,

1106
01:00:20,000 --> 01:00:23,000
અને 3 પોઇન્ટ, 3 પોઇન્ટ, 3 પોઇન્ટ, 3 પોઇન્ટ મળે છે.

1107
01:00:23,000 --> 01:00:26,000
અમે એક bool સુયોજિત કરીને કે શબ્દ બ્લેકયાદી કરવાનો પ્રયત્ન કરવા માંગો છો

1108
01:00:26,000 --> 01:00:29,000
સાચું જો તમે પહેલાથી જ તે મળ્યાં છે, અને જેથી શા માટે આપણે છે

1109
01:00:29,000 --> 01:00:31,000
આ માળખામાં સમાઇ જાય છે.

1110
01:00:31,000 --> 01:00:35,000
>> હવે, નીચે અહીં ભાંખોડિયાંભર થઈને ત્યાં આ અન્ય શબ્દકોશ કહેવાય સ્ટ્રક્ટ છે.

1111
01:00:35,000 --> 01:00:39,000
અહીં ગેરહાજર શબ્દ છે typedef કારણ કે આ કિસ્સામાં

1112
01:00:39,000 --> 01:00:43,000
અમે એક શબ્દકોશ વિચારને પ્રાવૃત જરૂરી હોય,

1113
01:00:43,000 --> 01:00:46,000
અને એક શબ્દકોષના શબ્દો સંપૂર્ણ સમૂહ સમાવે છે,

1114
01:00:46,000 --> 01:00:49,000
કારણ કે આ એરે દ્વારા સૂચિત કરે છે, અને તે શબ્દોની કેટલી છે?

1115
01:00:49,000 --> 01:00:51,000
વેલ, ગમે આ ચલ કહેવાય કદ કહે છે.

1116
01:00:51,000 --> 01:00:53,000
પરંતુ અમે એક શબ્દકોશ જરૂર છે.

1117
01:00:53,000 --> 01:00:55,000
અમે માહિતી શબ્દકોષ કહેવાય પ્રકાર કરવાની જરૂર નથી.

1118
01:00:55,000 --> 01:00:58,000
અમે હમણાં જ એક તેમને જરૂર છે, તેથી તેને સી માં વળે

1119
01:00:58,000 --> 01:01:03,000
કે જો તમે typedef નથી કહેવું હોય, તો તમે હમણાં જ સ્ટ્રક્ટ કહે, પછી સર્પાકાર કૌંસ અંદર

1120
01:01:03,000 --> 01:01:05,000
તમે તમારા ચલો મૂકી, પછી તમે નામ મૂકે છે.

1121
01:01:05,000 --> 01:01:09,000
આ એક ચલ કહેવાય શબ્દકોશ જાહેર છે

1122
01:01:09,000 --> 01:01:11,000
કે આ જેવો દેખાય છે.

1123
01:01:11,000 --> 01:01:16,000
તેનાથી વિપરીત, આ રેખાઓ એક ફરીથી વાપરી શકાય માહિતી શબ્દ કહેવાય માળખું બનાવી રહ્યા

1124
01:01:16,000 --> 01:01:19,000
કે તમે બહુવિધ નકલો બનાવવા માટે, જેમ અમે બનાવી શકાય

1125
01:01:19,000 --> 01:01:22,000
વિદ્યાર્થીઓ બહુવિધ નકલો.

1126
01:01:22,000 --> 01:01:24,000
>> આ શું આખરે નથી અમને કરવા માટે પરવાનગી આપે છે?

1127
01:01:24,000 --> 01:01:30,000
મને પાછા જાઓ માં, ચાલો, કહો સરળ વખત એક સરળ ઉદાહરણ તરીકે,

1128
01:01:30,000 --> 01:01:34,000
દો અને મને અપ ખોલવા માટે, ચાલો, કહો compare1.c.

1129
01:01:34,000 --> 01:01:38,000
હાથ પર અહીં સમસ્યા પર પાછા છાલ ખરેખર છે

1130
01:01:38,000 --> 01:01:41,000
એક શબ્દમાળાને સ્તર અને બંધ આ તાલીમ વ્હીલ્સ લેતી શરૂ

1131
01:01:41,000 --> 01:01:44,000
કારણ કે તે છે કે જે શબ્દમાળા આ બધા સમય વળે

1132
01:01:44,000 --> 01:01:47,000
છે કે અમે 1 ખરેખર સપ્તાહમાં ફક્ત એક ઉપનામ વચન આપ્યું,

1133
01:01:47,000 --> 01:01:51,000
સમાનાર્થી શબ્દ કંઈક છે જે થોડી વધુ ભેદી લાગે માટે CS50 પુસ્તકાલય માંથી,

1134
01:01:51,000 --> 01:01:53,000
ઘરનાં પરચૂરણ કામો *, અને અમે આ તારો જોઇ છે તે પહેલાં.

1135
01:01:53,000 --> 01:01:55,000
અમે તેને ફાઇલો સંદર્ભમાં થયો છે.

1136
01:01:55,000 --> 01:01:59,000
>> ચાલો હવે જોવા શા માટે અમે કેટલાક સમય માટે થઈ આ વિગત હવે છુપાવી રહ્યું છે.

1137
01:01:59,000 --> 01:02:02,000
અહીં compare1.c તરીકે ઓળખાતી ફાઈલ છે,

1138
01:02:02,000 --> 01:02:07,000
અને તે દેખીતી રીતે 2 શબ્દમાળાઓ માટે વપરાશકર્તા પૂછે છે, અને ઓ ટી,

1139
01:02:07,000 --> 01:02:11,000
અને પછી તે 26 લીટી માં સમાનતા માટે તે શબ્દમાળાઓ તુલના કરવાનો પ્રયત્ન કરે છે,

1140
01:02:11,000 --> 01:02:14,000
અને જો તેઓ સમાન તે કહે કરશો, "તમે આ જ વાત લખ્યો,"

1141
01:02:14,000 --> 01:02:17,000
અને જો તેઓ સમાન નથી તે કહે છે, "તમે અલગ વસ્તુઓ લખ્યો."

1142
01:02:17,000 --> 01:02:19,000
મને આગળ વધો અને આ કાર્યક્રમ ચલાવો.

1143
01:02:19,000 --> 01:02:23,000
મને મારી સ્રોત ડિરેક્ટરીમાં જાઓ, compare1 બનાવે છે. તે ઠીક કમ્પાઇલ કરેલ છે.

1144
01:02:23,000 --> 01:02:25,000
મને compare1 ચલાવો.

1145
01:02:25,000 --> 01:02:27,000
હું ઝૂમ, દાખલ કરશો.

1146
01:02:27,000 --> 01:02:29,000
કંઈક કહો. હેલો.

1147
01:02:29,000 --> 01:02:32,000
હું કંઈક ફરીથી કહેવું પડશે. હેલો.

1148
01:02:32,000 --> 01:02:34,000
હું ચોક્કસપણે અલગ કામ નહીં લખો નહોતો.

1149
01:02:34,000 --> 01:02:37,000
>> મને આ ફરીથી પ્રયાસ કરો. આવજો.

1150
01:02:37,000 --> 01:02:40,000
વિવિધ ચોકકસ તેથી, શું થઈ રહ્યું છે તે અહીં?

1151
01:02:40,000 --> 01:02:44,000
વેલ, શું ખરેખર 26 વાક્ય છે સરખામણીમાં આવી રહી છે?

1152
01:02:44,000 --> 01:02:46,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

1153
01:02:46,000 --> 01:02:49,000
હા, તેથી તે તારણ છે કે જે શબ્દમાળા માહિતી પ્રકાર, સફેદ જૂઠ પ્રકારની છે.

1154
01:02:49,000 --> 01:02:53,000
એક શબ્દમાળા ચાર રચે છે * હોય છે, પરંતુ એક કોલસો બનાવો * શું છે?

1155
01:02:53,000 --> 01:02:56,000
એક કોલસો બનાવો *, કારણ કે તેઓ કહે છે, એક નિર્દેશક છે,

1156
01:02:56,000 --> 01:03:00,000
અને નિર્દેશક અસરકારક રીતે એક સરનામું છે,

1157
01:03:00,000 --> 01:03:05,000
મેમરીમાં રકમ સ્થાન, અને જો તમે એક શબ્દ માં હેલો જેવા લખ્યો છે થાય છે,

1158
01:03:05,000 --> 01:03:08,000
શબ્દમાળાઓ ભૂતકાળની ચર્ચાઓ પરથી યાદ

1159
01:03:08,000 --> 01:03:16,000
આ શબ્દ જેવું છે હેલો.

1160
01:03:16,000 --> 01:03:19,000
યાદ રાખો કે હેલ્લો જેવો શબ્દ રજૂ કરી શકાય

1161
01:03:19,000 --> 01:03:22,000
આ જેવા પાત્રો એક એરે તરીકે

1162
01:03:22,000 --> 01:03:25,000
અને પછી ઓવરને અંતે વિશિષ્ટ અક્ષર સાથે નલ અક્ષર કહેવાય છે,

1163
01:03:25,000 --> 01:03:27,000
આ \ સૂચવે છે.

1164
01:03:27,000 --> 01:03:29,000
શું ખરેખર એક શબ્દમાળા છે?

1165
01:03:29,000 --> 01:03:32,000
નોંધ કરો કે આ મેમરી બહુવિધ હિસ્સામાં છે,

1166
01:03:32,000 --> 01:03:36,000
અને હકીકતમાં, તે ઓવરને માત્ર એક વાર તમે સંપૂર્ણ શબ્દમાળા મારફતે જોવા ઓળખાય છે

1167
01:03:36,000 --> 01:03:38,000
ખાસ નલ પાત્ર શોધી.

1168
01:03:38,000 --> 01:03:41,000
પરંતુ જો આ મારા કમ્પ્યુટર મેમરી માંથી મેમરી એક ભાગ છે,

1169
01:03:41,000 --> 01:03:44,000
ચાલો આપખુદ કહે છે કે આ શબ્દમાળાને ફક્ત નસીબદાર મળ્યું,

1170
01:03:44,000 --> 01:03:47,000
અને તે મારા કોમ્પ્યુટર RAM ના ખૂબ શરૂઆતમાં મૂકી મળ્યો છે.

1171
01:03:47,000 --> 01:03:54,000
આ 0 બાઇટ, 1, 2, 3, 4, 5, 6 છે ...

1172
01:03:54,000 --> 01:04:02,000
>> જ્યારે હું GetString કંઈક કહેવું અને હું શબ્દમાળા ઓ = GetString કરવું

1173
01:04:02,000 --> 01:04:04,000
શું ખરેખર ફર્યા છે કરવામાં આવી રહી છે?

1174
01:04:04,000 --> 01:04:08,000
આ છેલ્લા કેટલાક અઠવાડિયા માટે, શું ખરેખર s માં સંગ્રહાયેલ છે કરવામાં આવી રહી છે

1175
01:04:08,000 --> 01:04:13,000
સે દીઠ આ શબ્દમાળાને નથી, પરંતુ આ કિસ્સામાં છે સંગ્રહિત કરવામાં આવી રહી શું છે

1176
01:04:13,000 --> 01:04:18,000
GetString ખરેખર શું કરે છે, કારણ કે નંબર 0

1177
01:04:18,000 --> 01:04:20,000
છે તેને ભૌતિક શબ્દમાળા નહિં આપે.

1178
01:04:20,000 --> 01:04:22,000
પણ ખરેખર પ્રત્યયાત્મક અર્થમાં નથી.

1179
01:04:22,000 --> 01:04:24,000
તે શું કરે છે વળતર એક નંબર છે.

1180
01:04:24,000 --> 01:04:28,000
નંબર છે કે જે મેમરીમાં હેલો સરનામું છે,

1181
01:04:28,000 --> 01:04:32,000
અને શબ્દમાળા ઓ પછી, જો આ સ્તર અમે પાછા છાલ, શબ્દમાળા ખરેખર અસ્તિત્વમાં નથી.

1182
01:04:32,000 --> 01:04:35,000
તે ફક્ત CS50 પુસ્તકાલય એક સરળીકરણ છે.

1183
01:04:35,000 --> 01:04:38,000
>> આ ખરેખર કામની પાળી * કહેવાય કંઈક છે.

1184
01:04:38,000 --> 01:04:41,000
ચાર અર્થમાં બનાવે છે કારણ કે તે એક શબ્દ હેલો, જેમ છે?

1185
01:04:41,000 --> 01:04:44,000
વેલ, તે અક્ષરો એક શ્રેણી છે, અક્ષરો શ્રેણી છે.

1186
01:04:44,000 --> 01:04:47,000
ચાર * એક પાત્રની સરનામા અર્થ થાય છે,

1187
01:04:47,000 --> 01:04:50,000
તેથી તે શું શબ્દમાળા પાછા અર્થ છે?

1188
01:04:50,000 --> 01:04:53,000
એક સરસ, શબ્દમાળા પરત સરળ રસ્તો

1189
01:04:53,000 --> 01:04:57,000
બદલે છે આઉટ આકૃતિ હું કેવી રીતે 5 કે 6 વિવિધ બાઇટ્સ પર પાછા પ્રયાસ

1190
01:04:57,000 --> 01:05:01,000
દો મને બાઇટ જે સરનામા પર પાછા?

1191
01:05:01,000 --> 01:05:03,000
પ્રથમ એક.

1192
01:05:03,000 --> 01:05:06,000
અન્ય શબ્દોમાં કહીએ દો, મને તમે મેમરીમાં પાત્રની સરનામું આપો.

1193
01:05:06,000 --> 01:05:10,000
કે ઘરનાં પરચૂરણ કામો * શું દર્શાવે છે, એક મેમરીમાં જ અક્ષર ની સરનામું.

1194
01:05:10,000 --> 01:05:12,000
કે ચલ ઓ કૉલ કરો.

1195
01:05:12,000 --> 01:05:15,000
S માં સ્ટોર ચોક્કસ સરનામું, કે જે હું આપખુદ જણાવ્યું હતું 0 છે,

1196
01:05:15,000 --> 01:05:19,000
ફક્ત વસ્તુઓ સરળ રાખવા માટે છે, પરંતુ હકીકતમાં તે સામાન્ય રીતે મોટા નંબર છે.

1197
01:05:19,000 --> 01:05:21,000
>> એક મિનિટ રાહ જુઓ.

1198
01:05:21,000 --> 01:05:23,000
જો તમે માત્ર મને પ્રથમ અક્ષર ની સરનામા આપીને કરી રહ્યાં છો, હું કેવી રીતે જાણી શકું સરનામું શું છે

1199
01:05:23,000 --> 01:05:25,000
બીજા પાત્ર, ત્રીજા, ચોથા અને પાંચમા?

1200
01:05:25,000 --> 01:05:27,000
[અશ્રાવ્ય વિદ્યાર્થીઓ]

1201
01:05:27,000 --> 01:05:31,000
તમે માત્ર ખબર જ્યાં શબ્દમાળા ઓવરને આ સરળ યુક્તિ રીતે છે,

1202
01:05:31,000 --> 01:05:35,000
તેથી જ્યારે તમે કંઈક જેવા printf વાપરવા માટે, શું printf શાબ્દિક પોતાની દલીલ તરીકે લે છે,

1203
01:05:35,000 --> 01:05:39,000
જણાવ્યું હતું કે અમે આ% s પ્લેસહોલ્ડર વાપરવા માટે, અને પછી તમે પાસ

1204
01:05:39,000 --> 01:05:41,000
આ ચલ છે કે જે શબ્દમાળા સ્ટોર છે.

1205
01:05:41,000 --> 01:05:47,000
તમે ખરેખર પસાર કરી રહ્યાં છો શું કે જેઓ શબ્દમાળા પ્રથમ અક્ષર સરનામું છે.

1206
01:05:47,000 --> 01:05:50,000
Printf પછી લૂપ અથવા પાશ જ્યારે કે સરનામા પ્રાપ્ત પર વાપરે છે,

1207
01:05:50,000 --> 01:05:53,000
દાખલા તરીકે, 0, જેથી દો મને હવે કરવા માટે,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" ઓ);

1209
01:06:02,000 --> 01:06:07,000
જ્યારે હું કૉલ printf ("% s \ n" ઓ); હું શું ખરેખર સાથે છું printf પૂરી

1210
01:06:07,000 --> 01:06:13,000
s માં પ્રથમ અક્ષર ની સરનામું, કે જે આ મનસ્વી કિસ્સામાં એચ છે

1211
01:06:13,000 --> 01:06:16,000
>> Printf કેવી રીતે ખબર નથી ચોકકસ શું સ્ક્રીન પર પ્રદર્શિત કરવા માટે?

1212
01:06:16,000 --> 01:06:19,000
જે વ્યક્તિ અમલમાં printf એક વખતે કે લૂપ માટે લૂપ એક અમલમાં

1213
01:06:19,000 --> 01:06:23,000
કહે છે કે, આ અક્ષર વિશિષ્ટ નલ અક્ષર જેટલી?

1214
01:06:23,000 --> 01:06:25,000
જો નહિં, તો તે છાપો. આ કેવી રીતે એક વિશે શું?

1215
01:06:25,000 --> 01:06:28,000
જો તે છાપી નહિં, તો તે છાપો, તે છાપો, તે છાપો.

1216
01:06:28,000 --> 01:06:32,000
ઓહ, આ એક વિશિષ્ટ છે. છાપકામ રોકો અને વપરાશકર્તા આવો.

1217
01:06:32,000 --> 01:06:35,000
અને જે શબ્દશઃ છે બધા કે હૂડ નીચે કરવામાં આવી રહ્યું છે તે,

1218
01:06:35,000 --> 01:06:38,000
અને તે એક વર્ગ પ્રથમ દિવસે પાચન ઘણું,

1219
01:06:38,000 --> 01:06:43,000
પરંતુ હવે તે ખરેખર સમજ બધું બિલ્ડિંગ બ્લોક છે

1220
01:06:43,000 --> 01:06:46,000
કે અમારી કોમ્પ્યુટર મેમરી ની અંદર પર ચાલી રહ્યું છે,

1221
01:06:46,000 --> 01:06:49,000
અને છેવટે અમે આ થોડી મદદ સાથે અલગ પીંજવું પડશે

1222
01:06:49,000 --> 01:06:51,000
અમારા મિત્રો પાસેથી સ્ટેનફોર્ડ ખાતે.

1223
01:06:51,000 --> 01:06:56,000
>> સ્ટેનફોર્ડ ખાતે પ્રોફેસર નિક Parlante આ અદ્ભુત વિડિઓ ક્રમ કર્યું છે

1224
01:06:56,000 --> 01:06:58,000
વિવિધ ભાષાઓ રજૂઆત તમામ પ્રકારના

1225
01:06:58,000 --> 01:07:00,000
આ થોડો Claymation અક્ષર Binky.

1226
01:07:00,000 --> 01:07:03,000
વૉઇસ તમે છો થોડા બીજા પૂર્વાવલોકન ઝલક માં સાંભળવા

1227
01:07:03,000 --> 01:07:05,000
એક સ્ટેનફોર્ડ પ્રોફેસર હોય છે, અને તમે રહ્યાં છો

1228
01:07:05,000 --> 01:07:07,000
હવે આ અધિકાર માત્ર 5 કે 6 સેકન્ડો

1229
01:07:07,000 --> 01:07:09,000
પરંતુ આ નોંધ છે કે જેના પર આજે આપણે એવા તારણ પર પડશે છે

1230
01:07:09,000 --> 01:07:11,000
અને બુધવારે શરૂ કરો.

1231
01:07:11,000 --> 01:07:15,000
હું તમને Binky, પૂર્વાવલોકન સાથે પોઇન્ટર ફન આપે છે.

1232
01:07:15,000 --> 01:07:18,000
[♪ સંગીત ♪] [પ્રોફેસર Parlante] હાય, Binky.

1233
01:07:18,000 --> 01:07:21,000
અપ વેક. તે નિર્દેશક આનંદ માટે સમય છે.

1234
01:07:21,000 --> 01:07:24,000
[Binky] કે શું છે? પોઇન્ટર વિશે જાણો!

1235
01:07:24,000 --> 01:07:26,000
ઓહ, એક જાતની મીઠાઈ!

1236
01:07:26,000 --> 01:07:29,000
>> અમે તમને બુધવાર પર જોશે.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]