1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [સમીક્ષા] [ક્વિઝ 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi રોસ, ટોમી MacWilliam, લુકાસ Freitas, જોસેફ ઓન્ગ] [હાર્વર્ડ યુનિવર્સિટી]

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

4
00:00:08,000 --> 00:00:10,000
>> અરે, દરેકને.

5
00:00:10,000 --> 00:00:15,000
0 ક્વિઝ છે, કે જે જગ્યાએ આ બુધવારે રહી છે માટે સમીક્ષા સત્ર માટે આપનું સ્વાગત છે.

6
00:00:15,000 --> 00:00:19,000
માટે અમે શું કરી રાત્રે જઈ રહ્યાં છો, હું 3 અન્ય TFs સાથે છું,

7
00:00:19,000 --> 00:00:24,000
અને સાથે સાથે અમે અમે શું કોર્સમાં કર્યું છે અત્યાર સુધી એક સમીક્ષા મારફતે જાઓ જતાં રહ્યાં છો.

8
00:00:24,000 --> 00:00:27,000
તે 100% વ્યાપક બનશે નહીં, પણ તે તમને વધુ સારી રીતે વિચાર આપવી જોઇએ

9
00:00:27,000 --> 00:00:31,000
તમે શું પહેલાથી નીચે હોય અને તમે હજી પણ બુધવાર પહેલાં અભ્યાસ કરવાની જરૂર છે કે શું.

10
00:00:31,000 --> 00:00:34,000
અને પ્રશ્નો સાથે તમારા હાથમાં એકત્ર નિઃસંકોચ આપણે સાથે જઈ રહ્યાં છો,

11
00:00:34,000 --> 00:00:38,000
પરંતુ ધ્યાનમાં રાખો કે અમે પણ અંતે સમય થોડો પડશે અંત

12
00:00:38,000 --> 00:00:41,000
જો આપણે થોડી મિનિટો સાથે મારફતે વિચાર ફાજલ-કરવા માટે સામાન્ય પ્રશ્નો કરવા માટે,

13
00:00:41,000 --> 00:00:47,000
જેથી ધ્યાનમાં રાખો કે, અને તેથી અમે 0 અઠવાડિયું સાથે શરૂઆતમાં શરૂ રહ્યા છીએ.

14
00:00:47,000 --> 00:00:50,000
>> [0 સમીક્ષા કિવઝઃ!] [0 ભાગ] [Lexi રોસ] પરંતુ તે પહેલાં અમે કે ચાલો વિશે વાત

15
00:00:50,000 --> 00:00:53,000
ક્વિઝ ઓફ લોજિસ્ટિક્સ.

16
00:00:53,000 --> 00:00:55,000
>> [લોજિસ્ટિક્સ] [ક્વિઝ / 10 10 બુધવારે વ્યાખ્યાન બદલે થાય છે]

17
00:00:55,000 --> 00:00:57,000
>> [(વિગતો માટે http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf જુઓ)] તે બુધવાર, 10 મી ઓક્ટોબરના રોજ છે.

18
00:00:57,000 --> 00:01:00,000
>> કે આ બુધવાર, અને જો તમે આ URL માટે અહીં જાઓ,

19
00:01:00,000 --> 00:01:03,000
જે પણ છે CS50.net-ત્યાં 'ઓ સુલભ કરવા માટે લિંકને-

20
00:01:03,000 --> 00:01:06,000
તમે જ્યાં પર આધારિત જવા વિશે જાણકારી જોઈ શકો છો

21
00:01:06,000 --> 00:01:10,000
તમારા છેલ્લા નામ અથવા શાળાના જોડાણ તેમજ

22
00:01:10,000 --> 00:01:14,000
તે વિશે બરાબર ક્વિઝ શું આવરે છે અને પ્રશ્નો પ્રકારો કે જે તમે વિચાર જઈ રહ્યાં છો કરશે કહે છે.

23
00:01:14,000 --> 00:01:19,000
ધ્યાનમાં રાખો કે તમે પણ એક વિભાગમાં ક્વિઝ માટે સમીક્ષા તક હશે,

24
00:01:19,000 --> 00:01:21,000
તેથી તમારા TFs કેટલાક અભ્યાસ સમસ્યાઓ ઉપર જઈને જોઈએ,

25
00:01:21,000 --> 00:01:29,000
અને તે અન્ય સારું જોવા માટે તમે જ્યાં પણ આ ક્વિઝ માટે અભ્યાસ કરવાની જરૂર છે તક છે.

26
00:01:29,000 --> 00:01:32,000
ચાલો બિટ્સ 'એન' બાઇટ્સ સાથે શરૂઆતમાં શરૂ કરો.

27
00:01:32,000 --> 00:01:35,000
યાદ રાખો થોડી ખાલી 0 અથવા 1 છે,

28
00:01:35,000 --> 00:01:38,000
અને એક બાઈટ 8 તે બિટ્સની એક સંગ્રહ છે.

29
00:01:38,000 --> 00:01:42,000
ચાલો બિટ્સ આ સંગ્રહ પર અહીં જુઓ.

30
00:01:42,000 --> 00:01:44,000
અમે બહાર આકૃતિ કેટલી બિટ્સ ત્યાં છે કરવાનો પ્રયત્ન કરીશું.

31
00:01:44,000 --> 00:01:48,000
જ્યાં અમે ગણતરી ત્યાં ફક્ત તેમને, 8 આઠ 0 અથવા 1 એકમો.

32
00:01:48,000 --> 00:01:51,000
અને કારણ કે 8 બિટ કે, 1 બાઈટ છે છે,

33
00:01:51,000 --> 00:01:53,000
દો અને તેને હેક્સાડેસિમલ રૂપાંતરિત કરો.

34
00:01:53,000 --> 00:01:58,000
હેક્સાડેસિમલ 16 આધાર છે, અને તે સારુ સરળ કન્વર્ટ

35
00:01:58,000 --> 00:02:01,000
દ્વિસંગી એક નંબર છે, કે જે એ છે કે શું છે હેક્સાડેસિમલ એક નંબર છે.

36
00:02:01,000 --> 00:02:04,000
બધા અમે નથી અમે 4 જૂથો પર નજર,

37
00:02:04,000 --> 00:02:07,000
અને અમે તેમને યોગ્ય હેક્સાડેસિમલ આંકડાના રૂપાંતરિત કરો.

38
00:02:07,000 --> 00:02:11,000
અમે 4 ના જૂથ જમણી સાથે સૌથી શરૂ કરવા માટે, 0011 જેથી.

39
00:02:11,000 --> 00:02:16,000
કે જે એક 1 અને 2 એક છે, કે જેથી એક સાથે કે 3 બનાવે બનશે.

40
00:02:16,000 --> 00:02:19,000
અને પછી ચાલો 4 બીજી બ્લોક જુઓ.

41
00:02:19,000 --> 00:02:24,000
1101. કે જે એક 1, 4, અને તે એક 8 એક જ હશે.

42
00:02:24,000 --> 00:02:28,000
એકસાથે કે 13 છે, જે ડી બનાવે રહ્યું છે

43
00:02:28,000 --> 00:02:32,000
અને અમે યાદ કરીશું કે હેક્સાડેસિમલ આપણે માત્ર 9 મારફતે 0 થતી નથી.

44
00:02:32,000 --> 00:02:36,000
અમે એફ મારફત 0 જાઓ, 9 પછી, જેથી એ 10 અનુલક્ષે,

45
00:02:36,000 --> 00:02:40,000
11 બી વગેરે, એટ જ્યાં એફ 15 છે.

46
00:02:40,000 --> 00:02:44,000
13 અહીં ડી છે,

47
00:02:44,000 --> 00:02:49,000
તેથી તે અક્ષાંશ કન્વર્ટ કરવા માટે બધા અમે અમે ખરેખર છે

48
00:02:49,000 --> 00:02:52,000
2 ની શક્તિ તરીકે દરેક સ્થિતિમાં સારવાર.

49
00:02:52,000 --> 00:02:58,000
કે એક 1, 2 એક, શૂન્ય 4s, 8 શૂન્ય, 16 એક, વગેરે એટ છે,

50
00:02:58,000 --> 00:03:03,000
અને તે થોડું મુશ્કેલ તમારા માથા માં ગણતરી છે, પરંતુ જો આપણે આગામી સ્લાઇડ પર જાઓ

51
00:03:03,000 --> 00:03:05,000
અમે કે જે જવાબ જોઈ શકો છો.

52
00:03:05,000 --> 00:03:09,000
>> અનિવાર્યપણે અમે જમણેથી સમગ્ર જઈ રહ્યાં છો પાછા ડાબી,

53
00:03:09,000 --> 00:03:14,000
અને અમે 2 લગતીવળગતી શક્તિ દ્વારા દરેક આંકડાના ગુણાકાર કરી રહ્યાં છો.

54
00:03:14,000 --> 00:03:19,000
અને યાદ રાખો, હેક્સાડેસિમલ માટે અમે 0x સાથે શરૂઆતમાં આ આંકડાઓ નોંધવા

55
00:03:19,000 --> 00:03:23,000
તેથી અમે તેને અક્ષાંશ નંબર સાથે ગૂંચવવામાં ન નથી.

56
00:03:23,000 --> 00:03:29,000
પર સતત આ એક ASCII ટેબલ છે,

57
00:03:29,000 --> 00:03:35,000
અને અમે શું ASCII અક્ષરો વાપરવા માટે ના સંખ્યાકીય મૂલ્યો સાથે ગોઠવણ છે.

58
00:03:35,000 --> 00:03:39,000
આ ક્રિપ્ટોગ્રાફી pset યાદ રાખો કે અમે તે ASCII કોષ્ટક વ્યાપક ઉપયોગ કરવામાં

59
00:03:39,000 --> 00:03:43,000
ક્રમમાં ક્રિપ્ટોગ્રાફી વિવિધ પદ્ધતિઓનો ઉપયોગ કરવા માટે,

60
00:03:43,000 --> 00:03:47,000
સીઝર અને Vigenère સાઇફર, અલગ અલગ પત્રો કન્વર્ટ

61
00:03:47,000 --> 00:03:52,000
આ વપરાશકર્તા દ્વારા આપવામાં કી અનુસાર શબ્દમાળા છે.

62
00:03:52,000 --> 00:03:56,000
ચાલો તે ASCII ગણિત એક થોડો જુઓ.

63
00:03:56,000 --> 00:04:02,000
અંતે 'પી' અક્ષર સ્વરૂપ કે જે પ્ર હશે માં + 1 છીએ,

64
00:04:02,000 --> 00:04:07,000
યાદ અને '5 '5 ≠ છે.

65
00:04:07,000 --> 00:04:10,000
અને બરાબર અમે કેવી રીતે તે 2 સ્વરૂપો વચ્ચે રૂપાંતરિત કરશે?

66
00:04:10,000 --> 00:04:13,000
તે વાસ્તવમાં ખૂબ હાર્ડ નથી.

67
00:04:13,000 --> 00:04:16,000
ક્રમમાં 5 વિચાર અમે '0 સબ્ટ્રેક્ટ '

68
00:04:16,000 --> 00:04:20,000
કારણ કે ત્યાં '0 વચ્ચે 5 જગ્યાઓ હોય છે, 'અને '5.'

69
00:04:20,000 --> 00:04:23,000
ક્રમમાં અન્ય રીતે આપણે માત્ર 0 ઉમેરવા જાઓ,

70
00:04:23,000 --> 00:04:25,000
તેથી તે નિયમિત અંકગણિત જેવા પ્રકારની છે.

71
00:04:25,000 --> 00:04:29,000
જસ્ટ યાદ રાખો કે જ્યારે કંઈક તેની આસપાસ અવતરણ છે તે પાત્ર છે

72
00:04:29,000 --> 00:04:37,000
અને આમ તે ASCII કોષ્ટકમાં કિંમત અનુલક્ષે છે.

73
00:04:37,000 --> 00:04:40,000
વધુ સામાન્ય કોમ્પ્યુટર વિજ્ઞાન વિષય માં ખસેડી રહ્યા છીએ.

74
00:04:40,000 --> 00:04:43,000
અમે શીખ્યા એક એલ્ગોરિધમ છે શું અને કેવી રીતે અમે પ્રોગ્રામિંગ ઉપયોગ

75
00:04:43,000 --> 00:04:45,000
અલગોરિથમનો અમલ.

76
00:04:45,000 --> 00:04:48,000
એલ્ગોરિધમ્સ કેટલાક ઉદાહરણો ખરેખર જેવા સરળ કંઈક છે

77
00:04:48,000 --> 00:04:51,000
ચકાસણી શું નંબર એકી કે બેકી છે.

78
00:04:51,000 --> 00:04:54,000
કે યાદ અમે 2 દ્વારા નંબર MoD અને તપાસ જો પરિણામ 0 છે.

79
00:04:54,000 --> 00:04:57,000
જો આમ હોય, તો તે પણ છે. જો નહિં, તો તે વિચિત્ર છે.

80
00:04:57,000 --> 00:04:59,000
અને તે ખરેખર એક મૂળભૂત અલ્ગોરિધમનો એક ઉદાહરણ છે.

81
00:04:59,000 --> 00:05:02,000
>> વધુ સામેલ એક એક થોડો દ્વિસંગી શોધ છે,

82
00:05:02,000 --> 00:05:05,000
અમે ઉપર સમીક્ષા સત્ર પછી જઈશ છે.

83
00:05:05,000 --> 00:05:09,000
અને પ્રોગ્રામિંગ શબ્દ અમે અલ્ગોરિધમનો લેવા માટે ઉપયોગ થાય છે

84
00:05:09,000 --> 00:05:15,000
અને તે કોમ્પ્યુટર કોડ રૂપાંતરિત વાંચી શકે છે.

85
00:05:15,000 --> 00:05:20,000
પ્રોગ્રામિંગ અને 2 ઉદાહરણો સ્ક્રેચ છે,

86
00:05:20,000 --> 00:05:22,000
જે અમે શું 0 અઠવાડિયું કર્યું હતું.

87
00:05:22,000 --> 00:05:25,000
તેમ છતાં અમે ખરેખર અણનમ કોડ ટાઇપ તેને અમલમાં એક રીત છે

88
00:05:25,000 --> 00:05:29,000
આ ગણતરીઓ, કે જે નંબરો 1-10 છાપવા છે,

89
00:05:29,000 --> 00:05:32,000
અને અહીં આપણે સી પ્રોગ્રામિંગ ભાષામાં જ નથી.

90
00:05:32,000 --> 00:05:41,000
આ વિધેયાત્મક રીતે સમકક્ષ, માત્ર વિવિધ ભાષાઓ અથવા સિન્ટેક્ષ માં લખાયેલ છે.

91
00:05:41,000 --> 00:05:44,000
પછી અમે બુલિયન સમીકરણો વિશે શીખી,

92
00:05:44,000 --> 00:05:48,000
અને બુલિયન કિંમત છે કે જે ક્યાં તો સાચી કે ખોટી છે છે,

93
00:05:48,000 --> 00:05:51,000
અને અહીં ઘણી વખત નજર બુલિયન સમીકરણો

94
00:05:51,000 --> 00:05:55,000
શરતો ની અંદર જાય છે, તેથી જો (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
સાથે સાથે, અમે પહેલાથી જ સેટ એક્સ = 5, આથી તે શરત સાચી માટે મૂલ્યાંકન રહ્યું છે.

96
00:06:00,000 --> 00:06:03,000
અને જો તે સાચું છે, કોડ ગમે તે સ્થિતિ નીચે છે

97
00:06:03,000 --> 00:06:08,000
છે કોમ્પ્યુટર દ્વારા મૂલ્યાંકન કરવામાં જવાનું, જેથી શબ્દમાળા પર છપાશે રહ્યું છે

98
00:06:08,000 --> 00:06:12,000
પ્રમાણભૂત આઉટપુટ, અને આ શબ્દ શરત

99
00:06:12,000 --> 00:06:16,000
ગમે તે નિવેદન જો ના કૌંસ અંદર છે ઉલ્લેખ કરે છે.

100
00:06:16,000 --> 00:06:20,000
તમામ ઓપરેટરો યાદ રાખો.

101
00:06:20,000 --> 00:06:26,000
| ભેગા જ્યારે અમે પ્રયાસ કરી રહ્યા છો માટે 2 અથવા વધુ શરતો, | તે && અને યાદ રાખો

102
00:06:26,000 --> 00:06:30,000
== નથી = કે કેમ તેની તપાસ 2 વસ્તુઓ સમાન છે.

103
00:06:30,000 --> 00:06:36,000
યાદ રાખો કે = સોંપણી માટે છે જ્યારે == એક બુલિયન ઓપરેટર છે.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ અને પછી અંતિમ 2 સ્વયંસ્પષ્ટ છે.

105
00:06:41,000 --> 00:06:45,000
બૂલીન લોજિક એ સામાન્ય અહીં સમીક્ષા.

106
00:06:45,000 --> 00:06:48,000
અને બુલિયન અભિવ્યક્તિઓ પણ આંટીઓ મહત્વપૂર્ણ છે,

107
00:06:48,000 --> 00:06:50,000
જે અમે ઉપર હવે જવા પડશે.

108
00:06:50,000 --> 00:06:56,000
અમે આંટીઓ લગભગ 3 પ્રકારના અત્યાર સુધી CS50 માં, વિદ્વાન માટે, જ્યારે, અને આમ કરતી વખતે.

109
00:06:56,000 --> 00:06:59,000
અને તે અગત્યનું છે તે જાણવા માટે કે મોટાભાગના હેતુઓ માટે જ્યારે

110
00:06:59,000 --> 00:07:02,000
અમે ખરેખર લૂપ કોઈપણ પ્રકારની સામાન્ય રીતે ઉપયોગ કરી શકો છો

111
00:07:02,000 --> 00:07:06,000
ત્યાં હેતુઓ અથવા સામાન્ય દાખલાની ચોક્કસ પ્રકારના હોય છે

112
00:07:06,000 --> 00:07:09,000
પ્રોગ્રામિંગ કે જે ખાસ કરીને એક આ લૂપ્સના માટે કૉલ માં

113
00:07:09,000 --> 00:07:13,000
કે તે બનાવવા સૌથી કાર્યક્ષમ અથવા તે રીતે કોડ મનોહર.

114
00:07:13,000 --> 00:07:18,000
ચાલો પર જાઓ આ લૂપ્સના દરેક શું માટે વાપરી શકાય મોટે ભાગે થાય છે.

115
00:07:18,000 --> 00:07:21,000
>> માં લૂપ માટે અમે સામાન્ય રીતે પહેલેથી જ ખબર કેટલી વખત અમે ભારપૂર્વક કહેવું કરવા માંગો છો.

116
00:07:21,000 --> 00:07:24,000
કે અમે શું શરત મૂકી.

117
00:07:24,000 --> 00:07:28,000
માટે, આઇ = 0, આઇ 10 <, ઉદાહરણ તરીકે.

118
00:07:28,000 --> 00:07:31,000
અમે પહેલાથી જ જાણો છો કે અમે 10 વખત કંઈક કરવા માંગો છો.

119
00:07:31,000 --> 00:07:34,000
હવે, જ્યારે લૂપ માટે, સામાન્ય રીતે આપણે જરૂરી નથી

120
00:07:34,000 --> 00:07:36,000
ખબર કેટલી વખત અમે લૂપ ચલાવવા માટે કરવા માંગો છો.

121
00:07:36,000 --> 00:07:39,000
પરંતુ અમે શરત અમુક પ્રકારની ખબર છે કે અમે તે કરવા માંગો છો કરવું

122
00:07:39,000 --> 00:07:41,000
હંમેશા સાચી હોઈ શકે છે અથવા હંમેશા ખોટા હોય છે.

123
00:07:41,000 --> 00:07:44,000
ઉદાહરણ તરીકે, જ્યારે સુયોજિત થયેલ છે.

124
00:07:44,000 --> 00:07:46,000
હવે કહો કે જે બુલિયન ચલ છે.

125
00:07:46,000 --> 00:07:48,000
જ્યારે સાચું આપણે કોડ મૂલ્યાંકન કરવા માંગો છો,

126
00:07:48,000 --> 00:07:52,000
જેથી થોડો વધુ વિસ્તારવા લાયક, લૂપ માટે થોડો વધુ એક કરતાં સામાન્ય બીટ,

127
00:07:52,000 --> 00:07:55,000
પરંતુ લૂપ માટે કોઇ પણ જ્યારે લૂપ રૂપાંતરિત કરી શકાય છે.

128
00:07:55,000 --> 00:08:00,000
છેલ્લે નથી, જ્યારે આંટીઓ, કે જે trickiest પ્રયત્ન અધિકાર દૂર સમજાવવાનો શકે છે,

129
00:08:00,000 --> 00:08:04,000
ઘણીવાર ઉપયોગ થાય છે જ્યારે અમે કોડ પ્રથમ મૂલ્યાંકન કરવા માંગો છો

130
00:08:04,000 --> 00:08:06,000
પ્રથમ વખત પહેલાં અમે શરત તપાસો.

131
00:08:06,000 --> 00:08:09,000
માટે સામાન્ય ઉપયોગ કેસ કરતા હો ત્યારે લૂપ

132
00:08:09,000 --> 00:08:12,000
જ્યારે તમે વપરાશકર્તા ઈનપુટ વિચાર કરવા માંગો છો, અને તમે જાણો છો કે તમે વપરાશકર્તા પૂછવા માગો છો

133
00:08:12,000 --> 00:08:15,000
ઈનપુટ માટે ઓછામાં ઓછી એકવાર, પરંતુ જો તેઓ તમને સારું ઇનપુટ આપતા નથી અધિકાર દૂર

134
00:08:15,000 --> 00:08:18,000
તમે તેમને પૂછ્યા સુધી તેઓ તમને સારા ઇનપુટ આપી રાખવા માંગો છો.

135
00:08:18,000 --> 00:08:21,000
કે જે સૌથી સામાન્ય ઉપયોગ જ્યારે લૂપ છે નથી,

136
00:08:21,000 --> 00:08:23,000
દો અને આ લૂપ્સના વાસ્તવિક માળખું જુઓ.

137
00:08:23,000 --> 00:08:27,000
સામાન્ય રીતે તેઓ હંમેશા આ પદ્ધતિઓને અનુસરે વલણ ધરાવે છે.

138
00:08:27,000 --> 00:08:30,000
>> અંદર માટે લૂપ પર તમે 3 ઘટકો હોય છે:

139
00:08:30,000 --> 00:08:35,000
આરંભ, જેમ કે ખાસ કરીને કંઈક પૂર્ણાંક હું = 0 જ્યાં i ગણક છે,

140
00:08:35,000 --> 00:08:40,000
શરત છે, જ્યાં અમે કહી લૂપ માટે આ સ્કોર અને આ સ્થિતિ હજી પણ ધરાવે સુધી માંગો છો,

141
00:08:40,000 --> 00:08:44,000
હું 10 <, અને પછી છેવટે સુધારા, કે જે અમે કેવી રીતે વધારો જેવી

142
00:08:44,000 --> 00:08:47,000
લૂપમાં દરેક સમયે કાઉન્ટર ચલ.

143
00:08:47,000 --> 00:08:50,000
સામાન્ય ત્યાં જોવા વસ્તુ માત્ર હું + + છે,

144
00:08:50,000 --> 00:08:52,000
જે હું 1 દ્વારા દર વખતે વધારો થાય છે.

145
00:08:52,000 --> 00:08:55,000
તમે પણ મને + + = 2 કંઈક કરી શકે,

146
00:08:55,000 --> 00:08:58,000
જેનો અર્થ છે કે હું 2 દરેક વખતે જ્યારે તમે લૂપ દ્વારા જાઓ ઉમેરો.

147
00:08:58,000 --> 00:09:03,000
અને પછી આવું તો કોઈપણ કોડ કે જે વાસ્તવમાં લૂપ ભાગ તરીકે ચલાવે ઉલ્લેખ કરે છે.

148
00:09:03,000 --> 00:09:09,000
અને જ્યારે લૂપ માટે, આ સમય અમે ખરેખર લૂપની બહાર પ્રારંભ છે,

149
00:09:09,000 --> 00:09:12,000
તેથી, ઉદાહરણ તરીકે, ચાલો કહેવું અમે લૂપ જ પ્રકાર તરીકે હું માત્ર વર્ણવેલ કરવા પ્રયાસ કરી રહ્યા છો.

150
00:09:12,000 --> 00:09:16,000
અમે કહ્યું પૂર્ણાંક હું = 0 પહેલાં લૂપ શરૂ થાય છે.

151
00:09:16,000 --> 00:09:20,000
પછી અમે જ્યારે હું 10 <આવું કહેવું શકે છે,

152
00:09:20,000 --> 00:09:22,000
તેથી પહેલાં તરીકે કોડ જ બ્લોક,

153
00:09:22,000 --> 00:09:26,000
અને આ સમય કોડ સુધારો ઉદાહરણ તરીકે, ભાગ, આઇ + +,

154
00:09:26,000 --> 00:09:29,000
વાસ્તવમાં લૂપની અંદર જાય છે.

155
00:09:29,000 --> 00:09:33,000
અને છેલ્લે, માટે એક કરતા હો ત્યારે, તે જ્યારે લૂપ માટે સમાન છે,

156
00:09:33,000 --> 00:09:36,000
પરંતુ અમે યાદ રાખો કે આ કોડ એકવાર મૂલ્યાંકન કરશે

157
00:09:36,000 --> 00:09:40,000
પહેલાં શરત ચકાસાયેલ છે, તેથી તે ઘણો વધારે અર્થપૂર્ણ બને છે

158
00:09:40,000 --> 00:09:44,000
જો તમે નીચે ટોચના ક્રમમાં તે જુઓ.

159
00:09:44,000 --> 00:09:49,000
એક કરતા હો ત્યારે લૂપ કોડ મૂલ્યાંકન પહેલાં તમે પણ જ્યારે સ્થિતિ પર નજર,

160
00:09:49,000 --> 00:09:55,000
જ્યારે લૂપ જ્યારે, તે પ્રથમ ચકાસે છે.

161
00:09:55,000 --> 00:09:59,000
નિવેદનો અને ચલો.

162
00:09:59,000 --> 00:10:04,000
જ્યારે અમે નવા ચલ બનાવવા માંગો છો તો અમે પ્રથમ તે પ્રારંભ કરવા માંગો છો.

163
00:10:04,000 --> 00:10:07,000
>> ઉદાહરણ તરીકે, પૂર્ણાંક પટ્ટી ચલ બાર પ્રારંભ,

164
00:10:07,000 --> 00:10:10,000
પરંતુ તેને એક મૂલ્ય આપતી નથી, તેથી શું માતાનો બાર કિંમત હવે છે?

165
00:10:10,000 --> 00:10:12,000
અમે નથી જાણતા.

166
00:10:12,000 --> 00:10:14,000
કેટલાક કચરો કિંમત છે કે જે પહેલાં મેમરી હતું ત્યાં સંગ્રહિત હોઈ શકે છે,

167
00:10:14,000 --> 00:10:16,000
અને અમે તે ચલ વાપરવા માંગો નહિં

168
00:10:16,000 --> 00:10:19,000
ત્યાં સુધી અમે ખરેખર તે કિંમત આપે છે,

169
00:10:19,000 --> 00:10:21,000
કે જેથી અમે તેને અહીં જાહેર.

170
00:10:21,000 --> 00:10:24,000
પછી અમે તેને 42 નીચે હોઈ પ્રારંભ.

171
00:10:24,000 --> 00:10:28,000
હવે, અલબત્ત, આપણે જાણીએ છીએ કે આ એક લીટી પર, પૂર્ણાંક 42 = બાધ કરી શકાય છે.

172
00:10:28,000 --> 00:10:30,000
પરંતુ ફક્ત બહુવિધ પગલાંઓ કે જે રહ્યું હોય સાફ કરવા માટે,

173
00:10:30,000 --> 00:10:34,000
જાહેરાત અને પ્રારંભ અલગ અહીં થાય છે.

174
00:10:34,000 --> 00:10:38,000
તે એક પગલું પર થાય છે, અને આગામી એક પૂર્ણાંક baz બાધ = 1 +

175
00:10:38,000 --> 00:10:44,000
આ નીચે નિવેદન, આ કોડ બ્લોક ઓવરને અંતે જેથી ઇન્ક્રીમેન્ટ baz,

176
00:10:44,000 --> 00:10:48,000
જો અમે baz મૂલ્ય છાપો હતા તે 44 થશે

177
00:10:48,000 --> 00:10:52,000
કારણ કે અમે જાહેર અને તે પ્રારંભ માટે 1> બાર હોય છે,

178
00:10:52,000 --> 00:10:58,000
અને પછી અમે તેની સાથે વધુ એક વખત વધારો એ + +.

179
00:10:58,000 --> 00:11:02,000
અમે આ ખૂબ થોડા સમય પર ગયા, પરંતુ તે સારી છે એક સામાન્ય હોય છે

180
00:11:02,000 --> 00:11:04,000
સૂત્રો અને ઘટનાઓ શું છે તે સમજવામાં.

181
00:11:04,000 --> 00:11:06,000
અમે મુખ્યત્વે સ્ક્રેચ આવું કર્યું,

182
00:11:06,000 --> 00:11:09,000
જેથી તમે થ્રેડ્સના કોડ બહુવિધ સિક્વન્સ તરીકે વિચાર કરી શકો છો

183
00:11:09,000 --> 00:11:11,000
તે જ સમયે ચાલી રહ્યું છે.

184
00:11:11,000 --> 00:11:14,000
વાસ્તવિકતા, તે કદાચ આ જ સમયે ચાલી રહ્યુ છે,

185
00:11:14,000 --> 00:11:17,000
પરંતુ પ્રકારના અમૂર્ત અમે તે છે કે તે રીતે વિચાર કરી શકો છો.

186
00:11:17,000 --> 00:11:20,000
>> સ્ક્રેચ, ઉદાહરણ તરીકે, અમે બહુવિધ sprites હતી.

187
00:11:20,000 --> 00:11:22,000
તે જ સમયે વિવિધ કોડ શકાય ચલાવવા શકે છે.

188
00:11:22,000 --> 00:11:26,000
એક, જ્યારે અન્ય કંઈક કહી રહ્યાં છે વૉકિંગ શકાય છે

189
00:11:26,000 --> 00:11:29,000
સ્ક્રીન વિવિધ ભાગ છે.

190
00:11:29,000 --> 00:11:34,000
ઘટનાઓ બહાર તર્ક અલગ અન્ય રીત છે

191
00:11:34,000 --> 00:11:37,000
તમારો કોડ વિવિધ ઘટકો વચ્ચે,

192
00:11:37,000 --> 00:11:40,000
અને સ્ક્રેચ માં અમે ઘટનાઓ અનુકરણ બ્રોડકાસ્ટ મદદથી સમર્થ હતા,

193
00:11:40,000 --> 00:11:43,000
અને તે ખરેખર છે જ્યારે હું પ્રાપ્ત હું સાંભળો જ્યારે,

194
00:11:43,000 --> 00:11:47,000
પરંતુ તે એક આવશ્યક માહિતી ટ્રાન્સમિટ કરવાનો માર્ગ છે

195
00:11:47,000 --> 00:11:49,000
એક સ્પ્રાઈટ બીજા.

196
00:11:49,000 --> 00:11:52,000
ઉદાહરણ માટે, તમે રમત વહન પર કરી શકો છો,

197
00:11:52,000 --> 00:11:56,000
અને જ્યારે અન્ય સ્પ્રાઈટ રમત પર મેળવે છે,

198
00:11:56,000 --> 00:11:58,000
તે ચોક્કસ રીતે પ્રતિક્રિયા આપે છે.

199
00:11:58,000 --> 00:12:03,000
તે મહત્વનું છે પ્રોગ્રામિંગ માટે સમજી મોડલ છે.

200
00:12:03,000 --> 00:12:07,000
માત્ર આધારભૂત 0 અઠવાડિયું પર જવા માટે, અમે શું બન્યું છે જેથી કરીને અત્યાર સુધી,

201
00:12:07,000 --> 00:12:10,000
ચાલો આ સરળ સી કાર્યક્રમ જુઓ.

202
00:12:10,000 --> 00:12:14,000
લખાણ અહીં થોડું નાના બીટ હોઇ શકે, પણ હું તેની પર જાઓ ખરેખર ઝડપી પડશે.

203
00:12:14,000 --> 00:12:20,000
અમે 2 ટોચ cs50.h, અને stdio.h અંતે હેડર ફાઈલો સહિત રહ્યા છો.

204
00:12:20,000 --> 00:12:23,000
પછી અમે સતત કહેવાય મર્યાદા વ્યાખ્યાયિત કરી રહ્યા છીએ 100 છે.

205
00:12:23,000 --> 00:12:26,000
પછી અમે અમારી મુખ્ય કાર્ય અમલ કરી રહ્યા છીએ.

206
00:12:26,000 --> 00:12:29,000
કારણ કે આપણે આદેશ વાક્ય દલીલો ઉપયોગ કરતા નથી અમે રદબાતલ મુકવાની જરૂર છે

207
00:12:29,000 --> 00:12:32,000
મુખ્ય માટે દલીલો તરીકે.

208
00:12:32,000 --> 00:12:38,000
અમે મુખ્ય ઉપર પૂર્ણાંક જુઓ. કે વળતર પ્રકાર છે, તેથી તળિયે 0 આવો.

209
00:12:38,000 --> 00:12:41,000
અને અમે CS50 પુસ્તકાલય કાર્ય ઉપયોગ કરી રહ્યાં છો પૂર્ણાંક વિચાર

210
00:12:41,000 --> 00:12:45,000
ઇનપુટ માટે વપરાશકર્તા પૂછો, અને અમે તેને આ ચલ x માં સંગ્રહે,

211
00:12:45,000 --> 00:12:51,000
તેથી અમે એક્સ ઉપર જાહેર કરો, અને અમે તેને એક્સ = GetInt સાથે પ્રારંભ.

212
00:12:51,000 --> 00:12:53,000
>> પછી અમે જોવા માટે જો વપરાશકર્તા આપણને સારા ઇનપુટ આપ્યો તપાસો.

213
00:12:53,000 --> 00:12:59,000
જો તે ≥ LIMIT અમે માટે 1 ભૂલ કોડ આવો અને એક ભૂલ સંદેશો છાપો કરવા માંગો છો.

214
00:12:59,000 --> 00:13:02,000
અને છેલ્લે, જો વપરાશકર્તા અમને આપવામાં આવી છે સારું ઇનપુટ

215
00:13:02,000 --> 00:13:08,000
અમે નંબર સ્ક્વેર અને તે પરિણામે છાપી રહ્યા છીએ.

216
00:13:08,000 --> 00:13:11,000
જસ્ટ ખાતરી કરો કે તે તમામ હિટ ઘર

217
00:13:11,000 --> 00:13:17,000
તમે અહીં કોડ વિવિધ ભાગો લેબલો જોઈ શકો છો.

218
00:13:17,000 --> 00:13:19,000
હું સતત, હેડર ફાઈલો ઉલ્લેખ કર્યો છે.

219
00:13:19,000 --> 00:13:21,000
ઓહ, પૂર્ણાંક એક્સ. માટે યાદ રાખો કે એક સ્થાનિક ચલ છે તેની ખાતરી કરો.

220
00:13:21,000 --> 00:13:24,000
કે તે એક વૈશ્વિક ચલ ના વિરોધાભાસ, જે અમે વિશે વાત કરીશું

221
00:13:24,000 --> 00:13:27,000
પાછળથી થોડો સમીક્ષા સત્ર માં,

222
00:13:27,000 --> 00:13:30,000
અને અમે પુસ્તકાલય કાર્ય printf ફોન આવે છે,

223
00:13:30,000 --> 00:13:34,000
તેથી જો આપણે stdio.h હેડર ફાઈલ સમાવેશ થતો નથી કર્યું હતું

224
00:13:34,000 --> 00:13:37,000
અમે printf કહી શકશે નહીં.

225
00:13:37,000 --> 00:13:42,000
અને હું માનું છું કે તીર કે કાપી મળ્યો અહીં% d માટે પોઇન્ટ છે,

226
00:13:42,000 --> 00:13:45,000
જે printf માં ફોર્મેટિંગ શબ્દમાળા છે.

227
00:13:45,000 --> 00:13:52,000
તે કહે છે એક નંબર, ડી% તરીકે આ ચલ છાપો.

228
00:13:52,000 --> 00:13:58,000
અને તે 0 અઠવાડિયું માટે છે.

229
00:13:58,000 --> 00:14:06,000
હવે લુકાસ ચાલુ રાખવા માટે જઈ રહ્યો છે.

230
00:14:06,000 --> 00:14:08,000
અરે, ગાય્સ. મારું નામ લુકાસ છે.

231
00:14:08,000 --> 00:14:10,000
હું કેમ્પસ, માથેર પર શ્રેષ્ઠ ઘર માં અભ્યાસ કરે છું,

232
00:14:10,000 --> 00:14:14,000
અને હું 1 અઠવાડિયું અને 2.1 વિશે થોડુંક વાત જાઉં છું.

233
00:14:14,000 --> 00:14:16,000
[1 અઠવાડિયું અને 2.1!] [લુકાસ Freitas]

234
00:14:16,000 --> 00:14:19,000
તરીકે Lexi જણાવ્યું હતું કે, આવી હતી જ્યારે અમે સ્ક્રેચ માંથી સી તમારી કોડ અનુવાદ શરૂ

235
00:14:19,000 --> 00:14:23,000
એક વસ્તુઓ છે કે જે અમે નોંધ્યું છે કે તમે આ કરી શકો છો ફક્ત નથી કે

236
00:14:23,000 --> 00:14:26,000
તમારો કોડ લખવા અને તેને ચલાવવા માટે એક લીલો ધ્વજ હવે મદદથી.

237
00:14:26,000 --> 00:14:30,000
ખરેખર, તમે અમુક પગલાંઓ ઉપયોગ તમારા સી કાર્યક્રમ બનાવવા હોય

238
00:14:30,000 --> 00:14:33,000
એક્ઝિક્યુટેબલ ફાઇલ બને છે.

239
00:14:33,000 --> 00:14:36,000
મૂળભૂત રીતે તમે જ્યારે તમે કાર્યક્રમ લખી રહ્યાં છે કે શું

240
00:14:36,000 --> 00:14:40,000
તમે એક ભાષા કે જે કમ્પાઇલર સમજી શકે તમારા વિચાર અનુવાદ કરો,

241
00:14:40,000 --> 00:14:44,000
તેથી જ્યારે તમે સી એક કાર્યક્રમ લખી રહ્યાં

242
00:14:44,000 --> 00:14:47,000
તમે શું કરી રહ્યા ખરેખર કંઈક લખવાનું છે કે તમારા કમ્પાઇલર સમજવા રહ્યું છે,

243
00:14:47,000 --> 00:14:50,000
અને પછી કમ્પાઇલર કે કોડ અનુવાદ રહ્યું છે

244
00:14:50,000 --> 00:14:53,000
કંઈક કે જે તમારા કમ્પ્યુટરને સમજશે માં.

245
00:14:53,000 --> 00:14:55,000
>> અને આ વસ્તુ, તમારા કમ્પ્યુટર છે તે ખરેખર ખૂબ મૂક.

246
00:14:55,000 --> 00:14:57,000
તમારા કમ્પ્યુટર માત્ર 0s અને 1 સે સમજી શકે,

247
00:14:57,000 --> 00:15:01,000
તેથી વાસ્તવમાં પ્રથમ કમ્પ્યુટર્સ લોકો સામાન્ય રીતે પ્રોગ્રામ

248
00:15:01,000 --> 00:15:04,000
0s અને 1 સે, પરંતુ હવે વાપરી રહ્યા હોય, ભગવાન આભાર.

249
00:15:04,000 --> 00:15:07,000
અમે 0s અને 1 સે માટે સિક્વન્સ યાદ ન હોય

250
00:15:07,000 --> 00:15:10,000
લૂપ માટે અથવા જ્યારે લૂપ અને તેથી એક છે.

251
00:15:10,000 --> 00:15:13,000
તેથી જ અમે કમ્પાઇલર છે.

252
00:15:13,000 --> 00:15:17,000
કમ્પાઇલર કરે છે શું છે તે મારાથી સી કોડ અનુવાદ કરે છે,

253
00:15:17,000 --> 00:15:21,000
અમારા કિસ્સામાં, એક ભાષા કે જે તમારા કમ્પ્યુટરને સમજી કરશે,

254
00:15:21,000 --> 00:15:25,000
જે પદાર્થ કોડ છે, અને ત્યારે કમ્પાઇલર છે કે અમે ઉપયોગ કરી રહ્યાં છો છે

255
00:15:25,000 --> 00:15:30,000
છે રણકાર કહેવાય છે, તેથી આ ખરેખર રણકાર માટે પ્રતીક છે.

256
00:15:30,000 --> 00:15:33,000
જ્યારે તમે તમારા કાર્યક્રમ છે, તો તમે 2 વસ્તુઓ હોય છે.

257
00:15:33,000 --> 00:15:37,000
પ્રથમ, તમે તમારા કાર્યક્રમ કમ્પાઇલ હોય છે, અને તે પછી તમે તમારા કાર્યક્રમ ચલાવવા જઈ રહ્યાં છો.

258
00:15:37,000 --> 00:15:41,000
તમારા કાર્યક્રમ કમ્પાઇલ તમે વિકલ્પો ઘણાં આવું હોય છે.

259
00:15:41,000 --> 00:15:44,000
પ્રથમ એક રણકાર program.c નથી

260
00:15:44,000 --> 00:15:47,000
જેમાં કાર્યક્રમ તમારા કાર્યક્રમ નામ છે.

261
00:15:47,000 --> 00:15:51,000
આ કિસ્સામાં તમે તેઓ માત્ર કહી રહ્યાં છે જોઈ શકે છે "હેય, મારા કાર્યક્રમ કમ્પાઇલ."

262
00:15:51,000 --> 00:15:56,000
તમે નથી કહેતા કે કંઈપણ "હું મારા કાર્યક્રમ માટે આ નામ માંગો છો" રહ્યા છો.

263
00:15:56,000 --> 00:15:58,000
>> બીજા વિકલ્પ તમારા કાર્યક્રમ માટે એક નામ આપી રહી છે.

264
00:15:58,000 --> 00:16:02,000
તમે રણકાર-o અને પછી એ નામ છે જે તમે કરવા માંગો છો કહી શકીએ

265
00:16:02,000 --> 00:16:06,000
એક્ઝેક્યુટેબલ ફાઈલ તરીકે અને પછી program.c શકાય નામ આપવામાં આવ્યું છે.

266
00:16:06,000 --> 00:16:11,000
અને તમે પણ કાર્યક્રમ બનાવવા શું કરી શકો છો, અને જુઓ પ્રથમ 2 કિસ્સાઓમાં કેવી રીતે

267
00:16:11,000 --> 00:16:15,000
હું મૂકો. કેચ અને ત્રીજી એક હું માત્ર કાર્યક્રમો છે?

268
00:16:15,000 --> 00:16:18,000
અરે વાહ, તમે ખરેખર નથી. કેચ મૂકી જ્યારે તમે બનાવવા ઉપયોગ કરવો જોઈએ.

269
00:16:18,000 --> 00:16:22,000
તો કમ્પાઇલર ખરેખર તમે કિકિયારી રહ્યું છે.

270
00:16:22,000 --> 00:16:24,000
અને પણ, હું જો તમે ગાય્સ યાદ ખબર નહિં હોય,

271
00:16:24,000 --> 00:16:29,000
પરંતુ વખત અમે પણ અથવા એલએમ ઉપયોગ-lcs50 ઘણો.

272
00:16:29,000 --> 00:16:31,000
કે લિંક કહેવામાં આવે છે.

273
00:16:31,000 --> 00:16:35,000
તે માત્ર ત્યારે કમ્પાઇલર કહે છે કે તમે તે લાઈબ્રેરીઓ અધિકાર ત્યાં ઉપયોગ કરશે,

274
00:16:35,000 --> 00:16:39,000
તેથી જો તમે cs50.h ઉપયોગ કરવા માંગો છો તમે ખરેખર લખો હોય

275
00:16:39,000 --> 00:16:43,000
program.c-lcs50 રણકાર.

276
00:16:43,000 --> 00:16:45,000
જો તમે તે નથી, પણ કમ્પાઇલર જાણવા નથી જઈ રહ્યા

277
00:16:45,000 --> 00:16:50,000
કે તમે cs50.h. તે કાર્યો ઉપયોગ કરી રહ્યાં છો

278
00:16:50,000 --> 00:16:52,000
અને જ્યારે તમે તમારા કાર્યક્રમ ચલાવવા માટે તમારે 2 વિકલ્પો છે કરવા માંગો છો.

279
00:16:52,000 --> 00:16:57,000
જો તમે રણકાર program.c કર્યું તમે તમારા કાર્યક્રમ માટે એક નામ આપી ન હતી.

280
00:16:57,000 --> 00:17:01,000
તમે તેને ચલાવવા માટે a.out. / મદદથી હોય છે.

281
00:17:01,000 --> 00:17:06,000
A.out પ્રમાણભૂત નામ કે રણકાર તમારા કાર્યક્રમ આપે છે જો તમે તેને એક નામ આપી નથી.

282
00:17:06,000 --> 00:17:11,000
અન્યથા તમે /. કાર્યક્રમ કરવા જઈ રહ્યાં છો જો તમે તમારી કાર્યક્રમ નામ આપ્યું,

283
00:17:11,000 --> 00:17:15,000
અને પણ જો તમે કાર્યક્રમ નામ ઉપસ્થિત કર્યો હતો કે એક કાર્યક્રમ મેળવવા રહ્યું છે

284
00:17:15,000 --> 00:17:23,000
પહેલાંથી જ આ કેચ ફાઈલ જેવી જ નામ પ્રોગ્રામ હશે.

285
00:17:23,000 --> 00:17:26,000
તો પછી અમે ડેટા પ્રકારો અને માહિતી વિશે વાત કરી.

286
00:17:26,000 --> 00:17:31,000
>> મૂળભૂત માહિતી પ્રકારો થોડું બોક્સ તેઓ વાપરો એ જ વસ્તુ છે

287
00:17:31,000 --> 00:17:35,000
માટે કિંમતો સંગ્રહ, જેથી ડેટા પ્રકારો Pokémons જેમ જ ખરેખર છે.

288
00:17:35,000 --> 00:17:39,000
તેઓ બધા માપો અને પ્રકારો આવે છે.

289
00:17:39,000 --> 00:17:43,000
હું જો કે સાદ્રશ્ય અર્થમાં બનાવે છે ખબર નથી.

290
00:17:43,000 --> 00:17:46,000
આ માહિતી કદ ખરેખર મશીન આર્કીટેક્ચર પર આધાર રાખે છે.

291
00:17:46,000 --> 00:17:49,000
બધા માહિતી માપો કે હું અહીં બતાવવા માટે જાઉં છું

292
00:17:49,000 --> 00:17:53,000
મશીન 32-bit છે, કે જે અમારા સાધન કિસ્સામાં છે ખરેખર છે,

293
00:17:53,000 --> 00:17:56,000
પરંતુ જો તમે ખરેખર તમારા Mac અથવા Windows માં પણ કોડિંગ છે

294
00:17:56,000 --> 00:17:59,000
કદાચ તમે મશીન 64-bit છે જઈ રહ્યાં છો,

295
00:17:59,000 --> 00:18:03,000
જેથી યાદ રાખો કે આ માહિતી માપો કે હું જાઉં છું અહીં બતાવવા માટે

296
00:18:03,000 --> 00:18:06,000
મશીન 32-bit માટે છે.

297
00:18:06,000 --> 00:18:08,000
પ્રથમ એક કે અમે જોયું પૂર્ણાંક હતી,

298
00:18:08,000 --> 00:18:10,000
જે ખૂબ જ સીધું છે.

299
00:18:10,000 --> 00:18:13,000
તમારે એક પૂર્ણાંક સ્ટોર પૂર્ણાંક વાપરો.

300
00:18:13,000 --> 00:18:16,000
અમે પણ અક્ષર છે, ઘરનાં પરચૂરણ કામો થયો છે.

301
00:18:16,000 --> 00:18:20,000
જો તમે અક્ષર અથવા નાની પ્રતીક ઉપયોગ કરવા માંગો છો તો તમે કદાચ એક કોલસો બનાવો ઉપયોગ જઈ રહ્યાં છો.

302
00:18:20,000 --> 00:18:26,000
એ ઘરનાં પરચૂરણ કામો 1 બાઇટ, કે જે Lexi જણાવ્યું હતું કે જેમ 8 બીટ્સ, એનો અર્થ એ થાય છે.

303
00:18:26,000 --> 00:18:31,000
મૂળભૂત રીતે અમે તે ASCII કોષ્ટક કે જે 256 છે પાસે

304
00:18:31,000 --> 00:18:34,000
0s અને 1 સે શક્ય સંયોજનો,

305
00:18:34,000 --> 00:18:37,000
અને પછી જ્યારે તમે ઘરનાં પરચૂરણ કામો લખો તેને અનુવાદિત રહ્યું છે

306
00:18:37,000 --> 00:18:44,000
અક્ષર કે તમે નંબર છે કે જે તમે ASCII કોષ્ટકમાં Lexi જેવા હોય છે ઇનપુટ્સ જણાવ્યું હતું.

307
00:18:44,000 --> 00:18:48,000
અમે પણ ફ્લોટ છે, કે જે અમે અક્ષાંશ નંબરો સ્ટોર કરવા ઉપયોગ કરે છે.

308
00:18:48,000 --> 00:18:53,000
જો તમે 3.14 પસંદ કરો માંગો છો, ઉદાહરણ તરીકે, તમે ફ્લોટ ઉપયોગ જઈ રહ્યાં છો

309
00:18:53,000 --> 00:18:55,000
અથવા ડબલ વધુ ચોકસાઇ ધરાવે છે.

310
00:18:55,000 --> 00:18:57,000
એક ફ્લોટ 4 બાઇટ્સ છે.

311
00:18:57,000 --> 00:19:01,000
એક ડબલ 8 બાઇટ્સ હોય છે, તેથી માત્ર તફાવત એ ચોકસાઇ છે.

312
00:19:01,000 --> 00:19:04,000
અમે પણ લાંબા કે પૂર્ણાંકો માટે વપરાય છે,

313
00:19:04,000 --> 00:19:09,000
અને તમે એક મશીન 32-bit માટે જુઓ પૂર્ણાંક અને લાંબી જ માપ છે,

314
00:19:09,000 --> 00:19:13,000
તેથી તે ખરેખર અર્થમાં નથી એક મશીન 32-bit લાંબા વાપરો.

315
00:19:13,000 --> 00:19:17,000
>> પરંતુ જો તમે મેક અને 64-bit મશીન ઉપયોગ કરી રહ્યાં છો, ખરેખર લાંબા 8 કદ ધરાવે છે,

316
00:19:17,000 --> 00:19:19,000
તેથી તે ખરેખર આર્કીટેક્ચર પર આધાર રાખે છે.

317
00:19:19,000 --> 00:19:22,000
મશીન 32-bit માટે સૂઝ ન બનાવવા માટે લાંબા ખરેખર ઉપયોગ કરતું નથી.

318
00:19:22,000 --> 00:19:25,000
અને પછી લાંબા લાંબા, બીજી બાજુ, 8 બાઇટ્સ હોય છે,

319
00:19:25,000 --> 00:19:30,000
તેથી તે ખૂબ સારી છે જો તમે લાંબા સમય સુધી પૂર્ણાંક માંગો છો.

320
00:19:30,000 --> 00:19:34,000
અને છેલ્લે, અમે શબ્દમાળા હોય છે, જે વાસ્તવમાં એક કોલસો બનાવો * છે,

321
00:19:34,000 --> 00:19:37,000
જે ઘરનાં પરચૂરણ કામો માટે નિર્દેશક છે.

322
00:19:37,000 --> 00:19:40,000
તે ખૂબ જ સરળ છે લાગે છે કે શબ્દમાળા માપ જેવા રહ્યું છે

323
00:19:40,000 --> 00:19:42,000
અક્ષરો નંબર કે તમે ત્યાં છે,

324
00:19:42,000 --> 00:19:45,000
પરંતુ હકીકતમાં ઘરનાં પરચૂરણ કામો * પોતે

325
00:19:45,000 --> 00:19:49,000
ચાર રચે છે, જે 4 બાઇટ્સ છે નિર્દેશક કદ ધરાવે છે.

326
00:19:49,000 --> 00:19:52,000
ચાર રચે છે * કદ 4 બાઇટ્સ છે.

327
00:19:52,000 --> 00:19:56,000
જો તમે નાની શબ્દ અથવા અક્ષર અથવા કંઈપણ હોય તો કોઈ વાંધો નથી.

328
00:19:56,000 --> 00:19:58,000
તે 4 બાઇટ્સ જ હશે.

329
00:19:58,000 --> 00:20:01,000
અમે પણ કાસ્ટિંગ વિશે થોડુંક વિદ્વાન,

330
00:20:01,000 --> 00:20:04,000
જેથી તમે જોઈ શકો છો, જો તમારી પાસે છે, ઉદાહરણ તરીકે, એક કાર્યક્રમ છે કે જે કહે છે

331
00:20:04,000 --> 00:20:08,000
પૂર્ણાંક x 3 = અને પછી printf ("% d", એક્સ / 2)

332
00:20:08,000 --> 00:20:12,000
શું તમે જાણીએ છીએ કે તે શું સ્ક્રીન પર છાપી રહ્યું છે?

333
00:20:12,000 --> 00:20:14,000
>> કોઇકે >> [વિદ્યાર્થીઓ] 2.

334
00:20:14,000 --> 00:20:16,000
1. 1 >>, હા.

335
00:20:16,000 --> 00:20:20,000
જ્યારે તમે / 3 2 કરવું તે 1.5 વિચાર ચાલી રહ્યું છે,

336
00:20:20,000 --> 00:20:24,000
પરંતુ ત્યાર બાદ અમે એક પૂર્ણાંક ઉપયોગ કરી રહ્યા છો તે અક્ષાંશ ભાગ અવગણો ચાલી રહ્યું છે,

337
00:20:24,000 --> 00:20:26,000
અને તમે માટે 1 હોય રહ્યા છીએ.

338
00:20:26,000 --> 00:20:29,000
જો તમે તે થાય, તમે શું કરી શકો છો, દાખલા તરીકે, નથી માંગતા,

339
00:20:29,000 --> 00:20:33,000
છે ફ્લોટ જાહેર વાય = x.

340
00:20:33,000 --> 00:20:40,000
પછી x કે 3 પ્રયત્ન ઉપયોગ હવે વાય માં 3,000 પ્રયત્ન રહ્યું છે.

341
00:20:40,000 --> 00:20:44,000
અને તે પછી તમને વાય / 2 છાપી શકો છો.

342
00:20:44,000 --> 00:20:50,000
ખરેખર, હું એક 2 હોવો જોઈએ. ત્યાં ઉપર.

343
00:20:50,000 --> 00:20:55,000
તે 3.00/2.00 કરી રહ્યું છે,

344
00:20:55,000 --> 00:20:58,000
અને તમે 1.5 વિચાર જઈ રહ્યાં છો.

345
00:20:58,000 --> 00:21:06,000
અને અમે આ .2 f હોય માત્ર અક્ષાંશ ભાગ 2 માં રેખાંશ એકમો માટે કહો.

346
00:21:06,000 --> 00:21:12,000
જો તમે .3 એફ હોય તે ખરેખર 1,500 હોય બનશે.

347
00:21:12,000 --> 00:21:16,000
જો તે 2 તે 1.50 જ હશે.

348
00:21:16,000 --> 00:21:18,000
અમે પણ આ કેસ અહીં છે.

349
00:21:18,000 --> 00:21:22,000
જો તમે ફ્લોટ કરવા એક્સ 3.14 = અને પછી તમે printf એક્સ

350
00:21:22,000 --> 00:21:24,000
તમે 3.14 વિચાર જઈ રહ્યાં છો.

351
00:21:24,000 --> 00:21:29,000
અને જો તમે એક્સ = x ની પૂર્ણાંક,

352
00:21:29,000 --> 00:21:34,000
જે પૂર્ણાંક તરીકે એક્સ સારવાર અર્થ થાય છે અને તમે હવે એક્સ છાપો

353
00:21:34,000 --> 00:21:36,000
તમે 3.00 પાસે જઈ રહ્યાં છો.

354
00:21:36,000 --> 00:21:38,000
એ નથી કે સૂઝ છે?

355
00:21:38,000 --> 00:21:41,000
કારણ કે તમે પ્રથમ પૂર્ણાંક તરીકે રહ્યાં છો એક્સ સારવાર, તેથી તમે રેખાંશ ભાગ અવગણી રહ્યાં છો,

356
00:21:41,000 --> 00:21:45,000
અને પછી તમે એક્સ છાપવા કરી રહ્યાં છો.

357
00:21:45,000 --> 00:21:47,000
અને આખરે, તમે પણ કરી શકો છો,

358
00:21:47,000 --> 00:21:52,000
પૂર્ણાંક એક્સ = 65, અને પછી તમે એક કોલસો બનાવો કેચ = x જાહેર,

359
00:21:52,000 --> 00:21:56,000
અને પછી જો તમે કો છાપી તમે ખરેખર મેળવવા જઈ રહ્યાં છો

360
00:21:56,000 --> 00:21:59,000
એ, જેથી મૂળભૂત શું તમે અહીં કરી રહ્યા છીએ

361
00:21:59,000 --> 00:22:02,000
છે અક્ષર માં પૂર્ણાંક અનુવાદ,

362
00:22:02,000 --> 00:22:05,000
જેમ કે તે ASCII કોષ્ટક કરે છે.

363
00:22:05,000 --> 00:22:08,000
અમે પણ ગણિત ઓપરેટરો વિશે વાત કરી.

364
00:22:08,000 --> 00:22:14,000
તેમાંના મોટા ભાગના ખૂબ સરળ છે, તેથી + +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
અને અમે પણ મોડ, જે 2 નંબરો એક વિભાગ બાકીની છે તે વિશે વાત કરી હતી.

366
00:22:20,000 --> 00:22:23,000
જો તમે 10 3 ઉદાહરણ તરીકે%, છે,

367
00:22:23,000 --> 00:22:27,000
તો એનો અર્થ એ 3 દ્વારા 10 વહેંચી અને બાકીની શું છે?

368
00:22:27,000 --> 00:22:30,000
તે માટે 1 જ હશે, તેથી તે ખરેખર કાર્યક્રમો ઘણો માટે ખૂબ જ ઉપયોગી છે.

369
00:22:30,000 --> 00:22:38,000
Vigenère અને સીઝર માટે હું ખૂબ ખાતરી કરો કે તમે ગાય્સ તમામ મોડ ઉપયોગ છું.

370
00:22:38,000 --> 00:22:43,000
ગણિત ઓપરેટરો વિશે, ખૂબ કાળજી રાખો જ્યારે * અને / સંયોજન.

371
00:22:43,000 --> 00:22:48,000
>> ઉદાહરણ તરીકે, જો તમે (2/3) * 2 તમે શું મેળવવા જવું છે?

372
00:22:48,000 --> 00:22:50,000
[2 વિદ્યાર્થીઓ].

373
00:22:50,000 --> 00:22:54,000
અરે વાહ, 2/2 3 કારણ 1.5 પ્રયત્ન રહ્યું છે,

374
00:22:54,000 --> 00:22:57,000
પરંતુ કારણ કે તમે 2 પૂર્ણાંકો વચ્ચે કામગીરી કરી રહ્યા છીએ

375
00:22:57,000 --> 00:22:59,000
તમે ખરેખર માત્ર રહ્યાં છો માટે 1 ધ્યાનમાં જવાનું,

376
00:22:59,000 --> 00:23:03,000
અને પછી 1 2 * 2 માટે પ્રયત્ન રહ્યું છે, તેથી ખૂબ, ખૂબ કાળજી રાખો

377
00:23:03,000 --> 00:23:07,000
જ્યારે પૂર્ણાંકો સાથે અંકગણિત કરી કારણ કે

378
00:23:07,000 --> 00:23:12,000
તમે 2 કે = 3 કે કિસ્સામાં, વિચાર કરી શકે છે.

379
00:23:12,000 --> 00:23:14,000
અને પણ ખૂબ જ પ્રાધાન્ય વિશે કાળજી રાખો.

380
00:23:14,000 --> 00:23:21,000
તમે સામાન્ય રીતે કૌંસ વાપરવા માટે ખાતરી કરો કે તમે જાણો છો કે તમે શું કરી રહ્યાં છો પ્રયત્ન કરીશું.

381
00:23:21,000 --> 00:23:27,000
કેટલાક ઉપયોગી શોર્ટકટ્સ, અલબત્ત, એક હું + + + + અથવા i = 1 છે

382
00:23:27,000 --> 00:23:30,000
અથવા મદદથી + + =.

383
00:23:30,000 --> 00:23:34,000
કે હું = 1 + કરવાથી તરીકે જ ચીજ છે.

384
00:23:34,000 --> 00:23:39,000
તમે પણ મને કરી શકે છે - અથવા i - 1 =,

385
00:23:39,000 --> 00:23:42,000
જે હું = -1 તરીકે આ જ વાત છે,

386
00:23:42,000 --> 00:23:46,000
કંઈક તમે ગાય્સ આંટીઓ માટે ઘણો ઉપયોગ કરે છે, ઓછામાં ઓછું.

387
00:23:46,000 --> 00:23:52,000
પણ * માટે, જો તમે વાપરવા * = અને જો તમે કરો, ઉદાહરણ તરીકે,

388
00:23:52,000 --> 00:23:57,000
હું * 2 = હું = 2 * જણાવ્યું હતું તે જ વસ્તુ છે,

389
00:23:57,000 --> 00:23:59,000
અને વિભાગ માટે આ જ બાબત.

390
00:23:59,000 --> 00:24:08,000
જો તમે / i = 2 કરવું તે મને = / i 2 તરીકે જ વાત છે.

391
00:24:08,000 --> 00:24:10,000
>> હવે કાર્યો વિશે.

392
00:24:10,000 --> 00:24:13,000
તમે ગાય્સ જોયું કે વિધેયો એ ખૂબ સારો કોડ સેવ વ્યૂહરચના છે

393
00:24:13,000 --> 00:24:16,000
જ્યારે તમે પ્રોગ્રામિંગ કરી રહ્યાં છો, તેથી જો તમે એ જ કાર્ય કરવા માંગો

394
00:24:16,000 --> 00:24:20,000
કોડ ફરીથી અને ફરીથી, કદાચ તમે કાર્ય ઉપયોગ કરવા માંગો છો

395
00:24:20,000 --> 00:24:25,000
માત્ર જેથી તમે નકલ અને અને ફરીથી કોડ પેસ્ટ નથી.

396
00:24:25,000 --> 00:24:28,000
ખરેખર, મુખ્ય કામગીરી છે, અને જ્યારે હું તમને કાર્ય બંધારણ દર્શાવે છે

397
00:24:28,000 --> 00:24:32,000
તમે એ જોવા માટે કે જે ખૂબ સ્પષ્ટ છે જઈ રહ્યાં છો.

398
00:24:32,000 --> 00:24:35,000
અમે પણ કેટલાક પુસ્તકાલયો માંથી વિધેયો વાપરવા માટે,

399
00:24:35,000 --> 00:24:39,000
ઉદાહરણ તરીકે, printf, GetIn છે, કે જે CS50 પુસ્તકાલય છે,

400
00:24:39,000 --> 00:24:43,000
અને toupper જેવા અન્ય કાર્ય કરે છે.

401
00:24:43,000 --> 00:24:46,000
તે બધા વિધેયોને ખરેખર અન્ય લાઈબ્રેરીઓમાં લાગુ પાડવામાં આવે છે,

402
00:24:46,000 --> 00:24:49,000
અને જ્યારે તમે તમારા કાર્યક્રમ ની શરૂઆતમાં તે દામણ ફાઈલોને મૂકવામાં

403
00:24:49,000 --> 00:24:53,000
તમે કહેતા કે તમે મને તે કાર્યો માટે કોડ આપવા કૃપા કરીને કરી શકો છો

404
00:24:53,000 --> 00:24:57,000
તેથી હું તેમને મારી જાતને દ્વારા અમલ નથી?

405
00:24:57,000 --> 00:25:00,000
અને તમે પણ તમારા પોતાના કાર્યો લખી શકો છો, જેથી જ્યારે તમે પ્રોગ્રામિંગ શરૂ

406
00:25:00,000 --> 00:25:04,000
તમે સમજો કે લાઈબ્રેરીઓ બધા વિધેયો કે જે તમને જરૂર નથી.

407
00:25:04,000 --> 00:25:10,000
છેલ્લા pset માટે, ઉદાહરણ તરીકે, અમે ડ્રો, ચઢાઇને, અને લુકઅપ લખ્યું હતું,

408
00:25:10,000 --> 00:25:13,000
અને તે ખૂબ જ ખૂબ જ મહત્વપૂર્ણ છે માટે વિધેયો લખી કરવાનો પ્રયત્ન

409
00:25:13,000 --> 00:25:17,000
કારણ કે તેઓ ઉપયોગી છે, અને અમે તેમને પ્રોગ્રામિંગ તમામ સમય વાપરે છે,

410
00:25:17,000 --> 00:25:19,000
અને તે કોડ ઘણો સાચવે છે.

411
00:25:19,000 --> 00:25:21,000
એક કાર્ય બંધારણ આ છે.

412
00:25:21,000 --> 00:25:24,000
અમે શરૂઆતમાં વળતર પ્રકાર હોય છે. પરત પ્રકાર શું છે?

413
00:25:24,000 --> 00:25:27,000
તે ફક્ત ત્યારે તમારા કાર્ય પર પાછા જઈ રહ્યું છે.

414
00:25:27,000 --> 00:25:29,000
જો તમે ઉદાહરણ માટે એક કાર્ય, કારણદર્શી હોય છે,

415
00:25:29,000 --> 00:25:31,000
કે પૂર્ણાંક એક કારણદર્શી ગણતરી રહ્યું છે,

416
00:25:31,000 --> 00:25:34,000
કદાચ તે એક પૂર્ણાંક પણ પરત ચાલી રહ્યું છે.

417
00:25:34,000 --> 00:25:37,000
પછી પરત પ્રકાર માટે પૂર્ણાંક હોવો રહ્યું છે.

418
00:25:37,000 --> 00:25:41,000
Printf ખરેખર વળતર પ્રકાર રદબાતલ છે

419
00:25:41,000 --> 00:25:43,000
કારણ કે તમે કંઈપણ પરત કરી રહ્યાં છો.

420
00:25:43,000 --> 00:25:45,000
તમે હમણાં જ સ્ક્રીન પર કરી રહ્યાં છો વસ્તુઓ છાપવા

421
00:25:45,000 --> 00:25:48,000
અને કાર્ય પછીથી છોડી.

422
00:25:48,000 --> 00:25:51,000
પછી તમારે કાર્ય કે જે તમે પસંદ કરી શકો છો નું નામ છે.

423
00:25:51,000 --> 00:25:55,000
તમે થોડું વાજબી હોઈ શકે છે, જેમ કે xyz જેવા એક નામ પસંદ કરો નહિં જોઈએ

424
00:25:55,000 --> 00:25:58,000
અથવા x2f જેવા હોય છે.

425
00:25:58,000 --> 00:26:02,000
એક નામ છે જે અર્થમાં બનાવે બનાવવા પ્રયાસ કરો.

426
00:26:02,000 --> 00:26:04,000
>> ઉદાહરણ તરીકે, જો તે કારણદર્શી છે, કારણદર્શી કહો.

427
00:26:04,000 --> 00:26:08,000
જો તે કાર્ય છે કે જે કંઈક દોરવા રહ્યું છે છે નામ, તે દોરે છે.

428
00:26:08,000 --> 00:26:11,000
અને પછી અમે પરિમાણો, જે પણ દલીલો કહેવામાં આવે છે છે,

429
00:26:11,000 --> 00:26:14,000
જે સ્રોતો છે કે જે તમારા કાર્ય જરૂર જેવા છે

430
00:26:14,000 --> 00:26:17,000
તમારો કોડ તેના કાર્ય કરવા માટે.

431
00:26:17,000 --> 00:26:20,000
જો તમે નંબર કારણદર્શી ગણતરી કરવા માંગો છો

432
00:26:20,000 --> 00:26:23,000
કદાચ તમે નંબર હોય ફેક્ટોરિયલ ગણતરી કરવાની જરૂર છે.

433
00:26:23,000 --> 00:26:27,000
એક દલીલો કે તમે જઈ રહ્યાં છો સંખ્યા પોતે છે.

434
00:26:27,000 --> 00:26:31,000
અને પછી તેને કંઈક અને અંતે કિંમત પાછી ચાલી રહ્યું છે

435
00:26:31,000 --> 00:26:35,000
જ્યાં સુધી તે રદબાતલ કાર્ય છે.

436
00:26:35,000 --> 00:26:37,000
ચાલો એક ઉદાહરણ જુઓ.

437
00:26:37,000 --> 00:26:40,000
જો હું કોઇ કાર્ય કે પૂર્ણાંકો ઝાકઝમાળ બધી સંખ્યાઓ જણાવે લખવા માંગો છો,

438
00:26:40,000 --> 00:26:43,000
સૌ પ્રથમ, પરત પ્રકાર માટે પૂર્ણાંક હોવો રહ્યું છે

439
00:26:43,000 --> 00:26:46,000
કારણ કે હું પૂર્ણાંકો ઝાકઝમાળ છે.

440
00:26:46,000 --> 00:26:51,000
અને પછી હું sumArray જેમ કાર્ય નામ પણ જાઉં છું,

441
00:26:51,000 --> 00:26:54,000
અને પછી તે એરે પોતે લઇ રહ્યું છે તે પૂર્ણાંક nums માટે,

442
00:26:54,000 --> 00:26:58,000
અને પછી એરે તેથી મને ખબર છે કેટલા નંબરો હું સંક્ષેપમાં હોય લંબાઈ.

443
00:26:58,000 --> 00:27:02,000
પછી હું ઉદાહરણ માટે એક ચલ કહેવાય સરવાળો, 0 થી, પ્રારંભ છે,

444
00:27:02,000 --> 00:27:08,000
અને દર વખતે હું એરે એક તત્વ જુઓ હું તે રકમ ઉમેરવા, જેથી કરીશું હું લૂપ માટે એક હતી.

445
00:27:08,000 --> 00:27:15,000
જેમ Lexi જણાવ્યું હતું કે, તમે આમ પૂર્ણાંક હું = 0, i <લંબાઈ i અને + +.

446
00:27:15,000 --> 00:27:20,000
અને એરે દરેક તત્વ માટે હું રકમ + + = nums [i] હતી,

447
00:27:20,000 --> 00:27:24,000
અને પછી હું રકમ પરત છે, તેથી તે ખૂબ જ સરળ છે, અને તે કોડ ઘણો બચાવે છે

448
00:27:24,000 --> 00:27:28,000
જો તમે આ કાર્ય સમય ઘણો ઉપયોગ કરી રહ્યાં છો.

449
00:27:28,000 --> 00:27:32,000
તો પછી અમે શરતો પર એક નજર લીધો હતો.

450
00:27:32,000 --> 00:27:38,000
અમે જો કે, એ હોય છે, અને બીજું જો.

451
00:27:38,000 --> 00:27:42,000
ચાલો શું તે વચ્ચેનો તફાવત છે.

452
00:27:42,000 --> 00:27:45,000
આ 2 કોડ પર એક નજર. તેમની વચ્ચે શું તફાવત છે?

453
00:27:45,000 --> 00:27:49,000
પ્રથમ એક મૂળભૂત છે કોડ્સ કે જે તમે કહો કરવા માંગો છો

454
00:27:49,000 --> 00:27:51,000
, અથવા 0 - જો નંબર + છે.

455
00:27:51,000 --> 00:27:55,000
પ્રથમ એક કહે છે, જો તે 0> છે પછી તે હકારાત્મક છે.

456
00:27:55,000 --> 00:28:00,000
જો તે 0 થી = છે પછી તેને 0 છે, અને જો તે 0 <છે પછી તે નકારાત્મક છે.

457
00:28:00,000 --> 00:28:04,000
>> અને અન્ય એક જો કે, એ જો, બીજું કરવાનું છે.

458
00:28:04,000 --> 00:28:07,000
બંને વચ્ચે આ તફાવત એ છે કે આ એક ખરેખર રહ્યું છે

459
00:28:07,000 --> 00:28:13,000
તપાસો જો> 0, <= 0 0 અથવા ત્રણ વખત,

460
00:28:13,000 --> 00:28:17,000
તેથી જો તમે 2 નંબર હોય છે, ઉદાહરણ તરીકે, તે માટે અહીં આવે છે અને કહે છે ચાલી રહ્યું છે

461
00:28:17,000 --> 00:28:21,000
(x 0>) જો, અને તે માટે હા કહી રહ્યું છે, જેથી હું સકારાત્મક છાપો.

462
00:28:21,000 --> 00:28:25,000
પરંતુ છતાં પણ મને ખબર છે કે તે 0> છે અને તે માટે 0 0 અથવા <ન ચાલી રહ્યું છે

463
00:28:25,000 --> 00:28:29,000
હું હજુ પણ કરવા જઈ રહ્યો છું તે 0 છે, તે છે <0,

464
00:28:29,000 --> 00:28:33,000
તેથી હું ખરેખર IFS ની અંદર જઈ રહ્યો છું કે હું ન હતી

465
00:28:33,000 --> 00:28:38,000
કારણ કે હું પહેલેથી જ ખબર છે કે તે આ શરતો કોઇ પણ સંતુષ્ટ નથી ચાલી રહ્યું છે.

466
00:28:38,000 --> 00:28:41,000
હું જો વાપરવા માટે, બીજું તો, બીજું નિવેદન.

467
00:28:41,000 --> 00:28:45,000
તે વાસ્તવમાં કહે જો એક્સ = 0 હું સકારાત્મક છાપો.

468
00:28:45,000 --> 00:28:48,000
જો તે નથી, હું પણ આ પરીક્ષણ જાઉં છું.

469
00:28:48,000 --> 00:28:51,000
જો તે 2 છે આ નથી છું હું જાઉં.

470
00:28:51,000 --> 00:28:54,000
મૂળભૂત રીતે જો હું x = 2 હતી તમે કહ્યું

471
00:28:54,000 --> 00:28:57,000
જો (x 0>), હા, તેથી આ છાપો.

472
00:28:57,000 --> 00:29:00,000
હવે મને ખબર છે કે તે 0> છે અને તે જો પ્રથમ સંતુષ્ટ

473
00:29:00,000 --> 00:29:02,000
હું પણ આ કોડ ચાલી નથી જવું છું.

474
00:29:02,000 --> 00:29:09,000
આ કોડ વધુ ઝડપથી ચાલે છે, વાસ્તવમાં, 3 ગણો ઝડપી જો તમે આ વાપરો.

475
00:29:09,000 --> 00:29:11,000
અમે પણ અને અને અથવા શીખ્યા.

476
00:29:11,000 --> 00:29:15,000
હું આ મારફતે જાઓ કારણ કે Lexi પહેલેથી જ તેમને વિશે વાત કરી નથી માંગવાનો.

477
00:29:15,000 --> 00:29:17,000
તે ફક્ત જે && અને | | ઓપરેટર.

478
00:29:17,000 --> 00:29:21,000
>> આ જ વસ્તુ હું કહી શકશો છે સાવચેત રહો જ્યારે તમે 3 શરતો હોય છે.

479
00:29:21,000 --> 00:29:24,000
કૌંસ વાપરો કારણ કે તે ખૂબ જ ગૂંચવણમાં છે જ્યારે તમે શરત છે

480
00:29:24,000 --> 00:29:27,000
અને અન્ય એક કે એક અન્ય.

481
00:29:27,000 --> 00:29:30,000
કૌંસ વાપરો ફક્ત ખાતરી કરો કે તમારી શરતો અર્થમાં બનાવવા પ્રયત્ન કરવા માટે

482
00:29:30,000 --> 00:29:34,000
કારણ કે તે કિસ્સામાં, ઉદાહરણ તરીકે, તમે કલ્પના કરી શકો છો કે

483
00:29:34,000 --> 00:29:38,000
તે પ્રથમ શરત અને એક અથવા બીજા હોઈ શકે છે

484
00:29:38,000 --> 00:29:41,000
અથવા 2 એક સંયુક્ત શરતો અને

485
00:29:41,000 --> 00:29:45,000
અથવા ત્રીજા એક છે, તેથી માત્ર ખૂબ કાળજી રાખો.

486
00:29:45,000 --> 00:29:48,000
અને છેલ્લે, અમે સ્વીચો વિશે વાત કરી.

487
00:29:48,000 --> 00:29:53,000
એક સ્વીચ ખૂબ ઉપયોગી છે જ્યારે તમે એક ચલ હોય છે.

488
00:29:53,000 --> 00:29:55,000
હવે કહો કે તમે n જેમ એક ચલ છે

489
00:29:55,000 --> 00:29:59,000
કે 0, 1, અથવા 2 હોઈ શકે છે, અને તે કેસ દરેક

490
00:29:59,000 --> 00:30:01,000
તમે કાર્ય કરવા જઈ રહ્યાં છો.

491
00:30:01,000 --> 00:30:04,000
તમે ચલ સ્વિચ કહેવું શકે છે, અને તે સૂચવે છે કે

492
00:30:04,000 --> 00:30:08,000
મૂલ્ય પછી મૂલ્ય 1 જેમ હું આ કરવા જઈ રહ્યો છું,

493
00:30:08,000 --> 00:30:12,000
અને પછી હું ભાંગી નાંખે છે, જેનો અર્થ થાય છે હું અન્ય કિસ્સાઓમાં કોઇ પણ જોવા નથી માંગવાનો

494
00:30:12,000 --> 00:30:15,000
કારણ કે અમે પહેલાથી જ તે કેસ સંતુષ્ટ

495
00:30:15,000 --> 00:30:20,000
અને પછી VALUE2 અને તેથી, હું અને પણ મૂળભૂત સ્વીચ કરી શકે છે.

496
00:30:20,000 --> 00:30:24,000
તેનો અર્થ એ કે જો તે કિસ્સાઓમાં કે હું હતો કોઇ સંતોષ નથી

497
00:30:24,000 --> 00:30:29,000
કે હું કંઈક બીજું કરવા જાઉં છું, પરંતુ તે વૈકલ્પિક છે.

498
00:30:29,000 --> 00:30:36,000
તે મારા માટે બધા છે. હવે આપણે ટોમી છે.

499
00:30:36,000 --> 00:30:41,000
તમામ હક, આ 3-ઇશ અઠવાડિયું પ્રયત્ન રહ્યું છે.

500
00:30:41,000 --> 00:30:45,000
આ વિષયો અમે આવરી લેતી આવશે ક્રિપ્ટો, અવકાશ, એરે વગેરે એટ, અમુક છે.

501
00:30:45,000 --> 00:30:49,000
જસ્ટ ક્રિપ્ટો પર ઝડપી શબ્દ. અમે આ ઘર ખૂબ મહેનત નથી જઈ રહ્યાં છો.

502
00:30:49,000 --> 00:30:52,000
>> અમે 2 pset આવું કર્યું, પરંતુ ક્વિઝ માટે ખાતરી કરો કે તમે તફાવત ખબર બનાવવા

503
00:30:52,000 --> 00:30:54,000
સીઝર સાઇફર અને Vigenère સાઇફર વચ્ચે,

504
00:30:54,000 --> 00:30:57,000
કેવી રીતે તે ciphers વર્ક બંને અને તે શું એનક્રિપ્ટ જેવું છે

505
00:30:57,000 --> 00:30:59,000
અને ડિક્રિપ્ટ તે 2 ciphers ઉપયોગ કરીને ટેક્સ્ટ.

506
00:30:59,000 --> 00:31:03,000
યાદ રાખો, સીઝર સાઇફર માત્ર સમાન રકમ દ્વારા દરેક અક્ષર ફરે છે,

507
00:31:03,000 --> 00:31:06,000
ખાતરી કરો કે તમે મોડ મૂળાક્ષરમાંથી અક્ષરોને સંખ્યા દ્વારા બનાવે છે.

508
00:31:06,000 --> 00:31:09,000
અને Vigenère સાઇફર, તો બીજી બાજુ, દરેક અક્ષર ફરે છે

509
00:31:09,000 --> 00:31:12,000
વિવિધ જથ્થો દ્વારા, તેથી તેના બદલે કહેતા કરતાં

510
00:31:12,000 --> 00:31:15,000
3 Vigenère દ્વારા દરેક અક્ષર ફેરવાય દરેક અક્ષર ફેરવવા કરશે

511
00:31:15,000 --> 00:31:17,000
વિવિધ કેટલીક કીવર્ડ પર આધાર રાખીને જથ્થો દ્વારા

512
00:31:17,000 --> 00:31:20,000
જ્યાં મુખ્ય શબ્દ દરેક અક્ષર કેટલાક વિવિધ જથ્થો પ્રતિનિધિત્વ

513
00:31:20,000 --> 00:31:26,000
દ્વારા સ્પષ્ટ લખાણ ફેરવવા.

514
00:31:26,000 --> 00:31:28,000
માતાનો ચલ અવકાશ વિશે પ્રથમ ચર્ચા દો.

515
00:31:28,000 --> 00:31:30,000
ત્યાં વેરિયેબલ્સ 2 અલગ અલગ પ્રકારના હોય છે.

516
00:31:30,000 --> 00:31:33,000
અમે સ્થાનિક ચલો હોય છે, અને આ માટે વ્યાખ્યાયિત કરી રહ્યા છે

517
00:31:33,000 --> 00:31:36,000
બહાર મુખ્ય છે, અથવા કોઇ કાર્ય અથવા બ્લોક બહાર,

518
00:31:36,000 --> 00:31:39,000
અને આ સુલભ તમારા કાર્યક્રમ ગમે ત્યાં હશે.

519
00:31:39,000 --> 00:31:41,000
જો તમે એક કાર્ય છે અને કાર્ય એક જ્યારે લૂપ છે

520
00:31:41,000 --> 00:31:44,000
મોટા વૈશ્વિક ચલ સુલભ દરેક જગ્યાએ છે.

521
00:31:44,000 --> 00:31:48,000
એક સ્થાનિક ચલ, તો બીજી બાજુ, એવી જગ્યા છે જ્યાં તેને વ્યાખ્યાયિત કરવામાં આવે છે માટે scoped છે.

522
00:31:48,000 --> 00:31:53,000
>> જો તમે એક કાર્ય અહીં હોય છે, ઉદાહરણ તરીકે, અમે આ કાર્ય ત હોય છે,

523
00:31:53,000 --> 00:31:56,000
અને જી ની અંદર ત્યાં અહીં એક ચલ વાય કહેવાય છે,

524
00:31:56,000 --> 00:31:58,000
અને તે અર્થ એ થાય કે આ એક સ્થાનિક ચલ છે.

525
00:31:58,000 --> 00:32:00,000
આમ છતાં આ ચલ વાય કહેવાય છે

526
00:32:00,000 --> 00:32:03,000
અને આ ચલ આ 2 વિધેયો વાય કહેવાય છે

527
00:32:03,000 --> 00:32:06,000
આ બોલ પર કોઈ વિચાર દરેક અન્ય સ્થાનિક ચલો શું હોય છે.

528
00:32:06,000 --> 00:32:10,000
બીજી તરફ, અહીં આપણે પૂર્ણાંક એક્સ 5 = કહે,

529
00:32:10,000 --> 00:32:12,000
અને આ કોઇ કાર્ય દાયરાની બહાર છે.

530
00:32:12,000 --> 00:32:16,000
તે મુખ્ય દાયરાની બહાર છે, તેથી આ એક વૈશ્વિક ચલ છે.

531
00:32:16,000 --> 00:32:20,000
કે આ 2 વિધેયો કે અંદર અર્થ થાય છે જ્યારે હું એક્સ કહે છે - અથવા એક્સ + +

532
00:32:20,000 --> 00:32:26,000
હું જ એક્સ જેમાં આ વાય અને આ પિ અલગ ચલો છે ઍક્સેસ છું.

533
00:32:26,000 --> 00:32:30,000
કે વૈશ્વિક ચલ અને સ્થાનિક ચલ વચ્ચે તફાવત છે.

534
00:32:30,000 --> 00:32:33,000
જ્યાં સુધી ડિઝાઈન ચિંતા છે, ક્યારેક તે કદાચ વધુ સારી રીતે વિચાર છે

535
00:32:33,000 --> 00:32:37,000
માટે ચલો સ્થાનિક રાખવા જ્યારે તમે કદાચ કરી શકો છો

536
00:32:37,000 --> 00:32:39,000
કર્યા ત્યારથી વૈશ્વિક ચલો સમૂહ ખરેખર ગૂંચવણમાં મેળવી શકો છો.

537
00:32:39,000 --> 00:32:42,000
જો તમે વિધેયો સમૂહ છે જે ત્રણેય એક જ વસ્તુ ફેરફાર

538
00:32:42,000 --> 00:32:45,000
તમે શું જો આ કાર્ય આકસ્મિક આ વૈશ્વિક સુધારે ભૂલી જાઓ છો,

539
00:32:45,000 --> 00:32:47,000
અને આ અન્ય કાર્ય તે વિશે ખબર નથી,

540
00:32:47,000 --> 00:32:50,000
અને તે સારુ ગૂંચવણમાં વિચાર કરતો નથી, કારણ તમે વધુ કોડ મેળવો.

541
00:32:50,000 --> 00:32:53,000
ચલો સ્થાનિક રાખવા જ્યારે તમે કદાચ કરી શકો છો

542
00:32:53,000 --> 00:32:56,000
માત્ર સારી ડિઝાઇન છે.

543
00:32:56,000 --> 00:33:00,000
એરે, યાદ રાખો, માત્ર છે તે જ પ્રકારની તત્વો યાદીઓ છે.

544
00:33:00,000 --> 00:33:04,000
સી ની અંદર 2.0 1, જેમ યાદી નથી, હેલ્લો કરી શકો છો.

545
00:33:04,000 --> 00:33:06,000
અમે હમણાં જ ન કરી શકે છે.

546
00:33:06,000 --> 00:33:11,000
>> જ્યારે અમે સી એક એરે જાહેર રીતે બધા તત્વો જ પ્રકારની હોય છે.

547
00:33:11,000 --> 00:33:14,000
અહીં હું 3 પૂર્ણાંકો ઝાકઝમાળ છે.

548
00:33:14,000 --> 00:33:18,000
અહીં હું એરે લંબાઈ ધરાવે છે, પરંતુ જો હું ફક્ત આ વાક્યરચના માં છું તે જાહેર

549
00:33:18,000 --> 00:33:21,000
જ્યાં હું સ્પષ્ટ રીતે બધા તત્વો કયા છે હું ટેકનિકલી આ 3 કરવાની જરૂર નથી.

550
00:33:21,000 --> 00:33:25,000
આ કમ્પાઈલર પૂરતી સ્માર્ટ બહાર આકૃતિ મોટું કેવી રીતે અરે હોવો જોઇએ.

551
00:33:25,000 --> 00:33:28,000
હવે જ્યારે હું વિચાર અથવા એરે ની કિંમત સુયોજિત કરવા માંગો છો

552
00:33:28,000 --> 00:33:30,000
આ તે શું વાક્યરચના છે.

553
00:33:30,000 --> 00:33:33,000
આ વાસ્તવમાં એરે બીજા તત્વ સુધારવા કારણ કે યાદ કરશે,

554
00:33:33,000 --> 00:33:36,000
નંબર 0 પર શરૂ થાય છે, નહિં કે 1 ખાતે.

555
00:33:36,000 --> 00:33:42,000
જો હું તે કિંમત વાંચી માંગો છો હું કંઈક કહી શકો પૂર્ણાંક એક્સ એરે = [1].

556
00:33:42,000 --> 00:33:44,000
અથવા જો હું તે કિંમત સુયોજિત કરવા માંગો છો, જેમ કે હું અહીં કરી રહ્યો છું,

557
00:33:44,000 --> 00:33:47,000
હું એરે [1] કહી શકો = 4.

558
00:33:47,000 --> 00:33:50,000
કે તેમના ઇન્ડેક્સ દ્વારા તત્વો ઍક્સેસ સમય

559
00:33:50,000 --> 00:33:52,000
અથવા તેમની સ્થિતિ અથવા તેઓ એરે છે જ્યાં,

560
00:33:52,000 --> 00:33:57,000
અને તે યાદી 0 અંતે શરૂ થાય છે.

561
00:33:57,000 --> 00:34:00,000
અમે પણ એરે હારમાળાઓનો હોઇ શકે છે,

562
00:34:00,000 --> 00:34:03,000
અને આ એરે બહુ આયામી કહેવામાં આવે છે.

563
00:34:03,000 --> 00:34:05,000
જ્યારે અમે એરે બહુ આયામી છે

564
00:34:05,000 --> 00:34:07,000
તેનો અર્થ એ કે અમે પંક્તિઓ અને કૉલમ્સ કંઈક હોઇ શકે છે,

565
00:34:07,000 --> 00:34:11,000
અને આ ફક્ત આ દ્રશ્યાત્મક અથવા તેના વિશે વિચારવાનો એક રીત છે.

566
00:34:11,000 --> 00:34:14,000
જ્યારે હું એક એરે બહુ આયામી હોય તેનો અર્થ એ કે હું જરૂર શરૂ જાઉં છું

567
00:34:14,000 --> 00:34:17,000
1 કરતાં વધુ અનુક્રમણિકા કારણ કે જો હું ગ્રિડ છે

568
00:34:17,000 --> 00:34:19,000
કહેતા પંક્તિ શું તમે છો અમને ફક્ત એક નંબર આપતું નથી.

569
00:34:19,000 --> 00:34:22,000
કે ખરેખર માત્ર છે અમને નંબરોની યાદી આપવા જઈ રહી છે.

570
00:34:22,000 --> 00:34:25,000
હવે કહો કે હું આ એરે અહીં છે.

571
00:34:25,000 --> 00:34:30,000
હું ગ્રિડ કહેવામાં આવે એરે હોય છે, અને હું તે 2 પંક્તિઓ અને 3 કૉલમ કહી રહ્યો છું,

572
00:34:30,000 --> 00:34:32,000
અને તેથી આ તે દ્રશ્યાત્મક કરવાની એક રીત છે.

573
00:34:32,000 --> 00:34:37,000
જ્યારે હું કહું છું હું [1] ખાતે તત્વ મેળવવા માંગો છો [2]

574
00:34:37,000 --> 00:34:41,000
કે અર્થ એ છે કે કારણ કે આ પંક્તિઓ પ્રથમ અને પછી કૉલમ છે

575
00:34:41,000 --> 00:34:44,000
હું 1 પંક્તિ થી હું 1 જણાવ્યું હતું કે કૂદી જાઉં છું.

576
00:34:44,000 --> 00:34:49,000
>> પછી હું ઉપર 2 સ્તંભ અહીં આવવા જાઉં છું, અને હું કિંમત 6 વિચાર જાઉં છું.

577
00:34:49,000 --> 00:34:51,000
અર્થમાં બનાવીએ?

578
00:34:51,000 --> 00:34:55,000
મલ્ટી પરિમાણીય એરે, યાદ રાખો, જે ટેકનિકલી માત્ર એરે ઝાકઝમાળ છે.

579
00:34:55,000 --> 00:34:57,000
અમે એરે હારમાળાઓનો હારમાળાઓનો હોઈ શકે છે.

580
00:34:57,000 --> 00:35:00,000
અમે ચાલુ રાખવામાં શકે છે, પરંતુ વિશે ખરેખર એક રસ્તો લાગે છે

581
00:35:00,000 --> 00:35:03,000
આ કેવી રીતે બહાર આવી રહી નાખ્યો છે અને શું થઈ રહ્યું છે તે માટે તેને નિહાળવાની છે

582
00:35:03,000 --> 00:35:09,000
આ જેવી ગ્રીડ છે.

583
00:35:09,000 --> 00:35:12,000
જ્યારે અમે કાર્યો એરે પસાર કરવા માટે, તેઓ વર્તે જઈ રહ્યાં છો

584
00:35:12,000 --> 00:35:16,000
જ્યારે અમે વિધેયો માટે નિયમિત ચલો પસાર કરતાં થોડી અલગ બીટ

585
00:35:16,000 --> 00:35:18,000
પૂર્ણાંક અથવા ફ્લોટ પસાર જેવા હોય છે.

586
00:35:18,000 --> 00:35:21,000
જ્યારે અમે પૂર્ણાંક અથવા ઘરનાં પરચૂરણ કામો અથવા આ અન્ય માહિતી કોઈપણ પ્રકારના પાસ

587
00:35:21,000 --> 00:35:24,000
અમે ફક્ત જો કાર્ય સુધારે જોતા હતા

588
00:35:24,000 --> 00:35:28,000
કે ચલની કિંમત કે ફેરફાર કરવા માટે પ્રસરણ નથી જઈ રહ્યા

589
00:35:28,000 --> 00:35:32,000
આ ફોન કામ કરવું.

590
00:35:32,000 --> 00:35:35,000
ઝાકઝમાળ સાથે, બીજી બાજુ, કે શું થશે.

591
00:35:35,000 --> 00:35:39,000
જો હું એક એરે કેટલાક કાર્ય પસાર અને તે કાર્ય તત્વો કેટલાક બદલે,

592
00:35:39,000 --> 00:35:43,000
જ્યારે હું પાછળ કાર્ય કરે છે કે તે કહેવાય આવવા

593
00:35:43,000 --> 00:35:47,000
મારા એરે હવે અલગ હોઈ રહ્યું છે, અને તે માટે શબ્દભંડોળ

594
00:35:47,000 --> 00:35:50,000
છે એરે સંદર્ભ દ્વારા પસાર કરવામાં આવે છે, કારણ કે અમે પાછળથી જોશો.

595
00:35:50,000 --> 00:35:53,000
આ પોઇન્ટર, કેવી રીતે કામ કરે છે આ મૂળભૂત જ્યાં ડેટા પ્રકારો સાથે સંબંધિત છે,

596
00:35:53,000 --> 00:35:55,000
બીજી બાજુ, કિંમત દ્વારા પસાર થાય છે.

597
00:35:55,000 --> 00:35:59,000
>> અમે કે કેટલાક ચલ નકલ બનાવે છે અને પછી નકલ માં પસાર વિચાર કરી શકો છો.

598
00:35:59,000 --> 00:36:01,000
તે તો કોઈ વાંધો નથી કે આપણે શું ચલ સાથે કામ કરે છે.

599
00:36:01,000 --> 00:36:06,000
આ ફોન કાર્ય ધ્યાન રાખો કે તેમાં ફેરફાર કરવામાં આવ્યો હતો રહેશે નહીં.

600
00:36:06,000 --> 00:36:10,000
એરે થોડી કે સંદર્ભે અલગ અલગ બીટ છે.

601
00:36:10,000 --> 00:36:13,000
ઉદાહરણ તરીકે, આપણે માત્ર જોયું, મુખ્ય ફક્ત એક કાર્ય છે

602
00:36:13,000 --> 00:36:15,000
કે 2 દલીલો લઇ શકે છે.

603
00:36:15,000 --> 00:36:20,000
મુખ્ય કામ કરવા માટે પ્રથમ દલીલ argc, અથવા દલીલોની સંખ્યા છે,

604
00:36:20,000 --> 00:36:23,000
અને બીજી દલીલ argv કહે છે,

605
00:36:23,000 --> 00:36:27,000
અને તે તે દલીલોને વાસ્તવિક કિંમતો છે.

606
00:36:27,000 --> 00:36:30,000
હવે કહો કે હું this.c નામના પ્રોગ્રામ હોય,

607
00:36:30,000 --> 00:36:34,000
અને હું કહું છું આ કરવા માટે, અને હું આદેશ વાક્ય પર આ સ્કોર જાઉં છું.

608
00:36:34,000 --> 00:36:38,000
હવે કેટલીક દલીલો મારી કાર્યક્રમ પસાર આ કહે છે,

609
00:36:38,000 --> 00:36:42,000
હું કંઈક જેમ કહેવું / હોઇ શકે છે. આ 50 cs છે.

610
00:36:42,000 --> 00:36:45,000
આ આપણે શું ડેવિડ કરવું દરેક દિવસ કલ્પના ટર્મિનલ પર.

611
00:36:45,000 --> 00:36:48,000
પરંતુ હવે તે કાર્યક્રમની મુખ્ય કાર્ય અંદર

612
00:36:48,000 --> 00:36:52,000
આ કિંમતો છે, તેથી argc 4 છે.

613
00:36:52,000 --> 00:36:56,000
તે થોડો ગૂંચવણમાં મૂકે એવો છે કારણ કે ખરેખર અમે માત્ર 50 cs છે પસાર કરી રહ્યાં છો શકે છે.

614
00:36:56,000 --> 00:36:58,000
કે માત્ર 3.

615
00:36:58,000 --> 00:37:02,000
યાદ પરંતુ argv પ્રથમ તત્વ અથવા પ્રથમ દલીલ

616
00:37:02,000 --> 00:37:05,000
આ કાર્ય પોતાના નામ છે.

617
00:37:05,000 --> 00:37:07,190
જેથી અર્થ એ છે કે અમે 4 વસ્તુઓ અહીં હોય છે,

618
00:37:07,190 --> 00:37:10,530
અને પ્રથમ તત્વ માટે /. આ પ્રયત્ન રહ્યું છે.

619
00:37:10,530 --> 00:37:12,970
અને આ શબ્દમાળા તરીકે રજૂ કરવામાં આવશે.

620
00:37:12,970 --> 00:37:18,590
પછી બાકીના તત્વો હોય છે, આપણે શું કાર્યક્રમના નામ પછી લખ્યો.

621
00:37:18,590 --> 00:37:22,720
તેથી જ કોરે એક, કારણ કે અમે કદાચ 2 pset માં થયો હતો,

622
00:37:22,720 --> 00:37:28,780
યાદ રાખો કે જે 50 શબ્દમાળા પૂર્ણાંક 50 ≠ છે.

623
00:37:28,780 --> 00:37:32,520
તેથી અમે કંઈક કહી શકો છો 'પૂર્ણાંક = x 3 argv.'

624
00:37:32,520 --> 00:37:36,470
>> કે જે હમણાં જ ચાલી રહ્યું છે, નથી અર્થમાં બનાવવા કારણ કે આ એક સ્ટ્રિંગ છે, અને આ એક પૂર્ણાંક છે.

625
00:37:36,470 --> 00:37:38,510
તેથી જો તમે 2 વચ્ચે રૂપાંતરિત કરવા માંગો છો, યાદ રાખો, અમે જઈ રહ્યાં છો

626
00:37:38,510 --> 00:37:40,810
આ જાદુ atoi કહેવાય કાર્ય છે.

627
00:37:40,810 --> 00:37:46,270
કે જે શબ્દમાળા લે છે અને કે જેઓ શબ્દમાળા ની અંદર રજૂ પૂર્ણાંક આપે છે.

628
00:37:46,270 --> 00:37:48,360
જેથી એક સરળ ભૂલ છે એ ક્વિઝ પર બનાવે છે,

629
00:37:48,360 --> 00:37:51,590
માત્ર વિચારીને કે આ આપોઆપ યોગ્ય પ્રકાર હશે.

630
00:37:51,590 --> 00:37:53,860
પરંતુ માત્ર ખબર છે કે આ હંમેશા શબ્દમાળાઓ હશે

631
00:37:53,860 --> 00:38:00,920
પણ જો શબ્દમાળા માત્ર એક પૂર્ણાંક અથવા એક અક્ષર અથવા ફ્લોટ સમાવે છે.

632
00:38:00,920 --> 00:38:03,380
તેથી હવે આપણે સમય ચાલી વિશે વાત કરો.

633
00:38:03,380 --> 00:38:06,700
, જ્યારે અમે આ બધા ગાણિતીક નિયમો છે કે આ બધા ઉન્મત્ત વસ્તુઓ હોય છે

634
00:38:06,700 --> 00:38:11,580
તે ખરેખર ઉપયોગી બની જાય છે પ્રશ્ન પૂછો, "કેટલા તેઓ લે છે?"

635
00:38:11,580 --> 00:38:15,500
અમે અનંત સ્પર્શી નોટેશનમાં કહેવાય કંઈક સાથે પ્રતિનિધિત્વ કરે છે.

636
00:38:15,500 --> 00:38:18,430
તેથી આ અર્થ એ છે કે છે - દો, કહો કે અમે અમારા અલગોરિધમ આપી

637
00:38:18,430 --> 00:38:20,840
કેટલાક ખરેખર, ખરેખર, ખરેખર મોટી ઇનપુટ.

638
00:38:20,840 --> 00:38:23,840
અમે પ્રશ્ન પૂછવા માગો છો, "લાંબા તે કેવી રીતે લાગી રહ્યું છે?

639
00:38:23,840 --> 00:38:26,370
કેટલી પગલાંઓ તે અમારી અલ્ગોરિધમનો લેવા માટે રન કરશે

640
00:38:26,370 --> 00:38:29,980
ઇનપુટ કદ એક કાર્ય તરીકે? "

641
00:38:29,980 --> 00:38:33,080
જેથી પ્રથમ આપણી સ્કોર સમય વર્ણન કરી શકે મોટું ઓ સાથે છે

642
00:38:33,080 --> 00:38:35,380
અને આ અમારી ચાલતા સૌથી ખરાબ કેસ સમય છે.

643
00:38:35,380 --> 00:38:38,590
તેથી જો આપણે એક એરે સૉર્ટ કરવા માંગો છો, અને અમે અમારી અલ્ગોરિધમનો ઝાકઝમાળ આપી

644
00:38:38,590 --> 00:38:41,000
કે ઉતરતા ક્રમમાં છે જ્યારે તે ચડતા ક્રમમાં હોવી જોઈએ,

645
00:38:41,000 --> 00:38:43,130
કે ખરાબ કેસ જ હશે.

646
00:38:43,130 --> 00:38:49,800
આ અમારી સમય અમારા અલગોરિધમ લેશે મહત્તમ લંબાઈ બંધાયેલ ઉપર છે.

647
00:38:49,800 --> 00:38:54,740
બીજી તરફ, આ Ω માટે શ્રેષ્ઠ કેસ ચાલી સમય વર્ણન રહ્યું છે.

648
00:38:54,740 --> 00:38:58,210
તેથી જો અમે સૉર્ટ અલ્ગોરિધમનો માટે પહેલાથી જ છટણી એરે આપે છે,

649
00:38:58,210 --> 00:39:00,940
લાંબા તે કેવી રીતે તેને સૉર્ટ લઇ જશે?

650
00:39:00,940 --> 00:39:06,610
અને આ, તો પછી, ઓછા સમય ચાલી પર બાઉન્ડ વર્ણવે છે.

651
00:39:06,610 --> 00:39:10,980
અહીં માત્ર કેટલાક શબ્દો અમુક સામાન્ય ચાલી વખત વર્ણન છે.

652
00:39:10,980 --> 00:39:13,120
આ ક્રમમાં હોય છે.

653
00:39:13,120 --> 00:39:16,060
સૌથી ઝડપી સમય ચાલી અમે સતત કહેવાય છે.

654
00:39:16,060 --> 00:39:19,800
>> કે કોઈ બાબત કેટલી તત્વો અમારી અલ્ગોરિધમનો આપી અર્થ થાય છે,

655
00:39:19,800 --> 00:39:22,280
કોઈ બાબત મોટી કેવી રીતે અમારી વ્યૂહરચના છે, તે સૉર્ટ

656
00:39:22,280 --> 00:39:26,510
અથવા કરવાનું ગમે અમે એરે માટે કરી રહ્યા હંમેશા સમય જ જથ્થો લેશે.

657
00:39:26,510 --> 00:39:30,270
તેથી અમે 1 એક છે, જે સતત હોય છે, સાથે જ કે પ્રતિનિધિત્વ કરી શકે છે.

658
00:39:30,270 --> 00:39:32,410
અમે પણ લઘુગુણકીય રન સમયે હતા.

659
00:39:32,410 --> 00:39:34,800
તેથી દ્વિસંગી શોધ કંઈક લઘુગુણકીય છે,

660
00:39:34,800 --> 00:39:37,140
જ્યાં અમે દરેક અડધા સમયમાં સમસ્યા કાપી

661
00:39:37,140 --> 00:39:40,970
અને પછી વસ્તુઓ માત્ર ત્યાંથી ઊંચી છે.

662
00:39:40,970 --> 00:39:43,580
અને જો તમે ક્યારેય કોઈ કારણદર્શી ગાણિતીક અમને એક ઓ લખી,

663
00:39:43,580 --> 00:39:47,850
તમે કદાચ આ તમારા દિવસ કામ નથી આપવું જોઈએ.

664
00:39:47,850 --> 00:39:53,910
જ્યારે આપણે ચાલી વખત તુલના તે મહત્વપૂર્ણ છે ધ્યાનમાં આ વસ્તુઓ રાખો.

665
00:39:53,910 --> 00:39:57,760
તેથી જો હું અલ્ગોરિધમનો કે ઓ (એન), અને બીજા કોઈને હોય છે

666
00:39:57,760 --> 00:40:03,590
છે ઓ એક એલ્ગોરિધમ (2n) આ ખરેખર છે asymptotically સમકક્ષ.

667
00:40:03,590 --> 00:40:06,590
તેથી જો આપણે અબજ eleventy જેવી મોટી સંખ્યા હોવી n કલ્પના:

668
00:40:06,590 --> 00:40:13,090
તેથી જ્યારે અમે અબજ eleventy અબજ eleventy કંઈક + + 3 સાથે સરખામણી કરી રહ્યા છો,

669
00:40:13,090 --> 00:40:17,640
અચાનક કે +3 ખરેખર એક મોટા તફાવત હવે નથી.

670
00:40:17,640 --> 00:40:20,980
તેથી જ અમે આ બધી વસ્તુઓ સમકક્ષ આવે શરૂ રહ્યા છીએ.

671
00:40:20,980 --> 00:40:24,220
આ સ્થિરાંકો જેમ અહીં વસ્તુઓ તેથી, ત્યાં 2 આ એક્સ છે, અથવા 3 એક ઉમેરીને,

672
00:40:24,220 --> 00:40:27,180
આ ફક્ત સ્થિરાંકો, અને આ કરવા માટે ડ્રોપ જતાં હોય છે.

673
00:40:27,180 --> 00:40:32,480
તેથી કે કેમ આ રન વખત તમામ 3 કહે છે કે તેઓ ઓ (એન) છો તરીકે જ છે.

674
00:40:32,480 --> 00:40:37,490
તેવી જ રીતે, જો આપણે 2 અન્ય રન જોવાયા છે, ચાલો કહેવું ઓ (n + ચોરસ 2n ³), અમે ઉમેરી શકો છો

675
00:40:37,490 --> 00:40:42,070
+ N એ, 7 +, અને પછી અમે અન્ય રન સમય કે જે હમણાં જ ઓ છે (n ³) હોય છે.

676
00:40:42,070 --> 00:40:46,290
ફરીથી, આ જ વસ્તુ છે કારણ કે આ - આ જ નથી.

677
00:40:46,290 --> 00:40:49,840
આ જ વસ્તુઓ છે, માફ કરશો. તેથી આ જ છે કારણ કે

678
00:40:49,840 --> 00:40:53,090
આ n ³ આ 2n ચોરસ પર પ્રભુત્વ રહ્યું છે.

679
00:40:53,090 --> 00:40:59,130
>> છે તો શું આપણે (n ³ O) અને O જેવા વખત ચાલે છે તે જ વસ્તુ નથી (ચોરસ એન)

680
00:40:59,130 --> 00:41:02,820
કારણ કે આ n ³ ખૂબ આ n ચોરસ કરતાં પણ મોટો છે.

681
00:41:02,820 --> 00:41:05,470
તેથી જો આપણે પ્રતિનિધિઓ હોય છે, અચાનક આ બાબતના શરૂ કરે છે,

682
00:41:05,470 --> 00:41:08,280
પરંતુ જ્યારે અમે પરિબળો સાથે કામ કરી રહ્યાં છે કારણ કે અમે અહીં છે,

683
00:41:08,280 --> 00:41:12,810
પછી તેને વાંધો નથી કારણ કે તેઓ માત્ર છોડી જતા નથી ચાલી રહ્યું છે.

684
00:41:12,810 --> 00:41:16,760
ચાલો એવા ગાણિતીક નિયમો કેટલાક અમે અત્યાર સુધીમાં જોયેલા પર એક નજર

685
00:41:16,760 --> 00:41:19,260
અને તેમના રન સમય વિશે વાત કરો.

686
00:41:19,260 --> 00:41:23,850
યાદીમાં નંબર શોધી પ્રથમ માર્ગ, કે જે આપણે જોયું, રેખીય શોધ હતી.

687
00:41:23,850 --> 00:41:26,950
અને લીનીયર શોધ અમલીકરણ સુપર સીધું છે.

688
00:41:26,950 --> 00:41:30,490
અમે હમણાં જ એક યાદી હોય છે, અને અમે યાદીમાં દરેક એક તત્વ જોવા જઈ રહ્યાં છો

689
00:41:30,490 --> 00:41:34,260
ત્યાં સુધી અમે નંબર શોધવા અમે શોધી રહ્યાં છે.

690
00:41:34,260 --> 00:41:38,370
જેથી અર્થ એ છે કે સૌથી ખરાબ કિસ્સામાં, આ ઓ (n).

691
00:41:38,370 --> 00:41:40,860
અને સૌથી ખરાબ અહીં કેસ જો તત્વ છે હોઈ શકે છે

692
00:41:40,860 --> 00:41:45,710
છેલ્લું તત્વ હતું, તે પછી લાઇનર શોધ મદદથી અમે દરેક એક તત્વ જોવા હોય

693
00:41:45,710 --> 00:41:50,180
ત્યાં સુધી અમે છેલ્લા એક મેળવવા માટે ક્રમમાં ખબર છે કે તે યાદીમાં વાસ્તવમાં હતી.

694
00:41:50,180 --> 00:41:52,910
, અમે હમણાં હાફવે આપી શકે છે અને કહે છે "તે કદાચ ત્યાં નથી."

695
00:41:52,910 --> 00:41:55,980
રેખીય શોધ સાથે અમે સમગ્ર બાબત જોવા મળે છે.

696
00:41:55,980 --> 00:41:59,090
આ ચાલી રહેલ શ્રેષ્ઠ કેસ વખતે, બીજી બાજુ, સતત હોય છે,

697
00:41:59,090 --> 00:42:04,200
કારણ કે શ્રેષ્ઠ કિસ્સામાં તત્વ અમે શોધી રહ્યાં છો તે ફક્ત યાદીમાં પ્રથમ છે.

698
00:42:04,200 --> 00:42:08,930
તેથી તે અમને ચોક્કસ પગલાં 1, કોઈ બાબત મોટી કેવી રીતે યાદી છે લાગી રહ્યું છે

699
00:42:08,930 --> 00:42:12,140
જો અમે પ્રથમ તત્વ માટે દર વખતે જોઈ રહ્યા છો.

700
00:42:12,140 --> 00:42:15,390
>> તેથી જ્યારે તમે શોધવા માટે, યાદ રાખો, તે જરૂરી નથી કે અમારા યાદી અલગ કરવામાં આવે છે.

701
00:42:15,390 --> 00:42:19,430
કારણ કે અમે ફક્ત દરેક એક તત્વ જોશે જઈ રહ્યાં છો, અને તે ખરેખર તો કોઈ વાંધો નથી

702
00:42:19,430 --> 00:42:23,560
હુકમ શું છે તે તત્વો સાઇન છે

703
00:42:23,560 --> 00:42:28,110
વધુ બુદ્ધિશાળી શોધ અલ્ગોરિધમનો દ્વિસંગી શોધ કંઈક છે.

704
00:42:28,110 --> 00:42:31,500
યાદ રાખો, દ્વિસંગી શોધ અમલીકરણ છે જ્યારે તમે જઈ રહ્યાં છો

705
00:42:31,500 --> 00:42:34,320
યાદીમાં મધ્યમ જોઈ રાખો.

706
00:42:34,320 --> 00:42:38,000
અને કારણ કે અમે મધ્યમ અંતે શોધી રહ્યાં છો, તો અમે જરૂર છે કે જે યાદી સૉર્ટ થાય છે

707
00:42:38,000 --> 00:42:40,580
બીજું કે અમે જ્યાં મધ્યમ નથી જાણતા હોય, તો અને અમે જોશે છે

708
00:42:40,580 --> 00:42:44,480
સમગ્ર તેને શોધવા માટે યાદી અને પછી તે સમયે અમે ફક્ત સમય બરબાદ કરી રહ્યા છીએ.

709
00:42:44,480 --> 00:42:48,480
તેથી જો અમે છટણી યાદી હોય છે અને અમે મધ્યમ શોધવા માટે, અમે મધ્યમ સરખાવવા જઈ રહ્યાં છો

710
00:42:48,480 --> 00:42:51,590
તત્વ માટે અમે શોધી રહ્યાં છે.

711
00:42:51,590 --> 00:42:54,640
જો કે તે ખૂબ ઊંચા છે, તે પછી અમે અધિકાર અડધા ભૂલી શકે

712
00:42:54,640 --> 00:42:57,810
કારણ કે આપણે જાણીએ છીએ કે જો અમારી તત્વ પહેલેથી જ છે પણ ઊંચા

713
00:42:57,810 --> 00:43:01,080
અને આ તત્વ જમણી બધું પણ ઊંચા છે,

714
00:43:01,080 --> 00:43:02,760
પછી અમે ત્યાં હવે જોવા જરૂર નથી.

715
00:43:02,760 --> 00:43:05,430
જ્યાં બીજી બાજુ, જો અમારા તત્વ ખૂબ ઓછી છે,

716
00:43:05,430 --> 00:43:08,700
આપણે જાણીએ છીએ કે તત્વ ડાબી બધું પણ ખૂબ ઓછી,

717
00:43:08,700 --> 00:43:11,390
તેથી તે ખરેખર ત્યાં જોવા અર્થમાં નથી ક્યાં,.

718
00:43:11,390 --> 00:43:15,760
આ રીતે, દરેક અને યાદીના અંતે મિડપોઇન્ટ દર વખતે આપણે જોવા પગલાં સાથે,

719
00:43:15,760 --> 00:43:19,060
અમે અડધા અમારી સમસ્યા કાપી જઈ રહ્યાં છો કારણ કે અચાનક આપણે જાણીએ છીએ

720
00:43:19,060 --> 00:43:23,040
નંબરો કે એક અમે શોધી રહ્યાં છો તે ન હોઈ શકે સંપૂર્ણ જથ્થો.

721
00:43:23,040 --> 00:43:26,950
>> સ્યુડોકોડનો આ કંઈક આના જેવી હો,

722
00:43:26,950 --> 00:43:30,990
અને કારણ કે અમે દરેક અડધા જ સમય માં યાદી કાપવા કરી રહ્યાં છો,

723
00:43:30,990 --> 00:43:34,920
અમારા ખરાબ કેસ રન રેખીય માંથી લઘુગુણકીય સમય જમ્પ.

724
00:43:34,920 --> 00:43:39,260
તેથી અચાનક અમારી પાસે લોગ ઈન પગલાંઓ ક્રમમાં યાદીમાં એક તત્વ શોધવા માટે બનાવવા માટે.

725
00:43:39,260 --> 00:43:42,460
આ ચાલી રહેલ શ્રેષ્ઠ કેસ સમય, જોકે, હજુ પણ છે સતત

726
00:43:42,460 --> 00:43:45,180
કારણ કે હવે, ચાલો માત્ર કહે છે કે તત્વ અમે શોધી રહ્યાં છો છે

727
00:43:45,180 --> 00:43:48,380
હંમેશા મૂળ યાદી ચોક્કસ મધ્યમ.

728
00:43:48,380 --> 00:43:52,080
તેથી અમે મોટું કારણ કે અમે માંગો છો તરીકે અમારી યાદી વધવા શકે છે, પરંતુ જો તત્વ અમે શોધી રહ્યાં છો તે મધ્યમાં છે,

729
00:43:52,080 --> 00:43:54,910
પછી તેને માત્ર અમને 1 પગલાં ચાલી રહ્યું છે.

730
00:43:54,910 --> 00:44:00,920
તેથી કે શા માટે આપણે (લોગ એન) ઓ અને (1) Ω અથવા સતત છો.

731
00:44:00,920 --> 00:44:04,510
ચાલો ખરેખર આ સૂચિ પર દ્વિસંગી શોધ ચલાવો.

732
00:44:04,510 --> 00:44:08,020
તેથી આપણે કહેવું કે અમને 164 તત્વ શોધી રહ્યાં છે.

733
00:44:08,020 --> 00:44:11,650
પ્રથમ વસ્તુ અમે કરવા જઇ રહ્યા છે અને આ યાદીમાં મિડપોઇન્ટ શોધો.

734
00:44:11,650 --> 00:44:15,060
તે જ થાય છે કે મિડપોઇન્ટ આ 2 નંબરો વચ્ચે પડવું રહ્યું છે,

735
00:44:15,060 --> 00:44:18,960
તેથી આપણે માત્ર આપખુદ કહેતા, દરેક સમયે મિડપોઇન્ટ 2 નંબરો વચ્ચે પડે છે,

736
00:44:18,960 --> 00:44:21,150
ચાલો માત્ર ગિરફતારી.

737
00:44:21,150 --> 00:44:24,330
અમે હમણાં જ ખાતરી કરવા માટે અમે આ રીતે દરેક પગલું શું કરવાની જરૂર છે.

738
00:44:24,330 --> 00:44:29,040
તેથી અમે ગિરફતારી જઈ રહ્યાં છો, અને અમે કહે છે કે 161 અમારા યાદી મધ્યમાં છે જઈ રહ્યાં છો.

739
00:44:29,040 --> 00:44:34,640
161 તેથી <164, અને 161 ડાબી દરેક તત્વ

740
00:44:34,640 --> 00:44:39,120
પણ 164 <છે, તેથી આપણે જાણીએ છીએ કે તે અમને તમામ અંતે મદદ નથી ચાલી રહ્યું છે

741
00:44:39,120 --> 00:44:42,690
પર અહીં જોઈ પ્રારંભ તત્વ કારણ કે અમે પ્રયત્ન નથી કરી શકો છો શોધી રહ્યાં છે.

742
00:44:42,690 --> 00:44:47,060
તેથી અમે શું કરી શકો છો છે અમે ફક્ત યાદી છે કે સમગ્ર ડાબી અડધા ભૂલી શકો,

743
00:44:47,060 --> 00:44:51,700
અને હવે માત્ર 161 આગળ જમણી ના વિચારો.

744
00:44:51,700 --> 00:44:54,050
>> તેથી ફરીથી, આ મિડપોઇન્ટ છે; ચાલો માત્ર ગિરફતારી.

745
00:44:54,050 --> 00:44:56,260
હવે 175 ખૂબ મોટી છે.

746
00:44:56,260 --> 00:44:59,180
તેથી આપણે જાણીએ છીએ તે અમને અહીં અથવા અહીં જોઈ મદદ નથી ચાલી રહ્યું છે,

747
00:44:59,180 --> 00:45:06,610
તેથી અમે માત્ર કે દૂર ફેંકવા શકે છે, અને છેવટે અમે 164 તો ફટકો પડશે.

748
00:45:06,610 --> 00:45:10,560
દ્વિસંગી શોધ પર કોઈપણ પ્રશ્ન છે?

749
00:45:10,560 --> 00:45:14,180
ચાલો એક પહેલેથી જ છટણી યાદી મારફતે શોધ માંથી પર ખસેડો

750
00:45:14,180 --> 00:45:17,660
ખરેખર કોઈપણ ક્રમમાં નંબરોની યાદી લેતી

751
00:45:17,660 --> 00:45:20,960
અને ચડતા ક્રમમાં છે કે જે યાદીમાં બનાવે છે.

752
00:45:20,960 --> 00:45:24,060
પ્રથમ અલ્ગોરિધમનો અમે અંતે જોવામાં બબલ સૉર્ટ તરીકે ઓળખાતું હતું.

753
00:45:24,060 --> 00:45:27,300
અને આ એલ્ગોરિધમ્સ આપણે જોયું સરળ હશે.

754
00:45:27,300 --> 00:45:32,970
બબલ સૉર્ટ કહે છે કે જ્યારે યાદી અંદર કોઇ 2 તત્વો સ્થળ બહાર છે,

755
00:45:32,970 --> 00:45:36,500
જેનો અર્થ થાય છે ત્યાં નીચા નંબર ડાબી ઊંચી સંખ્યા છે,

756
00:45:36,500 --> 00:45:40,190
તો પછી અમે તેમને સ્વેપ જઈ રહ્યાં છો, કારણ કે તે અર્થ એ થાય કે યાદી હશે

757
00:45:40,190 --> 00:45:42,860
"સોર્ટ વધુ" કરતાં પહેલાં હતી.

758
00:45:42,860 --> 00:45:45,180
અને અમે હમણાં જ આ પ્રક્રિયા ફરીથી ચાલુ રાખવા જઈ રહ્યાં છો અને ફરી ફરી

759
00:45:45,180 --> 00:45:52,100
ત્યાં સુધી છેવટે તેમના યોગ્ય સ્થાન માટે બબલ ના તત્વો પ્રકારની છે અને આપણે છટણી યાદી હોય છે.

760
00:45:52,100 --> 00:45:57,230
>> આ સમય રન O એ પ્રયત્ન રહ્યું છે (n ²) હતું. શા માટે?

761
00:45:57,230 --> 00:46:00,370
વેલ, સૌથી ખરાબ કિસ્સામાં કારણ કે, અમે દરેક તત્વ લઈ જઈ રહ્યાં છો, અને

762
00:46:00,370 --> 00:46:04,570
અમે અંત તે યાદી દરેક અન્ય તત્વ સાથે સરખામણી રહ્યા છીએ.

763
00:46:04,570 --> 00:46:08,030
પરંતુ શ્રેષ્ઠ કિસ્સામાં, અમે પહેલાથી જ છટણી યાદી હોય છે, પરપોટો સૉર્ટ હિસ્સો

764
00:46:08,030 --> 00:46:12,230
માત્ર જઈને એક મારફતે જાઓ, કહેવું "ના હું કોઈપણ અદલબદલ શકતા નથી., તેથી હું પૂર્ણ છું."

765
00:46:12,230 --> 00:46:17,410
તેથી અમે એક શ્રેષ્ઠ કેસ Ω (એન) ના ચાલી સમય હોય છે.

766
00:46:17,410 --> 00:46:20,680
ચાલો એક યાદી પર બબલ સૉર્ટ ચલાવો.

767
00:46:20,680 --> 00:46:23,560
અથવા પ્રથમ, ચાલો માત્ર કેટલાક સ્યુડોકોડનો અંતે ખરેખર ઝડપથી જુઓ.

768
00:46:23,560 --> 00:46:28,160
અમે કહી અમે ટ્રેક ના લૂપ દરેક ઇટરેશન રાખવા માંગો છો માંગો છો,

769
00:46:28,160 --> 00:46:32,190
કે શું નથી અથવા અમે કોઈ તત્વો બદલાઈ ટ્રૅક રાખો.

770
00:46:32,190 --> 00:46:37,610
છે કે કારણ તેથી, અમે રોકવા જ્યારે અમે કોઈપણ ઘટકો નથી સ્વૅપ છે જઈ રહ્યાં છો.

771
00:46:37,610 --> 00:46:41,980
તેથી અમારા લૂપ શરૂઆતમાં અમે કંઈપણ સ્વૅપ છે, તેથી અમે કહીએ છીએ પડશે કે ખોટા છે.

772
00:46:41,980 --> 00:46:47,170
હવે, અમે યાદી મારફતે જાઓ અને તત્વ તુલના હું તત્વ હું + 1 માટે જઈ રહ્યાં છો

773
00:46:47,170 --> 00:46:50,310
અને જો તે કેસ એ છે કે ત્યાં એક નાના નંબર ડાબી મોટા સંખ્યા છે,

774
00:46:50,310 --> 00:46:52,310
તો પછી અમે માત્ર તેમને સ્વેપ રહ્યા છીએ.

775
00:46:52,310 --> 00:46:54,490
>> અને પછી અમે યાદ રાખો કે અમે એક તત્વ સ્વૅપ રહ્યા છીએ.

776
00:46:54,490 --> 00:46:58,900
એટલે કે અમે આ યાદી મારફતે ઓછામાં ઓછા વધુ 1 વખત જવાની જરૂર

777
00:46:58,900 --> 00:47:02,160
કારણ કે આ પરિસ્થિતિ કે જેમાં આપણે અટકાવી છે જ્યારે સમગ્ર યાદી પહેલાથી જ છટણી કરવામાં આવે છે,

778
00:47:02,160 --> 00:47:04,890
જેનો અર્થ અમે કોઈ અદલબદલ નથી કર્યા છે.

779
00:47:04,890 --> 00:47:09,960
જેથી શા માટે અમારી સ્થિતિ નીચે અહીં છે છે 'જ્યારે કેટલાક તત્વો સ્વૅપ કરવામાં આવી છે.'

780
00:47:09,960 --> 00:47:13,720
તેથી હવે આપણે ફક્ત આ યાદી પર ચાલી જુઓ.

781
00:47:13,720 --> 00:47:16,640
હું 5,0,1,6,4 યાદી હોય છે.

782
00:47:16,640 --> 00:47:19,850
બબલ સૉર્ટ ડાબી પર તમામ માર્ગ શરૂ થઈ રહ્યું છે, અને તે તુલના રહ્યું છે

783
00:47:19,850 --> 00:47:24,700
આઇ તત્વો છે, તેથી 0 થી મને + 1, કે જે 1 તત્વ છે.

784
00:47:24,700 --> 00:47:29,020
તે કહે છે, 5 સારી> 0 ચાલી રહ્યું છે, પરંતુ હમણાં 5 ડાબી તરફ હોય છે,

785
00:47:29,020 --> 00:47:32,500
તેથી હું 5 અને 0 સ્વેપ કરવાની જરૂર છે.

786
00:47:32,500 --> 00:47:35,470
જ્યારે હું તેમને સ્વેપ અચાનક હું આ અલગ યાદી મળે છે.

787
00:47:35,470 --> 00:47:38,260
5 હવે 1> છે, તેથી અમે તેમને સ્વેપ રહ્યા છીએ.

788
00:47:38,260 --> 00:47:42,160
5 6> નથી, તેથી અમે કંઈપણ અહીં જરૂર નથી.

789
00:47:42,160 --> 00:47:46,690
પરંતુ 6 4> છે, તેથી અમે સ્વેપ કરવાની જરૂર છે.

790
00:47:46,690 --> 00:47:49,740
ફરીથી, અમે સમગ્ર આખરે શોધવામાં યાદી મારફતે રન કરવા પડે છે

791
00:47:49,740 --> 00:47:52,330
કે આ હુકમ બહાર છે; અમે તેમને સ્વેપ

792
00:47:52,330 --> 00:47:57,120
અને આ બિંદુએ અમે યાદી મારફતે 1 વધુ સમય ચાલે જરૂર

793
00:47:57,120 --> 00:48:05,390
ખાતરી કરવા માટે કે બધું તેના ક્રમમાં છે, અને આ બિંદુ બબલ સૉર્ટ અંતે સમાપ્ત થઈ ગઈ છે તેની ખાતરી કરો.

794
00:48:05,390 --> 00:48:10,720
કેટલાક ઘટકોને લઈને તેમને સોર્ટિંગ કરવા માટે એક અલગ અલ્ગોરિધમનો પસંદગી જેવું છે.

795
00:48:10,720 --> 00:48:15,740
પસંદગી સૉર્ટ પાછળ વિચાર છે કે અમે આ યાદી એક છટણી ભાગ બિલ્ડ જઈ રહ્યાં છો

796
00:48:15,740 --> 00:48:18,150
એક સમયે 1 તત્વ.

797
00:48:18,150 --> 00:48:23,170
>> અને જે રીતે અમે તે કરવા જઈ રહ્યાં છો અપ યાદી ડાબી સેગમેન્ટમાં મકાન છે.

798
00:48:23,170 --> 00:48:27,510
અને મૂળભૂત, દરેક - દરેક પગલાં પર, અમે નાના તત્વ અમે બાકી લેવા જઈ રહ્યાં છો

799
00:48:27,510 --> 00:48:32,310
કે હજુ સુધી કરવામાં આવી નથી છટણી છે, અને અમે તે છટણી સેગમેન્ટમાં ખસેડો રહ્યા છીએ.

800
00:48:32,310 --> 00:48:35,850
તેનો અર્થ એ કે અમે સતત લઘુત્તમ ક્રમમાંગોઠવાયેલનથી તત્વ શોધવાની જરૂર

801
00:48:35,850 --> 00:48:40,720
અને પછી તે ન્યૂનતમ તત્વ ભરે છે અને તેને ગમે સાથે સ્વેપ

802
00:48:40,720 --> 00:48:45,090
બાકી સૌથી તત્વ કે છૂટાં પાડવામાં આવે છે.

803
00:48:45,090 --> 00:48:50,890
આ સ્કોર સમય O એ પ્રયત્ન રહ્યું છે (ચોરસ એન) કારણ કે ખરાબ કિસ્સામાં

804
00:48:50,890 --> 00:48:55,070
અમે દરેક અન્ય તત્વ માટે દરેક એક તત્વ તુલના કરવાની જરૂર છે.

805
00:48:55,070 --> 00:48:59,250
કારણ કે અમે કહી રહ્યાં છે કે જો આપણે આ યાદીમાં ડાબી અડધા શરૂ થાય છે, આપણે જરૂર

806
00:48:59,250 --> 00:49:02,970
સમગ્ર અધિકાર સેગમેન્ટમાં મારફતે પસાર થવા માટે નાના તત્વ શોધો.

807
00:49:02,970 --> 00:49:05,430
અને પછી ફરી, અમે પર સમગ્ર અધિકાર સેગમેન્ટમાં જાઓ અને જરૂર

808
00:49:05,430 --> 00:49:08,210
ઉપર અને ઉપર અને ઉપર ઉપર કે જઈને ફરીથી રાખો.

809
00:49:08,210 --> 00:49:11,350
કે એન ચોરસ જ હશે. અમે બીજી લૂપ માટે લૂપ અંદર માટે જરૂર જઈ રહ્યાં છો

810
00:49:11,350 --> 00:49:13,350
જે n ચોરસ સૂચવે છે.

811
00:49:13,350 --> 00:49:16,530
શ્રેષ્ઠ કેસ વિચારોમાં દો, કહો કે અમે તેને પહેલાથી જ છટણી યાદી આપે છે;

812
00:49:16,530 --> 00:49:19,270
અમે ખરેખર n ચોરસ કરતાં કોઇ વધુ સારી રીતે નથી કરતી.

813
00:49:19,270 --> 00:49:21,730
કારણ કે પસંદગી સૉર્ટ જાણીને કે કોઇ માર્ગ હોય છે

814
00:49:21,730 --> 00:49:25,540
લઘુત્તમ તત્વ માત્ર એક હું જોઈ શકાય થાય છે.

815
00:49:25,540 --> 00:49:28,970
તે હજુ પણ ખાતરી કરો કે આ ખરેખર લઘુત્તમ છે જરૂર છે.

816
00:49:28,970 --> 00:49:31,670
>> અને માત્ર તેની ખાતરી કરવા માટે કે જે તે ન્યૂનતમ જ, આ અલ્ગોરિધમનો ઉપયોગ કરીને રસ્તો,

817
00:49:31,670 --> 00:49:34,640
માટે દરેક એક તત્વ અંતે ફરીથી જુઓ.

818
00:49:34,640 --> 00:49:38,420
ખરેખર તેથી, જો તમે તેને આપી - જો તમે પસંદગી સૉર્ટ પહેલાથી છટણી યાદી આપવા માટે,

819
00:49:38,420 --> 00:49:42,720
તે તેને યાદી છે કે જે હજુ સુધી નથી સૉર્ટ થાય છે આપવા કરતા કોઇ પણ સારી રીતે નથી ચાલી રહ્યું છે.

820
00:49:42,720 --> 00:49:46,320
જો કે, જો તે કેસ બને છે કે કંઈક ઓ (કંઈક હોય)

821
00:49:46,320 --> 00:49:50,640
અને કંઈક આ ઓમેગા, અમે માત્ર વધારે સંક્ષિપ્તમાં કે તે વસ્તુની θ છે કહી શકીએ.

822
00:49:50,640 --> 00:49:52,760
તેથી જો તમે જુઓ છો કે જે ક્યાંય પણ આવે છે, કે છે કે શું માત્ર થાય છે.

823
00:49:52,760 --> 00:49:57,580
>> જો કંઈક n ના થીટા છે ચોરસ છે, તે બન્ને મોટા (ચોરસ n O) અને Ω (ચોરસ એન) છે.

824
00:49:57,580 --> 00:49:59,790
શ્રેષ્ઠ કેસ અને ખરાબમાં ખરાબ કિસ્સામાં, જેથી તે તફાવત નથી,

825
00:49:59,790 --> 00:50:04,400
અલગોરિધમ એ જ વસ્તુ દર વખતે આવું રહ્યું છે.

826
00:50:04,400 --> 00:50:06,610
તેથી આ છે પસંદગી સૉર્ટ માટે સ્યુડોકોડનો શું દેખાશે શકે છે.

827
00:50:06,610 --> 00:50:10,630
અમે મૂળભૂત રીતે કહેવું કે હું ઉપર યાદી પર ફરી વળવું માંગો છો જઈ રહ્યાં છો

828
00:50:10,630 --> 00:50:15,180
જમણી અને લૂપ દરેક ઇટરેશન પર ડાબેથી, હું ખસેડવા જાઉં છું

829
00:50:15,180 --> 00:50:19,780
આ યાદીમાં આ છટણી ભાગ માં લઘુત્તમ તત્વ.

830
00:50:19,780 --> 00:50:23,260
અને એકવાર હું કંઈક ત્યાં, હું ક્યારેય તે તત્વ અંતે ફરીથી જુઓ.

831
00:50:23,260 --> 00:50:28,600
કારણ કે વહેલી તકે હું માં યાદી ડાબી સેગમેન્ટમાં એક તત્વ સ્વેપ, તે છટણી છે

832
00:50:28,600 --> 00:50:32,600
કારણ કે અમે ન્યૂનતમ ઉપયોગ કરીને ચડતા ક્રમમાં બધું કરી રહ્યા છીએ.

833
00:50:32,600 --> 00:50:38,740
તેથી અમે જણાવ્યું હતું કે, ઠીક, અમે હું પદ પર છો, અને અમે આગળ બધા તત્વો જોવાની જરૂર

834
00:50:38,740 --> 00:50:42,260
i ની જમણી કરવા માટે ન્યૂનતમ શોધો.

835
00:50:42,260 --> 00:50:46,150
તેથી તેનો અર્થ એ કે અમે હું + 1 ના યાદી ઓવરને નજર કરવા માંગો છો.

836
00:50:46,150 --> 00:50:51,610
અને હવે, જો તત્વ કે અમે હાલમાં અંતે શોધી રહ્યાં છો તે અમારા લઘુત્તમ કરતા ઓછી અત્યાર સુધી છે,

837
00:50:51,610 --> 00:50:54,190
જે, યાદ રાખો, અમે લઘુત્તમ બોલ શરૂ કરી રહ્યા છીએ જ હોઇ

838
00:50:54,190 --> 00:50:57,020
ગમે તત્વ અમે હાલમાં છો; હું ધારે કરીશું કે લઘુત્તમ છે.

839
00:50:57,020 --> 00:51:00,270
જો હું એક તત્વ છે કે જે કરતા નાની છે શોધવા માટે, તે પછી હું કહેવા જાઉં છું ઠીક,

840
00:51:00,270 --> 00:51:02,700
તેમજ, હું એક નવા લઘુત્તમ મળ્યા છે.

841
00:51:02,700 --> 00:51:06,080
હું યાદ જ્યાં કે લઘુત્તમ હતી જાઉં છું.

842
00:51:06,080 --> 00:51:09,560
>> તેથી હવે, એક વખત હું કે અધિકાર ક્રમમાંગોઠવાયેલનથી સેગમેન્ટમાં પસાર કર્યો છે,

843
00:51:09,560 --> 00:51:16,690
હું કહી શકીએ હું તત્વ કે હું સ્થિતિમાં છે સાથે લઘુત્તમ તત્વ સ્વેપ જાઉં છું.

844
00:51:16,690 --> 00:51:21,100
કે મારી સૂચિ બનાવી રહ્યું છે, મારા ડાબેથી જમણે યાદીમાં છટણી ભાગ,

845
00:51:21,100 --> 00:51:25,190
અને અમે ક્યારેય તત્વ અંતે ફરીથી જોવા એકવાર તે ભાગમાં છે જરૂર નથી.

846
00:51:25,190 --> 00:51:27,930
એકવાર અમે તેને સ્વૅપ કરી છે.

847
00:51:27,930 --> 00:51:30,260
તેથી આપણે આ સૂચિ પર પસંદગી સૉર્ટ ચલાવો.

848
00:51:30,260 --> 00:51:38,220
વાદળી અહીં તત્વ માટે હું પ્રયત્ન રહ્યું છે, અને લાલ તત્વ માટે લઘુત્તમ તત્વ રહ્યું છે.

849
00:51:38,220 --> 00:51:41,570
તેથી હું યાદી ડાબી બાજુએ બધી રીતે શરૂ કરે છે, જેથી 5 છે.

850
00:51:41,570 --> 00:51:44,610
હવે અમે લઘુત્તમ ક્રમમાંગોઠવાયેલનથી તત્વ શોધવા જરૂર છે.

851
00:51:44,610 --> 00:51:49,480
તેથી, અમે કહીએ 0 <5, તેથી 0 મારું નવું લઘુત્તમ છે.

852
00:51:49,480 --> 00:51:53,820
>> પરંતુ હું ત્યાં ન અટકાવવા માટે, કારણ કે તેમ છતાં અમે ઓળખી શકે છે કે 0 સૌથી નાનું છે શકે છે,

853
00:51:53,820 --> 00:51:59,390
અમે એ ખાતરી કરો કે યાદી દરેક અન્ય તત્વ દ્વારા ચલાવવામાં જરૂર છે.

854
00:51:59,390 --> 00:52:01,760
1 તેથી મોટી છે, 6 મોટા, 4 મોટું છે.

855
00:52:01,760 --> 00:52:05,850
તેનો અર્થ એ છે કે આ તમામ ઘટકો જોયા બાદ, હું નક્કી કર્યું 0 સૌથી નાનું છે.

856
00:52:05,850 --> 00:52:09,800
તેથી હું 5 અને 0 સ્વેપ જાઉં છું.

857
00:52:09,800 --> 00:52:15,480
એકવાર હું કે સ્વેપ, હું એક નવી યાદી મેળવવા જઈ રહ્યો છું, અને હું જાણું છું કે હું જરૂર 0 કે ફરીથી જોવા ક્યારેય

858
00:52:15,480 --> 00:52:19,380
કારણ કે એક વખત હું તેને સ્વૅપ કરી છે, હું તેને છટણી કરી છે અને અમે પૂર્ણ કરી લીધું.

859
00:52:19,380 --> 00:52:22,730
હવે તે જ બને છે કે વાદળી તત્વ ફરીથી 5 એ,

860
00:52:22,730 --> 00:52:26,030
અને અમે 1 છે જુઓ જરૂર છે, 6 અને 4 માટે 1 જે તે નક્કી

861
00:52:26,030 --> 00:52:31,520
નાના લઘુત્તમ તત્વ છે, તેથી અમે 1 અને 5 એ સ્વેપ કરશો.

862
00:52:31,520 --> 00:52:36,890
ફરીથી, અમે જોવા જરૂર - 6 અને 4 માટે 5 સરખાવવા માટે,

863
00:52:36,890 --> 00:52:39,830
અને અમે 4 અને 5 એ સ્વેપ જઈ રહ્યાં છો, અને છેલ્લે સરખાવવા માટે,

864
00:52:39,830 --> 00:52:45,740
તે 2 નંબરો અને તેમને સ્વેપ સુધી અમે અમારા છટણી યાદી મળે છે.

865
00:52:45,740 --> 00:52:49,730
પસંદગી સૉર્ટ પર કોઈપણ પ્રશ્ન છે?

866
00:52:49,730 --> 00:52:56,420
ઠીક છે. ચાલો છેલ્લા વિષય અહીં ખસેડવા માટે, અને તે કે પુનરાવર્તનના છે.

867
00:52:56,420 --> 00:52:59,810
>> રિકર્ઝન, યાદ રાખો, આ ખરેખર મેટા બાબત એ છે કે જ્યાં કાર્ય

868
00:52:59,810 --> 00:53:02,740
વારંવાર પોતે કહે છે.

869
00:53:02,740 --> 00:53:05,620
તેથી અમુક સમયે, જ્યારે અમારા fuction વારંવાર પોતાને કૉલ કરે છે,

870
00:53:05,620 --> 00:53:10,100
ત્યાં અમુક બિંદુ કે અમે જાતને કૉલ રોકવા જરૂરી છે.

871
00:53:10,100 --> 00:53:13,670
કારણ કે જો અમે તે નથી, તો પછી અમે માત્ર આ કાયમ કરવું ચાલુ રાખવા જઈ રહ્યાં છો,

872
00:53:13,670 --> 00:53:16,660
અને અમારો કાર્યક્રમ માત્ર રહ્યું છે માટે સમાપ્ત.

873
00:53:16,660 --> 00:53:19,200
અમે આ શરત આધાર કેસ કૉલ કરો.

874
00:53:19,200 --> 00:53:22,570
અને આધાર કેસ વિધેય ફરીથી ફોન કરતાં કહે છે,

875
00:53:22,570 --> 00:53:25,330
હું માત્ર કેટલાક કિંમત પાછી જાઉં છું.

876
00:53:25,330 --> 00:53:28,080
તેથી એક વખત અમે કિંમત પરત કર્યું છે, અમે જાતને કૉલ બંધ કર્યુ છે,

877
00:53:28,080 --> 00:53:32,550
અને કોલ્સ અમે અત્યાર સુધી કરેલા બાકીના પણ પાછા આવી શકો છો.

878
00:53:32,550 --> 00:53:36,050
આધાર કેસ ઓફ વિરુદ્ધ ફરી યાદ આવવું કેસ છે.

879
00:53:36,050 --> 00:53:39,050
અને આ છે જ્યારે અમે એ વિધેય કે અમે હાલમાં સાઇન છો બીજા કૉલ કરવા માંગો છો

880
00:53:39,050 --> 00:53:44,690
અને અમે કદાચ, જોકે હંમેશાં નથી, વિવિધ દલીલો ઉપયોગ કરવા માંગો છો.

881
00:53:44,690 --> 00:53:48,940
>> તેથી જો અમે એફ કહેવાય કાર્ય હોય છે, અને એફ ફક્ત 1 દલીલ લઇ કહે છે,

882
00:53:48,940 --> 00:53:52,010
અને અમે હમણાં જ (1) f, એફ (1), એફ (1) ને કૉલ રાખવા, અને તે માત્ર જેથી બને છે

883
00:53:52,010 --> 00:53:56,510
આ 1 દલીલ ફરી યાદ આવવું કેસ પડે છે, અમે હજી પણ જઈ રહ્યાં છો ક્યારેય અટકાવો.

884
00:53:56,510 --> 00:54:01,620
પણ જો આપણે એક આધાર કેસ છે, તો અમે ખાતરી કરવા માટે કે આખરે અમે તે આધાર કેસ હિટ જઈ રહ્યાં છો કરવાની જરૂર છે.

885
00:54:01,620 --> 00:54:04,250
અમે ફક્ત આ યાદ આવવું કેસ રહેતા નથી રાખી નથી.

886
00:54:04,250 --> 00:54:09,870
સામાન્ય રીતે, જ્યારે અમે જાતને કહી, અમે કદાચ એક અલગ દલીલ દરેક સમય હોય રહ્યા છીએ.

887
00:54:09,870 --> 00:54:12,700
અહીં ખરેખર સરળ ફરી યાદ આવવું કાર્ય છે.

888
00:54:12,700 --> 00:54:15,090
તેથી આ એક નંબર કારણદર્શી ગણતરી કરશે.

889
00:54:15,090 --> 00:54:17,790
અહીં ટોચ અમે અમારી આધાર કેસ હોય છે.

890
00:54:17,790 --> 00:54:22,330
કે જે n ≤ 1, અમે કારણદર્શી ફરી કૉલ ન જઈ રહ્યાં છો છે.

891
00:54:22,330 --> 00:54:26,490
અમે રોકવા જઈ રહ્યાં છો; આપણે માત્ર અમુક કિંમત પાછી જઈ રહ્યાં છો.

892
00:54:26,490 --> 00:54:30,170
જો આ સાચું નથી, તો પછી અમે અમારી યાદ આવવું કેસ હિટ રહ્યા છીએ.

893
00:54:30,170 --> 00:54:33,550
અહીં નોંધ કરો કે અમે માત્ર કારણદર્શી (n) ન કૉલ કરી રહ્યાં છો, કારણ કે તે ખૂબ જ ઉપયોગી નહિં હોય.

894
00:54:33,550 --> 00:54:36,810
અમે કંઈક બીજું ઓફ કારણદર્શી કહી રહ્યા છીએ.

895
00:54:36,810 --> 00:54:40,850
>> અને તેથી તમે જુઓ, આખરે તો અમે (5) કારણદર્શી અથવા કંઈક પસાર કરી શકો છો,

896
00:54:40,850 --> 00:54:45,900
અમે (4) કારણદર્શી અને તેથી પર કૉલ જઈ રહ્યાં છો, અને છેવટે અમે આ આધાર કેસ હિટ રહ્યા છીએ.

897
00:54:45,900 --> 00:54:51,730
તેથી આ સારી દેખાય છે. માતાનો જુઓ શું થાય છે જ્યારે અમે ખરેખર આ સ્કોર દો.

898
00:54:51,730 --> 00:54:57,840
આ સ્ટેક છે, અને ચાલો કહે છે કે મુખ્ય એક દલીલ (4) સાથે આ કાર્ય કહી રહ્યું છે.

899
00:54:57,840 --> 00:55:02,200
તેથી એક વખત કારણદર્શી જુએ છે અને 4 =, કારણદર્શી પોતે કૉલ કરશે.

900
00:55:02,200 --> 00:55:05,010
હવે, અચાનક, અમે કારણદર્શી (3) હોય છે.

901
00:55:05,010 --> 00:55:10,780
તેથી આ કાર્ય વધતી રાખવા સુધી છેવટે અમે અમારી આધાર કેસ હિટ જતાં હોય છે.

902
00:55:10,780 --> 00:55:17,830
આ બિંદુએ, આ વળતર કિંમત પરત (nx આ વળતર કિંમત) છે,

903
00:55:17,830 --> 00:55:21,290
આ વળતર કિંમત nx આ વળતર કિંમત છે.

904
00:55:21,290 --> 00:55:23,290
આખરે અમે કેટલાક નંબર ફટકો જરૂર છે.

905
00:55:23,290 --> 00:55:26,560
અહીં ટોચ પર, અમે 1 વળતર કહો.

906
00:55:26,560 --> 00:55:30,650
તેનો અર્થ એ છે કે એકવાર અમે કે જે નંબર પાછા, અમે સ્ટેક આ પૉપ કરી શકો છો.

907
00:55:30,650 --> 00:55:36,570
તેથી આ કારણદર્શી (1) કરવામાં આવે છે.

908
00:55:36,570 --> 00:55:41,190
જ્યારે 1 વળતર, આ કારણદર્શી (1) વળતર, 1 થી આ વળતર.

909
00:55:41,190 --> 00:55:46,910
આ વળતર કિંમત, યાદ રાખો, nx આ વળતર કિંમત હતી.

910
00:55:46,910 --> 00:55:50,720
તેથી અચાનક, આ વ્યક્તિ જાણે છે કે હું 2 પરત કરવા માંગો છો.

911
00:55:50,720 --> 00:55:55,910
>> તેથી યાદ રાખો કે, પરત આ કિંમત માત્ર nx પરત કિંમત છે અહીં.

912
00:55:55,910 --> 00:56:01,160
તેથી હવે અમે 3 2 એક્સ કહેવું કરી શકો છો, અને છેલ્લે, અહીં આપણે કહી શકીએ

913
00:56:01,160 --> 00:56:04,010
આ માત્ર 4 3 x x 2 પ્રયત્ન રહ્યું છે.

914
00:56:04,010 --> 00:56:09,570
અને આ વળતર એકવાર, અમે મુખ્ય એક પૂર્ણાંક અંદર ઘટીને મેળવો.

915
00:56:09,570 --> 00:56:15,460
રિકર્ઝન પર કોઈપણ પ્રશ્ન છે?

916
00:56:15,460 --> 00:56:17,090
અધિકાર છે. તેથી ત્યાં ઓવરને અંતે પ્રશ્નો માટે વધુ સમય છે,

917
00:56:17,090 --> 00:56:23,360
પરંતુ હવે જોસેફ બાકીના વિષયો આવરી લઈશું.

918
00:56:23,360 --> 00:56:25,590
>> બધા હક [જોસેફ ઓન્ગ]. તેથી હવે અમે recursions વિશે વાત કરી છે,

919
00:56:25,590 --> 00:56:27,840
ચાલો શું મર્જ સૉર્ટ કરો છે તે વિશે થોડુંક વાત કરો.

920
00:56:27,840 --> 00:56:31,740
મર્જ કરો સૉર્ટ મૂળભૂત નંબરોની યાદી સૉર્ટ બીજી રીતે હોય છે.

921
00:56:31,740 --> 00:56:36,430
અને તે કેવી રીતે કામ કરે છે મર્જ સૉર્ટ સાથે છે, તો તમે એક યાદી હોય છે, અને અમે શું છે

922
00:56:36,430 --> 00:56:39,120
અમે કહીએ છીએ, આપણે 2 છિદ્ર આ વિભાજિત.

923
00:56:39,120 --> 00:56:42,750
અમે પ્રથમ સૉર્ટ ડાબી અડધા ભાગ પર ફરીથી મર્જ સ્કોર પડશે,

924
00:56:42,750 --> 00:56:45,040
પછી અમે અધિકાર અડધા ભાગ પર સૉર્ટ મર્જ સ્કોર પડશે,

925
00:56:45,040 --> 00:56:50,240
અને તે અમને હવે આપે 2 છિદ્ર કે છટણી કરવામાં આવે છે, અને હવે અમે તે છિદ્ર એકસાથે રહ્યા છીએ.

926
00:56:50,240 --> 00:56:55,010
તે થોડી મુશ્કેલ ઉદાહરણ વિના જુઓ, તેથી અમે ગતિનું મારફતે જાઓ અને જુઓ શું થાય છે પડશે.

927
00:56:55,010 --> 00:56:59,590
તેથી તમે શરૂ કરો આ યાદી સાથે, અમે તેને 2 અર્ધભાગ વિભાજિત.

928
00:56:59,590 --> 00:57:02,300
અમે ડાબી અડધા ભાગ પર સૉર્ટ પ્રથમ મર્જ ચલાવો.

929
00:57:02,300 --> 00:57:06,660
જેથી ડાબી અડધા છે, અને હવે અમે આ યાદી મારફતે તેમને ફરીથી ચલાવો

930
00:57:06,660 --> 00:57:09,800
જે મર્જ સૉર્ટ પસાર કરવામાં નહીં, અને તે પછી અમે જુઓ, ફરીથી,

931
00:57:09,800 --> 00:57:13,270
આ યાદી ડાબી બાજુ અને અમે તેના પર સૉર્ટ મર્જ ચલાવો.

932
00:57:13,270 --> 00:57:15,880
હવે, અમે 2 સંખ્યાની યાદી નીચે વિચાર,

933
00:57:15,880 --> 00:57:19,010
અને હવે ડાબી અડધા માત્ર 1 તત્વ લાંબી છે, અને અમે શકતો નથી

934
00:57:19,010 --> 00:57:23,380
યાદી છે કે જે અડધા માં માત્ર 1 તત્વ છે વિભાજિત છે, તેથી અમે માત્ર કહી, એક વખત અમે 50 હોય છે,

935
00:57:23,380 --> 00:57:26,400
જે ફક્ત 1 તત્વ છે, તે પહેલેથી જ છટણી છે.

936
00:57:26,400 --> 00:57:29,860
>> એકવાર અમે સાથે પૂર્ણ કરી, અમે જોઈ શકો છો કે અમે આ કરી શકો છો

937
00:57:29,860 --> 00:57:32,230
આ યાદી જમણી અડધા પર ખસેડો,

938
00:57:32,230 --> 00:57:36,480
અને 3 પણ, છૂટાં પાડવામાં આવે છે અને તેથી હવે આ યાદીમાં બંને અર્ધભાગ સૉર્ટ કરી છે

939
00:57:36,480 --> 00:57:39,080
અમે આ નંબર ફરી પાછા સાથે જોડાઇ શકે છે.

940
00:57:39,080 --> 00:57:45,320
તેથી અમે 50 અને 3 જોવા; 3 50 કરતાં નાની હોય છે, તેથી તે પ્રથમ જાય અને પછી 50 સાઇન આવે છે

941
00:57:45,320 --> 00:57:49,340
હવે, તે થઈ છે; અમે પાછા જાઓ કે યાદી અને સૉર્ટ તે અડધા કરવા માટે છે.

942
00:57:49,340 --> 00:57:52,440
42 તે પોતાના નંબર છે, જેથી તે પહેલેથી જ છટણી છે.

943
00:57:52,440 --> 00:57:57,850
તેથી હવે અમે આ તુલના 2 અને 3 42 કરતાં નાની હોય છે, કે જેથી પ્રથમ મૂકવા નહીં,

944
00:57:57,850 --> 00:58:02,340
હવે 42 માં મૂકી નહીં, અને 50 સાઇન મૂકવા નહીં

945
00:58:02,340 --> 00:58:07,220
હવે, કે છટણી છે, અમે બધા માર્ગ પર પાછા જાઓ ટોચ પર, 1337 અને 15.

946
00:58:07,220 --> 00:58:14,560
વેલ, અમે હવે આ યાદી ડાબી અડધા જોવા; 1337 પોતે છે જેથી તે છટણી અને 15 છે સાથે જ.

947
00:58:14,560 --> 00:58:19,020
તેથી હવે અમે આ 2 નંબરો ભેગા કે મૂળ યાદી, 15 <1337, સૉર્ટ

948
00:58:19,020 --> 00:58:23,060
તેથી તે પ્રથમ જાય, પછી 1337 સાઇન જાય

949
00:58:23,060 --> 00:58:26,640
અને હવે અમે ઉપર મૂળ યાદી બંને અર્ધભાગ સોર્ટ થાય છે.

950
00:58:26,640 --> 00:58:30,440
અને તમામ અમે હોય તો આ ભેગા છે.

951
00:58:30,440 --> 00:58:36,890
અમે આ યાદીમાં પ્રથમ 2 નંબરો, 3 <15 જોવા છે, તેથી તે પ્રકારની એરે પર પ્રથમ વખત જાય છે.

952
00:58:36,890 --> 00:58:44,460
15 <42, તેથી તેને સાઇન હવે જાય છે, 42 <1337, કે જે સાઇન જાય

953
00:58:44,460 --> 00:58:51,010
50 <1337, તેથી તેને સાઇન જાય અને નોંધ્યું છે કે અમે માત્ર 2 નંબરો આ યાદી ઉપડ્યો.

954
00:58:51,010 --> 00:58:53,640
તેથી અમે ફક્ત 2 યાદીઓ વચ્ચે વારાફરતી રહ્યા છો.

955
00:58:53,640 --> 00:58:56,050
અમે હમણાં જ શરૂઆતમાં શોધી રહ્યાં છો, અને અમે તત્વ વાત કરી રહ્યાં છે

956
00:58:56,050 --> 00:59:00,270
કે પછી અને નાના તે અમારી એરે માં મૂકી છે.

957
00:59:00,270 --> 00:59:04,080
હવે અમે તમામ છિદ્ર મર્જ કરી છે અને અમે પૂર્ણ કરી લીધું.

958
00:59:04,080 --> 00:59:07,780
>> વિશે કોઇ પ્રશ્નો સૉર્ટ મર્જ? હા?

959
00:59:07,780 --> 00:59:14,190
[વિદ્યાર્થી] જો તે અલગ અલગ જૂથોમાં વિભાજન છે, તેઓ માત્ર શા માટે નથી તે નથી એકવાર વિભાજિત

960
00:59:14,190 --> 00:59:19,970
અને તમે એક જૂથમાં 3 અને 2 છે? [પ્રશ્ન દુર્બોધ રેસ્ટ ઓફ]

961
00:59:19,970 --> 00:59:24,940
કારણ - જેથી પ્રશ્ન છે, અમે માત્ર કે પ્રથમ પગલું ન શા માટે તેમને મર્જ કરી પછી અમે તેમને છે?

962
00:59:24,940 --> 00:59:29,530
કારણ કે અમે આ કરી શકો છો, બન્ને પક્ષો ડાબી સૌથી તત્વો શરૂ થાય છે,

963
00:59:29,530 --> 00:59:33,040
અને પછી નાના એક ભરે છે અને તેને મૂકી છે કે અમે કે આ ખબર

964
00:59:33,040 --> 00:59:35,290
વ્યક્તિગત યાદીઓ છટણી ઓર્ડર છે.

965
00:59:35,290 --> 00:59:37,290
તેથી જો હું બંને અર્ધભાગ ડાબી સૌથી તત્વો જોઈ રહ્યો છું,

966
00:59:37,290 --> 00:59:40,490
મને ખબર છે તેઓ તે યાદીઓ નાના તત્વો પ્રયત્ન રહ્યા છીએ.

967
00:59:40,490 --> 00:59:43,930
તેથી હું તેમને નાનું આ વિશાળ યાદી તત્વ સ્પોટ મુકી શકે છે.

968
00:59:43,930 --> 00:59:47,810
બીજી બાજુ, જો હું ત્યાં ઉપર બીજા સ્તર તે 2 યાદીઓ જોવા,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42 1337, અને 15, નહિં કે જે અલગ પાડવામાં આવે છે.

970
00:59:51,640 --> 00:59:55,770
તેથી જો હું 50 અને 1337 માટે જુઓ, હું મારું યાદી માં 50 પ્રથમ મૂકવા જાઉં છું.

971
00:59:55,770 --> 01:00:00,130
પરંતુ ખરેખર અર્થમાં નથી, કારણ કે તે 3 બધા બહાર નાનું તત્વ છે.

972
01:00:00,130 --> 01:00:04,390
જેથી માત્ર કારણ અમે આ સંયુક્ત પગલું કરી શકો છો છે કારણ કે અમારા યાદીઓ પહેલાથી જ અલગ પાડવામાં આવે છે.

973
01:00:04,390 --> 01:00:07,010
જે શા માટે અમે નીચે નીચે બધી રીતે વિચાર છે

974
01:00:07,010 --> 01:00:09,800
કારણ કે જ્યારે અમે માત્ર એક જ નંબર હોય, તમે કે જે એક નંબર ખબર

975
01:00:09,800 --> 01:00:14,120
અને પોતાના પહેલેથી જ છટણી યાદી છે.

976
01:00:14,120 --> 01:00:19,360
>> કોઈપણ પ્રશ્ન છે? નહીં?

977
01:00:19,360 --> 01:00:24,260
જટિલતા? સારું, તમે જોઈ શકો છો કે જે દરેક પગલે ત્યાં ઓવરને નંબરો છે,

978
01:00:24,260 --> 01:00:27,590
અને અમે અડધા લોગ n એ સમયમાં યાદી વિભાજિત કરી શકો છો,

979
01:00:27,590 --> 01:00:31,700
જે છે જ્યાં અમે આ n એક્સ લોગ n જટિલતા છે.

980
01:00:31,700 --> 01:00:34,940
અને તમે મર્જ સૉર્ટ માટે શ્રેષ્ઠ કેસ n લોગ n છે જુઓ, અને પડશે તે જ થાય છે

981
01:00:34,940 --> 01:00:39,340
કે ખરાબ કિસ્સામાં, અથવા ત્યાં ઉપર Ω પણ n n પ્રવેશો.

982
01:00:39,340 --> 01:00:42,480
ધ્યાનમાં રાખો કંઈક.

983
01:00:42,480 --> 01:00:45,750
પર ખસેડવું, ચાલો કેટલાક સુપર મૂળભૂત ફાઈલ હું ઓ / પર જાઓ

984
01:00:45,750 --> 01:00:48,830
જો તમે ભાંખોડિયાંભર થઈને તપાસ્યા હતા, તમે નોટિસ પડશે અમે સિસ્ટમ અમુક પ્રકારની હતી

985
01:00:48,830 --> 01:00:51,270
તમે જ્યાં લૉગ ફાઇલ લખી જો તમે કોડ દ્વારા વાંચી શકે છે.

986
01:00:51,270 --> 01:00:53,730
ચાલો કેવી રીતે તમે આ કરી શકે છે.

987
01:00:53,730 --> 01:00:57,450
વેલ અમે fprintf છે, કે જે તમે હમણાં જ તરીકે printf વિચાર કરી શકો છો,

988
01:00:57,450 --> 01:01:01,720
પણ માત્ર ફાઈલ બદલે છાપવા અને તેથી શરૂઆતમાં એફ.

989
01:01:01,720 --> 01:01:07,570
કોડ આ અહીં સૉર્ટ કરો, તેને શું છે, તમે ભાંખોડિયાંભર થઈને જોવા હોઈ શકે છે,

990
01:01:07,570 --> 01:01:12,310
તે પંક્તિ નંબરો કયા છે દ્વારા પંક્તિ તમારા એરે 2-પરિમાણીય પ્રિન્ટીંગ જાય છે.

991
01:01:12,310 --> 01:01:17,850
આ કિસ્સામાં, તમારા printf ટર્મિનલ માટે છાપે છે અથવા આપણે શું વિભાગ પ્રમાણભૂત આઉટપુટ પર ફોન કરો.

992
01:01:17,850 --> 01:01:22,170
>> અને હવે, આ કિસ્સામાં, બધા અમે શું હોય છે fprintf સાથે printf બદલો,

993
01:01:22,170 --> 01:01:26,770
તે કહેવું ફાઈલ શું તમે છાપવાનો કરવા માંગો છો, અને આ કિસ્સામાં તે માત્ર તેને છાપે છે કે ફાઈલ માટે

994
01:01:26,770 --> 01:01:32,230
ને બદલે તેને છાપી તમારા ટર્મિનલ માટે.

995
01:01:32,230 --> 01:01:36,500
વેલ, પછી કે પ્રશ્ન begs: અમે ક્યાથી નથી ફાઈલ આ પ્રકારની વિચાર, અધિકાર?

996
01:01:36,500 --> 01:01:39,840
અમે આ fprintf fuction લૉગ ઇન પસાર પણ અમે કોઈ વિચાર જ્યાં તે તરફથી આવ્યા હતા.

997
01:01:39,840 --> 01:01:43,980
વેલ, કોડ શરૂઆતમાં, અમે હતી શું અહીં ઉપર કોડ આ ભાગ હતો,

998
01:01:43,980 --> 01:01:48,340
જે મૂળભૂત રીતે કહે છે કે ખુલ્લી ફાઇલ log.txt કહે છે.

999
01:01:48,340 --> 01:01:53,220
અમે શું પછી એ જ છે કે અમે ખાતરી કરો કે ફાઈલ ખરેખર સફળતાપૂર્વક ખોલવામાં આવે છે બનાવવા હોય છે.

1000
01:01:53,220 --> 01:01:57,070
જેથી તે બહુવિધ કારણો માટે નિષ્ફળ રહેશે; તમે તમારા કમ્પ્યુટર પર પૂરતી જગ્યા ન હોય તો, ઉદાહરણ તરીકે.

1001
01:01:57,070 --> 01:01:59,790
તેથી તે હંમેશા મહત્વપૂર્ણ પહેલાં તમે ફાઇલ સાથે કોઇ કામગીરી કરી

1002
01:01:59,790 --> 01:02:03,300
કે અમે તપાસ કે શું ફાઈલ સફળતાપૂર્વક ખોલવામાં આવી હતી.

1003
01:02:03,300 --> 01:02:09,330
તેથી શું છે કે, તે fopen એક દલીલ છે, સાથે સાથે, અમે ઘણી રીતે ફાઇલ ખોલી શકે છે.

1004
01:02:09,330 --> 01:02:13,510
અમે શું છે કરી શકો છો, તો અમે તેને વાઇડ પસાર કરી શકો છો, કે જે ફાઈલ પર ફરીથી લખી અર્થ છે જો તે બહાર નીકળે છે પહેલાથી જ,

1005
01:02:13,510 --> 01:02:18,070
અમે એક પસાર કરવા માટે, જે તેમને ફાઈલ ઓવરને તેને ઓવરરાઈડીંગ બદલે ઉમેરી શકો છો,

1006
01:02:18,070 --> 01:02:22,730
અથવા આપણે r સ્પષ્ટ કરવા માટે, કે જેનો અર્થ કરી શકો છો, ચાલો તરીકે ફક્ત વાંચવા માટે ફાઇલ ખોલો.

1007
01:02:22,730 --> 01:02:24,890
તેથી જો કાર્યક્રમ ફાઈલ સાથે કોઈપણ ફેરફારો કરવા પ્રયાસ કરે છે,

1008
01:02:24,890 --> 01:02:30,140
તેમને અંતે કિકિયારી નથી અને તેમને તે નથી.

1009
01:02:30,140 --> 01:02:33,320
છેલ્લે, એક વાર અમે ફાઇલ સાથે પૂર્ણ કરી પૂરી તેના પર કામગીરી કરી,

1010
01:02:33,320 --> 01:02:35,860
અમે ખાતરી કરવા માટે અમે ફાઈલ બંધ કરવાની જરૂર છે.

1011
01:02:35,860 --> 01:02:38,830
અને તેથી તમારા કાર્યક્રમ ઓવરને અંતે, તમે તેમને ફરીથી પસાર જવું છે

1012
01:02:38,830 --> 01:02:42,120
આ ફાઇલ છે કે જે તમે ખોલી, અને માત્ર બંધ કરો.

1013
01:02:42,120 --> 01:02:44,650
તેથી આ મહત્વપૂર્ણ કંઈક કે જે તમે ખાતરી કરો કે તમે શું કરી હોય છે.

1014
01:02:44,650 --> 01:02:47,180
તેથી યાદ તમે ફાઈલ ખોલી શકે છે, તો પછી તમે ફાઇલ લખી શકે છે,

1015
01:02:47,180 --> 01:02:51,270
ફાઇલ માં કામગીરી કરી છે, પણ પછી તમે અંતે ફાઈલ બંધ હોય છે.

1016
01:02:51,270 --> 01:02:53,270
>> મૂળભૂત ફાઈલ પર કોઈપણ પ્રશ્નો I / O? હા?

1017
01:02:53,270 --> 01:02:58,050
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]

1018
01:02:58,050 --> 01:03:02,480
અહીં અધિકાર. આ પ્રશ્ન છે, જ્યાં આ log.txt ફાઈલ નથી દેખાય છે?

1019
01:03:02,480 --> 01:03:07,890
વેલ, જો તમે તેને log.txt આપી, તેને એક્ઝેક્યુટેબલ તરીકે એજ ડિરેક્ટરીમાં બનાવે છે.

1020
01:03:07,890 --> 01:03:10,500
તેથી જો you're - >> [વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]

1021
01:03:10,500 --> 01:03:18,830
હા. એ જ ફોલ્ડર માં, અથવા સમાન ડિરેક્ટરીમાં તરીકે તમે તેને ફોન કરો.

1022
01:03:18,830 --> 01:03:21,400
હવે મેમરી, સ્ટેક ઢગલો, અને.

1023
01:03:21,400 --> 01:03:23,400
આમ કેવી રીતે કમ્પ્યૂટર બહાર નાખ્યો મેમરી છે?

1024
01:03:23,400 --> 01:03:26,270
સારું, તમે આ અહીં બ્લોક જેવું તરીકે મેમરી કલ્પના કરી શકો છો.

1025
01:03:26,270 --> 01:03:30,260
અને અમે મેમરી હોય શું ત્યાં પર અટકી ઢગલો, અને સ્ટેક કે નીચે ત્યાં કહેવાય છે.

1026
01:03:30,260 --> 01:03:34,480
અને ઢગલો નીચેની તરફ વધે છે અને સ્ટેક ઉપરનું વધે છે.

1027
01:03:34,480 --> 01:03:38,620
જેથી ટોમી ઉલ્લેખ કર્યો છે - ઓહ જ છે, અને અમે આ અન્ય 4 સેગમેન્ટો મને બીજા મળશે હોય -

1028
01:03:38,620 --> 01:03:42,890
તરીકે ટોમી અગાઉ કહ્યું હતું કે, તમે જાણો છો કે કેવી રીતે તેના કાર્યો પોતાને કૉલ અને દરેક અન્ય કૉલ?

1029
01:03:42,890 --> 01:03:44,930
તેઓ સ્ટેક ફ્રેમ આ પ્રકારની બિલ્ડ.

1030
01:03:44,930 --> 01:03:47,360
વેલ, જો મુખ્ય foo કોલ્સ, foo સ્ટેક પર મૂકી નહીં.

1031
01:03:47,360 --> 01:03:52,430
Foo કહે બાર બાર, વિચાર માતાનો સ્ટેક પર મૂકવામાં આવે છે, અને તે સ્ટેક પર પછી મૂકવા નહીં.

1032
01:03:52,430 --> 01:03:57,040
અને તેઓ પાછા ફરવા માટે, તેઓ દરેક બોલ સ્ટેક લેવામાં છે.

1033
01:03:57,040 --> 01:04:00,140
આ સ્થાનો દરેક અને મેમરી પકડી શકું?

1034
01:04:00,140 --> 01:04:03,110
વેલ, ટોચની છે, કે જે લખાણ સેગમેન્ટ છે કાર્યક્રમ પોતે સમાવે છે.

1035
01:04:03,110 --> 01:04:06,390
મશીન કોડ તેથી, કે ત્યાં છે, એક વાર તમે તમારા કાર્યક્રમ કમ્પાઇલ.

1036
01:04:06,390 --> 01:04:08,520
આગળ, કોઇપણ વૈશ્વિક ચલો આરંભ.

1037
01:04:08,520 --> 01:04:12,660
>> જેથી તમે તમારા કાર્યક્રમ વૈશ્વિક ચલો હોય છે, અને તમે જેમ = 5 કહેવું,

1038
01:04:12,660 --> 01:04:15,260
કે જે સેગમેન્ટમાં મૂકવા નહીં, અને જમણી કે હેઠળ,

1039
01:04:15,260 --> 01:04:18,990
તમે કોઈપણ uninitialized વૈશ્વિક દશાંશ માહિતી, કે જે માત્ર એક ઈન્ છે,

1040
01:04:18,990 --> 01:04:20,990
પરંતુ તમે કહેશો નહીં, તે કંઇ માટે સમાન છે.

1041
01:04:20,990 --> 01:04:23,870
સમજો આ વૈશ્વિક ચલો છે, તેથી તેઓ મુખ્ય બહાર છો.

1042
01:04:23,870 --> 01:04:28,560
તેથી આ કોઇ વૈશ્વિક ચલો કે જાહેર છે પરંતુ આરંભ નથી થાય છે.

1043
01:04:28,560 --> 01:04:32,310
તેથી શું ઢગલો છે? મેમરી malloc છે, કે જે અમે થોડો માં મળશે મદદથી ફાળવવામાં આવે છે.

1044
01:04:32,310 --> 01:04:35,990
અને છેલ્લે, સ્ટેક સાથે તમે કોઈપણ સ્થાનિક ચલો છે

1045
01:04:35,990 --> 01:04:39,950
અને કોઈ ફંક્શન્સ તમને તેમના પરિમાણો કોઇ પણ કહી શકે છે.

1046
01:04:39,950 --> 01:04:43,720
છેલ્લા વસ્તુ, તમે ખરેખર જાણવા પર્યાવરણ ચલો શું નથી,

1047
01:04:43,720 --> 01:04:46,700
પરંતુ જ્યારે તમે કાર્યક્રમ ચલાવો, ત્યાં સંકળાયેલ કંઈક છે, જેમ કે

1048
01:04:46,700 --> 01:04:49,550
આ વ્યક્તિ જે કાર્યક્રમ ચાલી હતી વપરાશકર્તાનામ છે.

1049
01:04:49,550 --> 01:04:51,550
અને તે માટે નીચે પ્રકારના જ હશે.

1050
01:04:51,550 --> 01:04:54,540
મેમરી સરનામાંઓ, જે હેક્સાડેસિમલ કિંમતો છે દ્રષ્ટિએ,

1051
01:04:54,540 --> 01:04:58,170
0 અંતે ટોચની શરૂઆતમાં કિંમતો, અને તેઓ બધી રીતે જવું નીચે.

1052
01:04:58,170 --> 01:05:00,440
આ કિસ્સામાં, જો તમે સિસ્ટમને 32-bit કરશો,

1053
01:05:00,440 --> 01:05:05,390
તળિયે સરનામા માટે 0x પ્રયત્ન રહ્યું છે, એએફ અનુસરતા, કારણ કે તે 32 બીટ છે,

1054
01:05:05,390 --> 01:05:10,890
જે 8 બાઇટ્સ છે, અને આ કિસ્સામાં 8 બાઇટ્સ 8 હેક્સાડેસિમલ અંકો અનુલક્ષે છે.

1055
01:05:10,890 --> 01:05:20,110
જેથી નીચે અહીં તમે, પસંદ, 0xffffff જઈ રહ્યાં છો, અને ત્યાં તમને 0 હોય રહ્યા છીએ.

1056
01:05:20,110 --> 01:05:23,660
તેથી પોઇંટરો શું છે? તમે કેટલાક આ વિભાગમાં નહિં આવે તે પહેલા આવરી શકે છે.

1057
01:05:23,660 --> 01:05:26,660
પરંતુ અમે તે ઉપર વ્યાખ્યાન જવા નહોતો તેથી, એક નિર્દેશક માત્ર એક માહિતી પ્રકાર છે

1058
01:05:26,660 --> 01:05:34,030
ભંડાર છે, જે તેના બદલે 50 જેવી કિંમત અમુક પ્રકારના છે, તે મેમરીમાં કેટલાક સ્થાન સરનામા ના સંગ્રહ કરે છે.

1059
01:05:34,030 --> 01:05:36,020
કે મેમરી જેમ [દુર્બોધ].

1060
01:05:36,020 --> 01:05:41,120
તેથી આ કિસ્સામાં, અમે શું છે, તો અમને પૂર્ણાંક અથવા પૂર્ણાંક * એક નિર્દેશક હોય છે,

1061
01:05:41,120 --> 01:05:46,210
અને તે 0xDEADBEEF આ હેક્સાડેસિમલ સરનામા સમાવે છે.

1062
01:05:46,210 --> 01:05:50,880
>> તેથી અમે શું છે, હવે, મેમરી કેટલાક સ્થાન પર આ નિર્દેશક પોઇન્ટ

1063
01:05:50,880 --> 01:05:56,020
અને તે માત્ર એક, 50 કિંમત આ મેમરી સ્થાન પર છે.

1064
01:05:56,020 --> 01:06:01,810
કેટલાક 32-bit સિસ્ટમો પર, બધા 32-bit સિસ્ટમો પર, પોઇંટરો અપ 32 બિટ્સ અથવા 4 બાઇટ્સ લો.

1065
01:06:01,810 --> 01:06:06,020
પરંતુ, ઉદાહરણ તરીકે, સિસ્ટમ 64-bit પર પોઇન્ટર 64 બિટ્સ છે.

1066
01:06:06,020 --> 01:06:08,040
જેથી કંઈક તમે ધ્યાનમાં રાખવા માંગો છો શકે છે.

1067
01:06:08,040 --> 01:06:12,310
તેથી એક સિસ્ટમ ઓવરને-bit, એક નિર્દેશક ઓવરને બિટ્સ છે બનાવ્યો.

1068
01:06:12,310 --> 01:06:17,320
પોઇન્ટર પ્રકારના વધારાના વસ્તુઓ વગર હાર્ડ પાચન છે,

1069
01:06:17,320 --> 01:06:20,300
તેથી આપણે ગતિશીલ મેમરી ફાળવણી એક ઉદાહરણ દ્વારા જાઓ.

1070
01:06:20,300 --> 01:06:25,130
શું ગતિશીલ મેમરી ફાળવણી તમારા માટે કરે છે, અથવા આપણે શું malloc કહી,

1071
01:06:25,130 --> 01:06:29,280
તે તમને સેટ બહાર દશાંશ માહિતી અમુક પ્રકારની ફાળવો.

1072
01:06:29,280 --> 01:06:31,830
તેથી આ માહિતી પ્રકારના વધુ કાર્યક્રમના સમયગાળા માટે કાયમી.

1073
01:06:31,830 --> 01:06:36,430
જેમ તમે જાણો છો, કારણ કે, જો તમે એક કાર્ય ની અંદર x છે, અને તે કાર્ય વળતર જાહેર,

1074
01:06:36,430 --> 01:06:40,910
તમે લાંબા સમય સુધી માહિતી કે એક્સ માં સંગ્રહ કરવામાં વપરાશ હોય છે.

1075
01:06:40,910 --> 01:06:44,420
પોઇન્ટર અમને શું છે તે અમને મેમરી અથવા સ્ટોર કિંમતો સ્ટોર

1076
01:06:44,420 --> 01:06:46,840
મેમરી અલગ સેગમેન્ટ છે, નામ અનુસાર ઢગલો છે.

1077
01:06:46,840 --> 01:06:49,340
હવે એક વાર અમે કાર્ય બહાર પાછો સુધી અમે એક નિર્દેશક હોય છે

1078
01:06:49,340 --> 01:06:54,960
મેમરી કે સ્થાન, પછી અમે શું કરી શકો છો છે અમે માત્ર ત્યાં કિંમતો જોવા કરી શકો છો.

1079
01:06:54,960 --> 01:06:58,020
ચાલો એક ઉદાહરણ જોવા: આ અમારી મેમરી લેઆઉટ ફરી છે.

1080
01:06:58,020 --> 01:07:00,050
અને અમે આ કાર્ય હોય છે, મુખ્ય.

1081
01:07:00,050 --> 01:07:06,870
તે શું છે - ઠીક છે, તેથી સરળ, જમણી - પૂર્ણાંક એક્સ = 5, કે જે હમણાં જ મુખ્ય માં સ્ટેક પર એક ચલ છે.

1082
01:07:06,870 --> 01:07:12,450
>> બીજી બાજુ, હવે આપણે એક નિર્દેશક જે કાર્ય giveMeThreeInts કહે જાહેર.

1083
01:07:12,450 --> 01:07:16,800
અને તેથી હવે અમે આ કાર્ય જાય છે અને અમે તે માટે એક નવો સ્ટેક ફ્રેમ બનાવો.

1084
01:07:16,800 --> 01:07:20,440
જો કે, આ સ્ટેક ફ્રેમમાં, અમે પૂર્ણાંક temp * જાહેર,

1085
01:07:20,440 --> 01:07:23,210
જે mallocs અમારા માટે 3 પૂર્ણાંકો છે.

1086
01:07:23,210 --> 01:07:25,880
તેથી પૂર્ણાંક કદ અમને આપો કેટલા બાઇટ્સ આ પૂર્ણાંક છે,

1087
01:07:25,880 --> 01:07:29,620
અને malloc અમને આપે છે કે ઢગલો પર જગ્યા ઘણા બાઇટ્સ.

1088
01:07:29,620 --> 01:07:32,890
તેથી આ કિસ્સામાં, અમે 3 પૂર્ણાંકો માટે પૂરતી જગ્યા બનાવી છે,

1089
01:07:32,890 --> 01:07:36,830
અને ઢગલો માર્ગ ઉપર ત્યાં છે, કે જે શા માટે હું આ દોરવામાં કર્યું છે ઊંચી છે.

1090
01:07:36,830 --> 01:07:42,900
એકવાર અમે પૂર્ણ કરી લો, અમે પાછા અહીં આવે છે, તમે માત્ર જરૂર 3 ints પાછો ફર્યો,

1091
01:07:42,900 --> 01:07:47,000
અને તે સરનામું આપે છે, જ્યાં છે કે મેમરી છે ઉપર આ કેસ છે.

1092
01:07:47,000 --> 01:07:51,250
અને અમે નિર્દેશક સ્વીચ = સુયોજિત કરો, અને ત્યાં અમે અન્ય નિર્દેશક હોય છે.

1093
01:07:51,250 --> 01:07:54,550
પરંતુ શું કે કાર્ય વળતર અહીં મુક્યા છે અને અદૃશ્ય થઈ જાય છે.

1094
01:07:54,550 --> 01:07:59,250
તેથી temp અદૃશ્ય થઈ જાય છે, પરંતુ અમે હજુ પણ જ્યાં ની સરનામા જાળવવા

1095
01:07:59,250 --> 01:08:01,850
તે 3 પૂર્ણાંકો મુખ્ય ની અંદર હોય છે.

1096
01:08:01,850 --> 01:08:06,180
તેથી આ સમૂહ માં, પોઇંટરો scoped સ્થાનિક છે સ્ટૅક્ડ ફ્રેમ માટે,

1097
01:08:06,180 --> 01:08:09,860
પરંતુ મેમરી કે જે તેમને સંદર્ભ લો તો ઢગલો છે.

1098
01:08:09,860 --> 01:08:12,190
>> એ નથી કે સૂઝ છે?

1099
01:08:12,190 --> 01:08:14,960
[વિદ્યાર્થી] કે જે તમને પુનરાવર્તન કરશો? >> [જોસેફ] હા.

1100
01:08:14,960 --> 01:08:20,270
તેથી જો હું પાછા માત્ર થોડો જાઓ, તમે જુઓ છો કે કામચલાઉ નોકર ફાળવવામાં

1101
01:08:20,270 --> 01:08:23,500
ત્યાં સુધી હીપ પર અમુક મેમરી.

1102
01:08:23,500 --> 01:08:28,680
તેથી જ્યારે આ કાર્ય, વળતર giveMeThreeInts, આ અહીં સ્ટેકમાંથી અદૃશ્ય થઈ જાય છે.

1103
01:08:28,680 --> 01:08:35,819
અને તે ચલો કોઇપણ પણ, આ કિસ્સામાં, આ નિર્દેશક કે સ્ટૅક્ડ ફ્રેમમાં ફાળવવામાં હતું.

1104
01:08:35,819 --> 01:08:39,649
કે અદૃશ્ય થઈ રહ્યું છે, પણ ત્યારથી અમે કામચલાઉ નોકર પરત

1105
01:08:39,649 --> 01:08:46,330
અને અમે નિર્દેશક સેટ = કામચલાઉ નોકર, નિર્દેશક હવે સ્થાન સમાન મેમરી કામચલાઉ નોકર હતો નિર્દેશ બનશે.

1106
01:08:46,330 --> 01:08:50,370
તેથી હવે, તેમ છતાં અમે કામચલાઉ નોકર છે, કે જે સ્થાનિક નિર્દેશક ગુમાવો છો,

1107
01:08:50,370 --> 01:08:59,109
અમે હજુ તે શું છે કે ચલ નિર્દેશક ની અંદર તરફ ઇશારો કરવામાં આવ્યો હતો મેમરી સરનામા જાળવી રાખી છે.

1108
01:08:59,109 --> 01:09:03,740
પ્રશ્નો? કે જે ગૂંચવણમાં વિષય પ્રકારની હોઈ શકે જો તમને તે ઉપર વિભાગમાં નહિં ચાલ્યા ગયા છે શકે છે.

1109
01:09:03,740 --> 01:09:09,240
અમે, તમારા ટીએફ ચોક્કસપણે હશે તેની પર જાઓ અને અલબત્ત અમે પ્રશ્નોના જવાબ કરી શકો છો

1110
01:09:09,240 --> 01:09:11,500
આ માટે સમીક્ષા સત્ર ઓવરને અંતે.

1111
01:09:11,500 --> 01:09:14,220
પરંતુ આ જટિલ વિષય જેવું છે, અને હું વધુ ઉદાહરણો છે કે જે બતાવે જતાં હોય છે

1112
01:09:14,220 --> 01:09:18,790
કે મદદ કરશે સ્પષ્ટ પોઇંટરો ખરેખર શું છે.

1113
01:09:18,790 --> 01:09:22,500
>> આ કિસ્સામાં, પોઇંટરો એરે માટે સમકક્ષ હોય છે,

1114
01:09:22,500 --> 01:09:25,229
તેથી હું ફક્ત પૂર્ણાંક એરે તરીકે જ બાબત તરીકે આ નિર્દેશક વાપરી શકો છો.

1115
01:09:25,229 --> 01:09:29,840
તેથી હું 0 માં ક્રમાંકિત છું, અને 1 થી પ્રથમ પૂર્ણાંક બદલી રહ્યા હોય,

1116
01:09:29,840 --> 01:09:39,689
2 એ બીજા પૂર્ણાંક બદલવા, અને 3 પૂર્ણાંક માટે 3.

1117
01:09:39,689 --> 01:09:44,210
તેથી પોઇન્ટર પર વધુ. વેલ, Binky યાદ અપાવે છે.

1118
01:09:44,210 --> 01:09:48,319
આ કિસ્સામાં અમે નિર્દેશક ફાળવવામાં કર્યું છે, અથવા અમે નિર્દેશક જાહેર

1119
01:09:48,319 --> 01:09:52,760
પરંતુ શરૂઆતમાં જ્યારે હું માત્ર એક નિર્દેશક જાહેર, પછી તે મેમરીમાં ક્યાંય નથી પોઇન્ટ છે.

1120
01:09:52,760 --> 01:09:54,930
તે માત્ર તે અંદર કચરો કિંમતો છે.

1121
01:09:54,930 --> 01:09:56,470
તેથી હું કોઈ વિચાર જ્યાં આ નિર્દેશક માટે પોઇન્ટ છે.

1122
01:09:56,470 --> 01:10:01,630
તે સરનામું કે જેને માત્ર 0 અને 1 ની જ્યાં તે શરૂઆતમાં જાહેર કરવામાં આવી ભરવામાં આવે છે.

1123
01:10:01,630 --> 01:10:04,810
મેં કંઈપણ આ સાથે નથી ત્યાં સુધી હું તેના પર malloc કહી શકો છો

1124
01:10:04,810 --> 01:10:08,390
અને પછી તે મને ઢગલો જ્યાં હું કિંમતો અંદર મૂકી શકો છો પર થોડો અવકાશ આપે છે.

1125
01:10:08,390 --> 01:10:11,980
પછી ફરીથી, મને ખબર નથી શું આ મેમરી ની અંદર છે.

1126
01:10:11,980 --> 01:10:16,780
જેથી પ્રથમ વસ્તુ મને શું હોય છે કે કેમ તેની તપાસ સિસ્ટમ પૂરતી મેમરી હતી

1127
01:10:16,780 --> 01:10:20,850
મને આપી પાછા પ્રથમ સ્થાને છે, કેમ કે હું જે કરી રહ્યો છું અને આ તપાસ માં 1 પૂર્ણાંક.

1128
01:10:20,850 --> 01:10:25,020
જો નિર્દેશક નલ છે, કે જે અર્થ એ થાય કે તે પૂરતી જગ્યા અથવા અમુક અન્ય ભૂલ આવી ન હતી,

1129
01:10:25,020 --> 01:10:26,320
જેથી હું મારા કાર્યક્રમની બહાર નીકળવા માટે કરવો જોઈએ.

1130
01:10:26,320 --> 01:10:29,400
 પરંતુ જો તે સફળ કર્યું છે, હવે હું કે નિર્દેશક ઉપયોગ કરી શકો છો

1131
01:10:29,400 --> 01:10:35,020
અને * નિર્દેશક કરે છે શું છે તે અનુસરે છે જ્યાં સરનામું છે

1132
01:10:35,020 --> 01:10:38,480
તે કિંમત છે, જ્યાં છે અને તેને 1 થી સમાન સુયોજિત કરે છે.

1133
01:10:38,480 --> 01:10:41,850
અહીં પર, અમે જો કે મેમરી અસ્તિત્વમાં ચકાસણી કરી રહ્યા છીએ.

1134
01:10:41,850 --> 01:10:45,380
>> એકવાર તમે જાણો છો તે હાજર હોય, તો તમે તેને મુકી શકે છે

1135
01:10:45,380 --> 01:10:50,460
આ 1 કિસ્સામાં; શું કિંમત તમે તેને મૂકવામાં માંગો છો.

1136
01:10:50,460 --> 01:10:53,060
એકવાર અમે તેને પૂર્ણ કરી લીધું છે, શું તમે તે નિર્દેશક મુક્ત કરવાની જરૂર છે

1137
01:10:53,060 --> 01:10:57,160
કારણ કે અમે સિસ્ટમ છે કે જે મેમરી કે તમે પ્રથમ સ્થાને માટે પૂછવામાં પાછા જરૂર છે.

1138
01:10:57,160 --> 01:10:59,690
કારણ કે કમ્પ્યૂટર ખબર નથી ત્યારે અમે તેને પૂર્ણ કરી લીધું છે.

1139
01:10:59,690 --> 01:11:02,510
આ કિસ્સામાં અમે તેને બાહ્ય રીતે કહેવાની કરી રહ્યાં છો, ઠીક, અમે તે મેમરી સાથે પૂર્ણ કરી લીધું.

1140
01:11:02,510 --> 01:11:10,780
જો અમુક અન્ય પ્રક્રિયા તેને જરૂર છે, કેટલાક અન્ય કાર્યક્રમ તેને જરૂર છે, માટે આગળ વધીશું અને તે લઈ શકો છો.

1141
01:11:10,780 --> 01:11:15,110
અમે પણ શું કરી શકો છો છે અમે સેટ પર સ્થાનિક ચલો ના સરનામા મેળવી શકો છો.

1142
01:11:15,110 --> 01:11:19,080
તેથી પૂર્ણાંક એક્સ મુખ્ય ના સ્ટૅક્ડ ફ્રેમ અંદર છે.

1143
01:11:19,080 --> 01:11:23,060
અને જ્યારે અમે આ & "અને" નું ચિહ્ન વાપરવા માટે, આ અને ઓપરેટર, તેને શું છે

1144
01:11:23,060 --> 01:11:27,310
તે x લે છે, અને એક્સ માત્ર મેમરી કેટલીક માહિતી છે, પરંતુ તે એક સરનામું છે.

1145
01:11:27,310 --> 01:11:33,790
તે ક્યાંક સ્થિત થયેલ છે. જેથી દ્વારા કૉલિંગ અને એક્સ, આ શું કરે છે તે અમને x ની સરનામું આપે છે.

1146
01:11:33,790 --> 01:11:38,430
આમ, અમે જ્યાં એક્સ મેમરીમાં છે નિર્દેશક બિંદુ બનાવી રહ્યા છો.

1147
01:11:38,430 --> 01:11:41,710
હવે અમે ફક્ત * કંઈક એક્સ નથી, અમે કરી રહ્યા છીએ 5 પાછી મેળવવા જઈ રહી છે.

1148
01:11:41,710 --> 01:11:43,820
આ તારો તે dereferencing કહેવામાં આવે છે.

1149
01:11:43,820 --> 01:11:46,640
તમે સરનામા અનુસરવા અને તમે તેને કિંમત ત્યાં સંગ્રહિત છે.

1150
01:11:51,000 --> 01:11:53,310
>> કોઈપણ પ્રશ્ન છે? હા?

1151
01:11:53,310 --> 01:11:56,500
[વિદ્યાર્થી] જો તમે આ વસ્તુ 3-પોઇન્ટેડ ન કરવું હોય, તો તે હજી પણ નથી કમ્પાઇલ?

1152
01:11:56,500 --> 01:11:59,490
હા. જો તમે વસ્તુ 3-નિર્દેશક ન કરવું હોય, તો તે હજી પણ કમ્પાઇલ ચાલી રહ્યું છે,

1153
01:11:59,490 --> 01:12:02,720
પરંતુ હું તમને બતાવે છે, શું કરશો બીજી બને છે અને તે કે આમ કર્યા વિના,

1154
01:12:02,720 --> 01:12:04,860
કે અમે શું મેમરી છિદ્ર કૉલ કરો. તમે સિસ્ટમ આપતા નથી કરી રહ્યાં છો

1155
01:12:04,860 --> 01:12:07,850
તેની મેમરી બેક, તેથી પછી જ્યારે કાર્યક્રમ માટે એકઠા રહ્યું છે

1156
01:12:07,850 --> 01:12:10,940
મેમરી કે તેનો ઉપયોગ નથી, અને તે જ બીજું કંઇ તેનો ઉપયોગ કરી શકો છો.

1157
01:12:10,940 --> 01:12:15,750
જો તમે ક્યારેય તમારા કમ્પ્યુટર પર 1.5 મિલિયન કિલોબાઈટોમાં સાથે કર્યું છે ફાયરફોક્સ જોવા મળે છે,

1158
01:12:15,750 --> 01:12:17,840
કાર્ય વ્યવસ્થાપક, તે શું થઈ રહ્યું છે.

1159
01:12:17,840 --> 01:12:20,760
તમારે કાર્યક્રમ છે કે તેઓ સંભાળાતા ન કરી રહ્યાં છો મેમરી છિદ્ર હોય છે.

1160
01:12:23,080 --> 01:12:26,240
આમ કેવી રીતે નિર્દેશક અંકગણિત કામ કરે છે?

1161
01:12:26,240 --> 01:12:29,480
વેલ, નિર્દેશક અંકગણિત ઝાકઝમાળ માં જેમ ઈન્ડેક્સીંગ જેવું છે.

1162
01:12:29,480 --> 01:12:36,370
આ કિસ્સામાં, હું એક નિર્દેશક હોય છે, અને હું શું છે હું પ્રથમ તત્વ માટે નિર્દેશક મુદ્દો

1163
01:12:36,370 --> 01:12:42,100
3 પૂર્ણાંકો કે હું ફાળવવામાં કર્યું છે આ ઍરેની.

1164
01:12:42,100 --> 01:12:46,670
તેથી હવે મારે શું કરવું, સ્ટાર નિર્દેશક માત્ર યાદીમાં પ્રથમ તત્વ બદલે છે.

1165
01:12:46,670 --> 01:12:49,140
સ્ટાર નિર્દેશક અહીં પર +1 નિર્દેશ કરે છે.

1166
01:12:49,140 --> 01:12:53,140
+1 નિર્દેશક, તેથી નિર્દેશક અહીં વધારે છે ઉપર અહીં છે, +2 નિર્દેશક પર અહીં છે.

1167
01:12:53,140 --> 01:12:56,610
>> તેથી ફક્ત 1 ઉમેરીને આ એરે સાથે થતાં જ વસ્તુ છે.

1168
01:12:56,610 --> 01:12:59,880
અમે શું છે, જ્યારે અમે +1 નિર્દેશક તમે અહીં ઉપર સરનામા વિચાર,

1169
01:12:59,880 --> 01:13:04,180
અને અહીં આ કિંમત વિચાર ક્રમમાં, તમે સમગ્ર અભિવ્યક્તિ માંથી એક તારો મૂકી

1170
01:13:04,180 --> 01:13:05,990
તેને ડિરેફરન્સ.

1171
01:13:05,990 --> 01:13:09,940
તેથી, આ કિસ્સામાં, હું 1 થી આ એરે માં પ્રથમ સ્થાન સુયોજિત છું,

1172
01:13:09,940 --> 01:13:13,970
2 બીજા સ્થાન, અને સ્થાન માટે 3 ત્રીજા સ્થાન.

1173
01:13:13,970 --> 01:13:18,180
પછી હું ઉપર કરી રહ્યો છું અહીં શું છે હું અમારા +1 નિર્દેશક છાપવા છું,

1174
01:13:18,180 --> 01:13:19,970
જે ફક્ત મને 2 આપે છે.

1175
01:13:19,970 --> 01:13:23,650
હવે હું નિર્દેશક incrementing છું, જેથી નિર્દેશક +1 નિર્દેશક સમકક્ષ,

1176
01:13:23,650 --> 01:13:26,780
જે તેને આગળ ખસે છે.

1177
01:13:26,780 --> 01:13:30,810
અને તેથી હવે જો હું +1 નિર્દેશક છાપો, નિર્દેશક +1 હવે 3,

1178
01:13:30,810 --> 01:13:33,990
આ કિસ્સામાં જે 3 છાપે છે.

1179
01:13:33,990 --> 01:13:36,560
અને ક્રમમાં મફત કંઈક તો, નિર્દેશક કે હું તેને આપી

1180
01:13:36,560 --> 01:13:40,540
એરે જે હું malloc માંથી પાછા મળી શરૂઆતમાં પોઇન્ટ હોવું જ જોઈએ.

1181
01:13:40,540 --> 01:13:43,430
તેથી, આ કિસ્સામાં, જો હું 3 અહીં કહી હતી, આ અધિકાર નહીં હોય,

1182
01:13:43,430 --> 01:13:45,070
કારણ કે તે એરે મધ્યમાં છે.

1183
01:13:45,070 --> 01:13:48,820
હું મૂળ સ્થાન મેળવવા સબ્ટ્રેક્ટ છે

1184
01:13:48,820 --> 01:13:50,420
પ્રારંભિક પ્રથમ સ્પોટ પહેલા હું તેને મુક્ત કરી શકો છો.

1185
01:13:56,300 --> 01:13:58,450
તેથી, અહીં વધુ સંકળાયેલી ઉદાહરણ છે.

1186
01:13:58,450 --> 01:14:03,360
આ કિસ્સામાં, અમે એક અક્ષર એરે માં 7 અક્ષરો allocating કરી રહ્યાં છો.

1187
01:14:03,360 --> 01:14:06,480
>> અને આ કિસ્સામાં અમે શું કરી રહ્યા છે અમે તેમને પ્રથમ 6 પર રહ્યાં રહ્યાં છો,

1188
01:14:06,480 --> 01:14:09,900
અને અમે તેમને ઝેડ માટે સુયોજિત કરી રહ્યાં છો

1189
01:14:09,900 --> 01:14:13,350
તેથી, પૂર્ણાંક માટે હું = 0, આઇ 6>, હું + +,

1190
01:14:13,350 --> 01:14:16,220
તેથી, નિર્દેશક + + હું અમને ફક્ત આ કિસ્સામાં આપવાની રહેશે,

1191
01:14:16,220 --> 01:14:20,860
નિર્દેશક, +1 નિર્દેશક, +2 નિર્દેશક, +3 નિર્દેશક, અને તેથી અને જેથી લુપમાં આગળ.

1192
01:14:20,860 --> 01:14:24,040
તે શું થઈ રહ્યું છે તે શું છે તે સરનામા નોંધાયો નહીં, dereferences તે કિંમત મેળવવા માટે,

1193
01:14:24,040 --> 01:14:27,440
અને ફેરફારો કે જે ઝેડ માટે કિંમત

1194
01:14:27,440 --> 01:14:30,350
પછી ઓવરને અંતે યાદ આ શબ્દમાળા છે અધિકાર?

1195
01:14:30,350 --> 01:14:33,560
બધા શબ્દમાળાઓ માટે નલ બંધ પાત્ર સાથે અંત હોય છે.

1196
01:14:33,560 --> 01:14:38,620
તેથી, હું શું છે 6 પોઇન્ટર હું સાઇન તેનો નલ ટર્મીનેટર પાત્ર મૂકી

1197
01:14:38,620 --> 01:14:43,980
અને હવે હું શું મૂળભૂત પર છું અહીં કરી printf શબ્દમાળા માટે યોગ્ય અમલીકરણ છે?

1198
01:14:43,980 --> 01:14:46,190
>> તેથી, printf હવે જ્યારે નથી જ્યારે તે છે એક શબ્દમાળાને અંતે પહોંચી?

1199
01:14:46,190 --> 01:14:48,230
જ્યારે તેને નલ બંધ અક્ષર બનાવ્યા.

1200
01:14:48,230 --> 01:14:52,030
તેથી, આ કિસ્સામાં, મારા આ એરે શરૂઆતમાં મૂળ નિર્દેશક નિર્દેશ કરે છે.

1201
01:14:52,030 --> 01:14:56,410
હું પ્રથમ અક્ષર છાપો આઉટ. હું તેને એક ખસેડો.

1202
01:14:56,410 --> 01:14:58,420
હું કે અક્ષર છાપો આઉટ. હું તેને ખસેડવા પર.

1203
01:14:58,420 --> 01:15:02,180
અને હું આ કરી ત્યાં સુધી હું ઓવરને સુધી પહોંચવા રાખો.

1204
01:15:02,180 --> 01:15:07,750
અને હવે ઓવરને * નિર્દેશક ડિરેફરન્સ આ અને નલ બંધ અક્ષર પાછા મળી જશે.

1205
01:15:07,750 --> 01:15:11,780
અને તેથી મારું જ્યારે લૂપ સ્કોર ત્યારે જ કે કિંમત નલ બંધ અક્ષર નથી.

1206
01:15:11,780 --> 01:15:13,770
તેથી, હવે હું આ લૂપની બહાર બહાર નીકળો.

1207
01:15:18,780 --> 01:15:21,180
અને તેથી જો હું આ નિર્દેશક થી 6 સબ્ટ્રેક્ટ,

1208
01:15:21,180 --> 01:15:22,860
હું પાછા શરૂઆતમાં તમામ માર્ગ પર જાઓ.

1209
01:15:22,860 --> 01:15:27,880
યાદ રાખો, હું આ કરી રહ્યો છું કારણ કે હું આ શરૂઆત પર જાઓ કરવા માટે તેને મુક્ત હોય છે.

1210
01:15:27,880 --> 01:15:30,270
>> તેથી, હું જાણું છું કે ઘણી મજા આવી. ત્યાં કોઇ પ્રશ્નો છે?

1211
01:15:30,270 --> 01:15:31,870
કૃપા કરીને, હા!

1212
01:15:31,870 --> 01:15:36,610
[વિદ્યાર્થી પ્રશ્ન દુર્બોધ]

1213
01:15:36,610 --> 01:15:38,190
કે જે તમને કહી શકું મોટેથી? માફ કરશો.

1214
01:15:38,190 --> 01:15:44,140
[વિદ્યાર્થી] છેલ્લી સ્લાઇડ અધિકાર પહેલાં તમે નિર્દેશક મુક્ત પર,

1215
01:15:44,140 --> 01:15:47,300
તમે ખરેખર જ્યાં હતા નિર્દેશક કિંમત બદલવા?

1216
01:15:47,300 --> 01:15:50,370
[જોસેફ] તેથી, અહીં. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.

1217
01:15:50,370 --> 01:15:51,890
[જોસેફ] તેથી, હું એક નિર્દેશક બાદ બાદ હોય, અધિકાર,

1218
01:15:51,890 --> 01:15:54,140
જે વસ્તુ એક પાછા ફરે છે અને પછી હું તેને મુક્ત,

1219
01:15:54,140 --> 01:15:57,000
કારણ કે આ નિર્દેશક માટે એરે શરૂઆત પર ધ્યાન હોય છે.

1220
01:15:57,000 --> 01:16:00,420
[વિદ્યાર્થી] પરંતુ તે હતી કે જે તમને લીટી પછી અટકાવાયેલ હોવો જરૂરી નથી કરશે.

1221
01:16:00,420 --> 01:16:03,130
તેથી [જોસેફ], જો હું આ બાદ બંધ થઇ ગયા હતા, આ મેમરી છિદ્ર લેવામાં આવે છે,

1222
01:16:03,130 --> 01:16:04,810
કારણ કે હું મુક્ત ન સ્કોર નહોતો.

1223
01:16:04,810 --> 01:16:11,290
[વિદ્યાર્થી] હું [દુર્બોધ] પ્રથમ ત્રણ લીટીઓ જ્યાં તમે +1 નિર્દેશક [દુર્બોધ] પડી ગયો.

1224
01:16:11,290 --> 01:16:13,140
[જોસેફ] ઉહ-ઓહ. તેથી ત્યાં પ્રશ્ન શું છે?

1225
01:16:13,140 --> 01:16:14,780
માફ કરશો. ના, કોઈ. જાઓ, જાઓ, કૃપા કરીને.

1226
01:16:14,780 --> 01:16:16,870
તેથી [વિદ્યાર્થી], તમે પોઇંટરો કિંમત નથી બદલી રહ્યાં છીએ.

1227
01:16:16,870 --> 01:16:19,130
તમે નિર્દેશક બાદ બાદ કરી ન હતી.

1228
01:16:19,130 --> 01:16:19,730
[જોસેફ] હા, બરાબર.

1229
01:16:19,730 --> 01:16:21,890
તેથી, જ્યારે હું +1 નિર્દેશક અને +2 નિર્દેશક કરવું

1230
01:16:21,890 --> 01:16:24,410
હું નિર્દેશક નથી કરી રહ્યો છું +1 નિર્દેશક સમકક્ષ હોય છે.

1231
01:16:24,410 --> 01:16:27,260
તેથી, નિર્દેશક માત્ર એરે શરૂઆતમાં પોઇન્ટ રહે.

1232
01:16:27,260 --> 01:16:31,460
તે માત્ર ત્યારે હું વત્તા કરવું વત્તા કે તે નિર્દેશક અંદર કિંમત પાછા સુયોજિત કરે છે,

1233
01:16:31,460 --> 01:16:33,550
કે તે ખરેખર સાથે આ ખસે છે.

1234
01:16:36,860 --> 01:16:37,780
અધિકાર છે.

1235
01:16:40,550 --> 01:16:42,030
વધુ પ્રશ્નો છે?

1236
01:16:44,680 --> 01:16:47,790
>> ફરીથી, જો આ જબરજસ્ત જેવું છે, આ સત્રમાં આવરી લેવામાં આવશે.

1237
01:16:47,790 --> 01:16:50,710
તે વિશે તમારા સાથી શિક્ષણ કહો, અને અમે ઓવરને અંતે પ્રશ્નોના જવાબ આપી શકે છે.

1238
01:16:53,510 --> 01:16:56,600
અને સામાન્ય રીતે અમે આ બાદ વસ્તુ નથી ગમતું નથી.

1239
01:16:56,600 --> 01:16:59,760
આ મને ખૂબ હું કેવી રીતે એરે માં સરભર કર્યું છે રાખવામાં આવેલ જરૂર છે.

1240
01:16:59,760 --> 01:17:04,520
તેથી, સામાન્ય રીતે, આ માત્ર છે કેવી રીતે નિર્દેશક અંકગણિત કામો સમજાવે છે.

1241
01:17:04,520 --> 01:17:07,970
પરંતુ અમે સામાન્ય રીતે કરવા માંગો શું અમે નિર્દેશક એક નકલ બનાવવા માંગતા હોય છે,

1242
01:17:07,970 --> 01:17:11,640
અને પછી અમે એ નકલ વાપરો જ્યારે અમે આસપાસ શબ્દમાળા માં ખસેડીએ છીએ પડશે.

1243
01:17:11,640 --> 01:17:14,660
તેથી, આ કિસ્સામાં તમે નકલ સમગ્ર શબ્દમાળા છાપો વાપરવા માટે,

1244
01:17:14,660 --> 01:17:19,040
પરંતુ અમે નિર્દેશક બાદ 6 જેવા કરવું નહિં હોય અથવા કેટલી અમે આ ખસેડવામાં ટ્રેક રાખવા માટે,

1245
01:17:19,040 --> 01:17:22,700
માત્ર કારણ કે અમે જાણીએ છીએ કે અમારા મૂળ બિંદુ હજુ યાદી શરૂઆત પર ધ્યાન છે

1246
01:17:22,700 --> 01:17:25,340
અને બધા કે અમે બદલાઈ આ નકલ હતી.

1247
01:17:25,340 --> 01:17:28,250
તેથી, સામાન્ય રીતે, તમારા મૂળ નિર્દેશક નકલો બદલે છે.

1248
01:17:28,250 --> 01:17:32,350
પ્રયત્ન કરશો નહિં જેવા સૉર્ટ - મૂળ નકલો બદલવા don't.

1249
01:17:32,350 --> 01:17:35,290
તમારા મૂળ માત્ર નકલો બદલવા પ્રયાસ કરે છે.

1250
01:17:41,540 --> 01:17:44,870
તેથી, તમે નોટિસ જ્યારે અમે printf માં શબ્દમાળા પસાર

1251
01:17:44,870 --> 01:17:48,990
તમે તેને આગળ એક તારો મૂકવા જેવા અમે તમામ અન્ય dereferences સાથે ન હોય તો, યોગ્ય છે?

1252
01:17:48,990 --> 01:17:54,180
તેથી, જો તમે છાપે સમગ્ર શબ્દમાળા:% s અપેક્ષા એક સરનામું છે,

1253
01:17:54,180 --> 01:17:57,610
અને આ કિસ્સામાં એક નિર્દેશક અથવા અક્ષરો ઝાકઝમાળ જેમ આ કિસ્સામાં.

1254
01:17:57,610 --> 01:18:00,330
>> અક્ષરો, ઘરનાં પરચૂરણ કામો * s છે, અને એરે જ વસ્તુ છે.

1255
01:18:00,330 --> 01:18:03,690
પોઇન્ટર અક્ષરો છે, અને પાત્ર એરે જ વસ્તુ છે.

1256
01:18:03,690 --> 01:18:05,720
અને તેથી, બધા અમે હોય તો નિર્દેશક પાસ છે.

1257
01:18:05,720 --> 01:18:08,150
અમે * નિર્દેશક અથવા તે જેવો કંઈ જેવી પાસ નથી.

1258
01:18:13,110 --> 01:18:14,930
તેથી, એરે અને પોઇંટરો એ જ વસ્તુ છે.

1259
01:18:14,930 --> 01:18:19,160
જ્યારે તમે એક્સ કંઈક કરી રહ્યા છીએ એક એરે માટે અહીં પર [y],

1260
01:18:19,160 --> 01:18:21,960
તે હૂડ હેઠળ કરવાનું છે શું છે તે કહેતા છે, ઠીક છે, તે એક અક્ષર એરે છે,

1261
01:18:21,960 --> 01:18:23,690
જેથી તે એક નિર્દેશક છે.

1262
01:18:23,690 --> 01:18:26,510
અને તેથી એક્સ એ જ વસ્તુ છે,

1263
01:18:26,510 --> 01:18:28,650
અને તેથી તે શું કરે છે તે એક્સ માટે વાય ઉમેરે છે,

1264
01:18:28,650 --> 01:18:31,820
જે મેમરી આગળ કે ખૂબ થતાં જ વસ્તુ છે.

1265
01:18:31,820 --> 01:18:34,930
અને હવે એક્સ + + વાય અમને સરનામા અમુક પ્રકારની આપે છે,

1266
01:18:34,930 --> 01:18:37,570
અને અમે સરનામા ડિરેફરન્સ અથવા તીર અનુસરો

1267
01:18:37,570 --> 01:18:41,640
મેમરીમાં તે સ્થાન છે કે જ્યાં અને અમે મેમરી કે સ્થાન મૂલ્ય મેળવવા.

1268
01:18:41,640 --> 01:18:43,720
તેથી, તેથી આ બે બરાબર એ જ વસ્તુ છે.

1269
01:18:43,720 --> 01:18:45,840
તે માત્ર એક વાકયરચનામાં ખાંડ છે.

1270
01:18:45,840 --> 01:18:48,090
તેઓ આ જ વાત કરે છે. તેઓ દરેક અન્ય માટે માત્ર વિવિધ syntactics છો.

1271
01:18:51,500 --> 01:18:57,590
>> તેથી, શું પોઇન્ટર સાથે ખોટું જઇ શકો છો? જેમ, લોટ. ઠીક છે. તેથી, ખરાબ વસ્તુઓ.

1272
01:18:57,590 --> 01:19:02,410
કેટલાક ખરાબ વસ્તુઓ તમે કરી શકો છો, જો તમારી malloc કોલ નલ અધિકાર આપે છે તપાસી રહ્યા નથી કરી રહ્યાં છો?

1273
01:19:02,410 --> 01:19:06,560
આ કિસ્સામાં, હું સિસ્ટમ પૂછવા છું મને આપી - કે જે નંબર શું છે?

1274
01:19:06,560 --> 01:19:11,200
2 અબજ 4 વખત જેમ, કારણ કે એક પૂર્ણાંક કદ 4 બાઇટ્સ છે.

1275
01:19:11,200 --> 01:19:13,810
હું તેના માટે 8 અબજ બાઇટ્સ જેવી પૂછવા છું.

1276
01:19:13,810 --> 01:19:17,270
અલબત્ત મારા કમ્પ્યુટરને માટે મને તે બહુ મેમરી પાછા આપી શકશે નહિં રહ્યું છે.

1277
01:19:17,270 --> 01:19:20,960
અને અમે જો આ નલ નથી તપાસ કરી ન હતી, તેથી જ્યારે અમે તેને ત્યાં પર ડિરેફરન્સ પ્રયત્ન -

1278
01:19:20,960 --> 01:19:24,270
જ્યાં તે ચાલી રહ્યું છે તેને તીર અનુસરો - અમે કે મેમરી નથી.

1279
01:19:24,270 --> 01:19:27,150
આ છે જેને આપણે નલ નિર્દેશક dereferencing કૉલ કરો.

1280
01:19:27,150 --> 01:19:29,710
અને આ અનિવાર્યપણે તમે segfault માટે કારણ બને છે.

1281
01:19:29,710 --> 01:19:31,790
આ એક રીતે તમે segfault શકે છે.

1282
01:19:34,090 --> 01:19:38,090
અન્ય ખરાબ વસ્તુઓ તમે કરી શકો છો - ઓહ છે.

1283
01:19:38,090 --> 01:19:40,650
કે જે નલ નિર્દેશક dereferencing હતી. ઠીક છે.

1284
01:19:40,650 --> 01:19:45,160
અન્ય ખરાબ વસ્તુઓ છે - ઠીક છે, કે જે તમે હમણાં જ ત્યાં એક ચેક મૂકી

1285
01:19:45,160 --> 01:19:46,980
કે ચકાસે છે કે શું નિર્દેશક નલ છે

1286
01:19:46,980 --> 01:19:51,000
અને કાર્યક્રમ બહાર બહાર નીકળવા જો તે બને છે કે malloc એક નલ નિર્દેશક આપે છે.

1287
01:19:55,110 --> 01:19:59,850
કે xkcd કોમિક છે. લોકો હવે તેને સમજો. ના સૉર્ટ કરો.

1288
01:20:06,120 --> 01:20:09,350
>> તેથી મેમરી. અને હું આ પર ગયા હતા.

1289
01:20:09,350 --> 01:20:12,000
અમે લુપ માં malloc કૉલ કરી રહ્યાં છો, પરંતુ દર વખતે આપણે malloc કૉલ

1290
01:20:12,000 --> 01:20:14,370
અમે જ્યાં આ નિર્દેશક તરફ ઇશારો છે ટ્રેક ગુમાવી રહ્યાં છો,

1291
01:20:14,370 --> 01:20:15,750
કારણ કે અમે તેનો clobbering કરી રહ્યાં છો.

1292
01:20:15,750 --> 01:20:18,410
તેથી, malloc પ્રારંભિક કૉલ મને આપે મેમરી અહીં બનાવ્યા.

1293
01:20:18,410 --> 01:20:19,990
મારા માટે આ નિર્દેશક પોઇન્ટર.

1294
01:20:19,990 --> 01:20:23,020
હવે, હું તો તેને મુક્ત નથી, તેથી હવે હું malloc ફરી કૉલ કરો.

1295
01:20:23,020 --> 01:20:26,070
હવે તે ઉપર અહીં નિર્દેશ કરે છે. હવે મારી મેમરી ઉપર અહીં પોઇન્ટ છે.

1296
01:20:26,070 --> 01:20:27,640
ઉપર અહીં પોઇન્ટિંગ. ઉપર અહીં પોઇન્ટિંગ.

1297
01:20:27,640 --> 01:20:31,820
પરંતુ હું અહીં કે હું ફાળવવામાં પર તમામ મેમરી સરનામાંઓ ટ્રેક ગુમાવ્યું છે.

1298
01:20:31,820 --> 01:20:35,100
અને તેથી હવે હું તેમને કોઇ સંદર્ભ હવે નથી.

1299
01:20:35,100 --> 01:20:37,230
તેથી, હું તેમને આ લૂપની બહાર નથી મુક્ત કરી શકો છો.

1300
01:20:37,230 --> 01:20:39,390
અને તેથી ક્રમમાં આ કંઈક ઠીક કરવા માટે,

1301
01:20:39,390 --> 01:20:42,250
જો તમે મુક્ત મેમરી માટે ભૂલી જાઓ અને તમે આ મેમરી છિદ્ર વિચાર,

1302
01:20:42,250 --> 01:20:45,810
તમે આ લૂપની અંદર મેમરી મુક્ત એકવાર તમે તેને પૂર્ણ કરી લીધું છે.

1303
01:20:45,810 --> 01:20:51,400
વેલ, આ છે શું થાય છે. મને ખબર છે કે ઘણાં બધાં આ અપ્રિય.

1304
01:20:51,400 --> 01:20:55,270
પરંતુ હવે - યે! You 44.000 કિલોબાઈટોમાં જેવા મળે છે.

1305
01:20:55,270 --> 01:20:57,110
તેથી, તો તમે તેને લૂપ ઓવરને અંતે મુક્ત,

1306
01:20:57,110 --> 01:20:59,770
અને તે માત્ર મેમરી દર વખતે મુક્ત બનશે.

1307
01:20:59,770 --> 01:21:03,620
આવશ્યકપણે, તમારા કાર્યક્રમ મેમરી છિદ્ર હવે નથી.

1308
01:21:03,620 --> 01:21:08,150
>> અને હવે બીજું કંઈક તમે કરી શકો છો અમુક મેમરી કે તમે બે વાર માટે પૂછ્યું છે મુક્ત.

1309
01:21:08,150 --> 01:21:11,060
આ કિસ્સામાં, તમે malloc કંઈક, તમે તેની કિંમત બદલો.

1310
01:21:11,060 --> 01:21:13,140
તમે તેને મુક્ત છે કારણ કે તમે એક વખત જણાવ્યું હતું કે તેની સાથે કરવામાં આવી હતી.

1311
01:21:13,140 --> 01:21:14,940
પરંતુ તે પછી અમે તેને ફરીથી મુક્ત કર્યા હતા.

1312
01:21:14,940 --> 01:21:16,730
આ એવું કંઈક છે જે ખૂબ ખરાબ આપી છે.

1313
01:21:16,730 --> 01:21:18,820
તે શરૂઆતમાં segfault નથી ચાલી રહ્યું છે,

1314
01:21:18,820 --> 01:21:23,350
પરંતુ પછી શું ડબલ છે, આ બગડેલ તમારા ઢગલો માળખું મુક્ત કરીને જ્યારે,

1315
01:21:23,350 --> 01:21:27,200
અને તમે થોડો વધુ આ વિશે જાણવા માટે જો તમે CS61 જેવા વર્ગ લેવા પસંદ કરશો.

1316
01:21:27,200 --> 01:21:30,000
પરંતુ અનિવાર્યપણે એક પછી જ્યારે તમારી કમ્પ્યુટર ગુંચવણ ના થવી રહ્યું છે

1317
01:21:30,000 --> 01:21:33,010
મેમરી સ્થાનો શું છે જ્યાં જ્યાં અને તે સંગ્રહિત વિશે -

1318
01:21:33,010 --> 01:21:34,800
માહિતી મેમરીમાં જ્યાં સંગ્રહાયેલ છે.

1319
01:21:34,800 --> 01:21:38,080
અને તેથી નિર્દેશક મુક્ત કરીને બે વખત ખરાબ ચીજ છે કે તમે કરવા માંગતા નહિં હોય છે.

1320
01:21:38,080 --> 01:21:41,600
>> અન્ય વસ્તુઓ છે કે જે ખોટી જઈ શકે છે sizeof ઉપયોગ કરતા નથી.

1321
01:21:41,600 --> 01:21:44,460
તેથી, આ કિસ્સામાં તમે 8 બાઇટ્સ malloc,

1322
01:21:44,460 --> 01:21:46,700
અને તે બે પૂર્ણાંકો તરીકે જ વસ્તુ અધિકાર છે?

1323
01:21:46,700 --> 01:21:49,580
તેથી, કે સંપૂર્ણપણે સલામત છે, પરંતુ તે છે?

1324
01:21:49,580 --> 01:21:52,160
વેલ, તરીકે લુકાસ વિવિધ આર્કિટેક્ચરો પર વિશે વાત કરી,

1325
01:21:52,160 --> 01:21:54,220
પૂર્ણાંકો વિવિધ લંબાઈનો છે.

1326
01:21:54,220 --> 01:21:57,970
તેથી ઉપકરણ કે જે તમે ઉપયોગ કરી રહ્યાં છો પર, પૂર્ણાંકો લગભગ 4 બાઇટ્સ હોય છે,

1327
01:21:57,970 --> 01:22:02,370
પરંતુ અમુક અન્ય સિસ્ટમ પર તેઓ 8 બાઇટ્સ હોઈ શકે છે અથવા તેઓ 16 બાઇટ્સ હોઈ શકે.

1328
01:22:02,370 --> 01:22:05,680
તેથી, જો હું હમણાં જ અહીં ઉપર આ નંબરનો ઉપયોગ,

1329
01:22:05,680 --> 01:22:07,310
આ કાર્યક્રમ ઉપકરણ પર કામ કરી શકે છે,

1330
01:22:07,310 --> 01:22:10,360
પરંતુ તે કેટલાક અન્ય સિસ્ટમ પર પૂરતી મેમરી ફાળવી નથી ચાલી રહ્યું છે.

1331
01:22:10,360 --> 01:22:14,020
આ કિસ્સામાં, આ છે શું sizeof ઓપરેટર માટે વપરાય છે.

1332
01:22:14,020 --> 01:22:16,880
જ્યારે આપણે કહી (પૂર્ણાંક) sizeof, કરે શું છે

1333
01:22:16,880 --> 01:22:21,910
 અમને સિસ્ટમ છે કે જે કાર્યક્રમ ચાલી રહ્યો છે તેના પર એક પૂર્ણાંક માપ આપે છે.

1334
01:22:21,910 --> 01:22:25,490
તેથી, આ કિસ્સામાં, sizeof (પૂર્ણાંક) એ સાધન કંઈક પર 4 આપશે,

1335
01:22:25,490 --> 01:22:29,980
અને હવે આ ઇચ્છા 4 2 *, કે જે 8 છે,

1336
01:22:29,980 --> 01:22:32,330
જે ફક્ત બે પૂર્ણાંકો માટે જરૂરી જગ્યા જથ્થો છે.

1337
01:22:32,330 --> 01:22:36,710
અલગ સિસ્ટમ પર, જો પૂર્ણાંક 16 બાઇટ્સ કે 8 બાઇટ્સ જેવી છે,

1338
01:22:36,710 --> 01:22:39,380
તે માત્ર એટલા બાઇટ્સ પરત કે જથ્થો સ્ટોર ચાલી રહ્યું છે.

1339
01:22:41,830 --> 01:22:45,310
>> અને છેલ્લે, સ્ટ્ર્ક્ટ્સ.

1340
01:22:45,310 --> 01:22:48,340
તેથી, જો તમે મેમરીમાં સુડોકુ બોર્ડ સંગ્રહવા માંગો, તો અમે કેવી રીતે આવું કરી શકે છે?

1341
01:22:48,340 --> 01:22:51,570
તમે પ્રથમ વસ્તુ માટે એક ચલ જેવા લાગે શકે છે,

1342
01:22:51,570 --> 01:22:53,820
બીજી વસ્તુ માટે એક ચલ, ત્રીજા વસ્તુ માટે એક ચલ,

1343
01:22:53,820 --> 01:22:56,420
ખરાબ, જમણી - ચોથા વસ્તુ માટે એક ચલ?

1344
01:22:56,420 --> 01:23:00,750
તેથી, એક સુધારણા તમે આ શીર્ષ પર કરી શકો છો એક 9 x 9 એરે માટે છે.

1345
01:23:00,750 --> 01:23:04,480
કે દંડ છે, પરંતુ જો તમે સુડોકુ બોર્ડ સાથે અન્ય વસ્તુઓ સાંકળવા માગે છે

1346
01:23:04,480 --> 01:23:06,490
ગમે બોર્ડના મુશ્કેલી શું છે,

1347
01:23:06,490 --> 01:23:11,740
અથવા, ઉદાહરણ તરીકે, તમારી સ્કોર શું છે, અથવા કેટલી સમયે તે તમે આ બોર્ડને હલ કરવા માટે લઈ જાય છે?

1348
01:23:11,740 --> 01:23:14,970
સારું, તમે શું કરી શકો છો છે તમે સ્ટ્રક્ટ બનાવી શકો છો.

1349
01:23:14,970 --> 01:23:18,910
હું મૂળભૂત કહી રહ્યો છું શું છે હું અહીં પર આ માળખું વ્યાખ્યાયિત છું,

1350
01:23:18,910 --> 01:23:23,230
અને હું એક સુડોકુ બોર્ડ જે બોર્ડ જે 9 છે 9 એક્સ સમાવે વ્યાખ્યાયિત છું.

1351
01:23:23,230 --> 01:23:26,650
>> અને તે શું છે તે સ્તર ના નામ પોઇન્ટર છે.

1352
01:23:26,650 --> 01:23:30,730
તે પણ એક્સ અને વાય છે, જે જ્યાં હું હમણાં છું એ કોઓર્ડિનેટ્સ છે.

1353
01:23:30,730 --> 01:23:35,980
તે પણ સમય [દુર્બોધ] ખર્ચ્યા છે, અને તે ચાલ હું અત્યાર સુધી ઇનપુટ કર્યું છે કુલ સંખ્યા ધરાવે છે.

1354
01:23:35,980 --> 01:23:40,010
અને તેથી આ કિસ્સામાં, હું હમણાં જ એક માળખામાં માહિતી સંપૂર્ણ જથ્થો જૂથ કરી શકો છો

1355
01:23:40,010 --> 01:23:42,790
તેના બદલે તે વિવિધ આસપાસ variables જેવી ઉડાન જેવી રહી ઓફ

1356
01:23:42,790 --> 01:23:44,540
કે હું ખરેખર ટ્રેક ન રાખે શકો છો.

1357
01:23:44,540 --> 01:23:49,720
અને આ દે અમને ફક્ત આ સ્ટ્રક્ટ ની અંદર અલગ વસ્તુઓ સંદર્ભ જેવું માટે સરસ વાક્યરચના છે.

1358
01:23:49,720 --> 01:23:53,430
હું board.board ફક્ત કરવા માટે, અને હું સુડોકુ બોર્ડ પાછા મેળવી શકો છો.

1359
01:23:53,430 --> 01:23:56,320
Board.level, હું વિચાર ખડતલ તે કેવી રીતે છે.

1360
01:23:56,320 --> 01:24:00,540
Board.x અને board.y મને જ્યાં હું બોર્ડ હોઇ શકે એ કોઓર્ડિનેટ્સ આપે છે.

1361
01:24:00,540 --> 01:24:04,730
અને તેથી હું ઍક્સેસ છું અમે શું સ્ટ્રક્ટ ક્ષેત્રો કૉલ કરો.

1362
01:24:04,730 --> 01:24:08,840
આ sudokuBoard છે, કે જે પ્રકારની છે કે હું હોય છે વ્યાખ્યાયિત કરે છે.

1363
01:24:08,840 --> 01:24:14,800
અને હવે અમે અહીં છીએ. હું એક પ્રકાર sudokuBoard "ની બોર્ડ" કહેવાય ચલ હોય છે.

1364
01:24:14,800 --> 01:24:18,820
અને તેથી હવે હું તમામ ક્ષેત્રો કે અહીં ઉપર આ માળખું બનાવે છે ઍક્સેસ કરી શકો છો.

1365
01:24:20,830 --> 01:24:22,450
>> સ્ટ્ર્ક્ટ્સ વિશે કોઈ પ્રશ્ન? હા?

1366
01:24:22,450 --> 01:24:25,890
પૂર્ણાંક એક્સ, વાય માટે [વિદ્યાર્થી], તમે એક વાક્ય પર બંને જાહેર? >> [જોસેફ] ઉહ-ઓહ.

1367
01:24:25,890 --> 01:24:27,400
[વિદ્યાર્થી] તેથી, તો તમે ફક્ત તેને તમામ સાથે કરી શકે?

1368
01:24:27,400 --> 01:24:31,200
એક્સ જેમ, વાય અલ્પવિરામ વખત કુલ છે કે?

1369
01:24:31,200 --> 01:24:34,460
[જોસેફ] હા, તમે ચોક્કસપણે કે શું કરી શકે છે, પરંતુ કારણ હું એ જ લાઇન પર એક્સ અને વાય મૂકે છે -

1370
01:24:34,460 --> 01:24:36,330
અને એક પ્રશ્ન છે કે શા માટે આપણે માત્ર એક જ વાક્ય પર આ શું કરી શકું?

1371
01:24:36,330 --> 01:24:38,600
અમે ફક્ત આ જ વાક્ય પર શા માટે નથી આ બધી મૂકી છે

1372
01:24:38,600 --> 01:24:42,090
એક્સ અને વાય દરેક અન્ય સાથે સંબંધિત છે,

1373
01:24:42,090 --> 01:24:44,780
અને આ માત્ર stylistically વધુ યોગ્ય એક અર્થમાં છે,

1374
01:24:44,780 --> 01:24:46,600
કારણ કે તે જ લાઇન પર બે વસ્તુઓ જૂથબદ્ધ છે

1375
01:24:46,600 --> 01:24:49,340
જેમ સૉર્ટ જ વસ્તુ સાથે રહેલો છે.

1376
01:24:49,340 --> 01:24:51,440
અને મેં હમણાં જ આ સિવાય વિભાજિત. તે માત્ર એક શૈલી વાત છે.

1377
01:24:51,440 --> 01:24:53,720
તે વિધેયાત્મક રીતે કોઈ પ્રકારની તફાવત બનાવે છે.

1378
01:24:58,150 --> 01:24:59,270
સ્ટ્ર્ક્ટ્સ પર કોઈપણ અન્ય પ્રશ્નો છે?

1379
01:25:03,030 --> 01:25:06,620
તમે સ્ટ્રક્ટ સાથે Pokédex વ્યાખ્યાયિત કરી શકો છો.

1380
01:25:06,620 --> 01:25:11,720
એક Pokémon ધરાવે છે અને તેને એક પત્ર, એક માલિક, એક પ્રકાર છે.

1381
01:25:11,720 --> 01:25:16,990
અને પછી જો તમે Pokémon ઝાકઝમાળ હોય, તો તમારે એક Pokédex બનાવવા માટે, યોગ્ય શકે?

1382
01:25:16,990 --> 01:25:20,810
ઠીક છે કૂલ. તેથી, સ્ટ્ર્ક્ટ્સ પર પ્રશ્નો. તે સ્ટ્ર્ક્ટ્સ સંબંધિત છે.

1383
01:25:20,810 --> 01:25:25,270
>> છેલ્લે, GDB. GDB શું તમને છે? તે તમને તમારા કાર્યક્રમ ડિબગ.

1384
01:25:25,270 --> 01:25:27,650
અને જો તમે GDB ઉપયોગ કર્યો નથી, હું ટૂંકા જોવાનું ભલામણ કરશે

1385
01:25:27,650 --> 01:25:31,250
અને માત્ર GDB શું છે ઉપર જઈને, તો તમે તેને કેવી રીતે સાથે કામ કરે છે, તમે કેવી રીતે તેનો ઉપયોગ થઇ શકે છે,

1386
01:25:31,250 --> 01:25:32,900
અને તે એક કાર્યક્રમ પર પરીક્ષણ.

1387
01:25:32,900 --> 01:25:37,400
અને તેથી GDB શું તમને નથી તે [દુર્બોધ] તમારા કાર્યક્રમ વિરામ દે

1388
01:25:37,400 --> 01:25:38,920
અને વ્યવહારુ રેખા.

1389
01:25:38,920 --> 01:25:42,600
ઉદાહરણ તરીકે, હું મારા કાર્યક્રમ 3 લીટી જેવા અટકશે અમલ કરવા માંગો છો,

1390
01:25:42,600 --> 01:25:46,010
અને જ્યારે હું 3 વાક્ય પર છું હું તમામ કિંમતો કે ત્યાં છાપી શકે છે.

1391
01:25:46,010 --> 01:25:49,710
અને તેથી આપણે શું કહી જેવી લીટી માં pausing

1392
01:25:49,710 --> 01:25:52,350
છે અમે આ તે લીટી પર બ્રેકપોઇન્ટ મૂકવા કહી

1393
01:25:52,350 --> 01:25:55,920
અને પછી અમે તે સમયે કાર્યક્રમ રાજ્યના ખાતે ચલો છાપી શકો છો.

1394
01:25:55,920 --> 01:25:58,990
>> અમે પછી ત્યાં કાર્યક્રમ વાક્ય દ્વારા વાક્ય મારફતે પગલું કરી શકો છો.

1395
01:25:58,990 --> 01:26:03,200
અને પછી અમે સ્ટેક રાજ્ય સમયે દેખાય છે.

1396
01:26:03,200 --> 01:26:08,600
અને તેથી ક્રમમાં GDB, અમે શું છે અમે સી ફાઇલ પર રણકાર કૉલ કરવા,

1397
01:26:08,600 --> 01:26:11,290
પણ અમે તેને-ggdb ધ્વજ પસાર હોય છે.

1398
01:26:11,290 --> 01:26:15,850
અને એકવાર અમે પૂર્ણ કરી લો કે અમે ફક્ત પરિણામી આઉટપુટ ફાઇલ પર gdb ચલાવો.

1399
01:26:15,850 --> 01:26:18,810
અને તેથી તમે આ જેવા કેટલાક લખાણને જેવા સામૂહિક વિચાર,

1400
01:26:18,810 --> 01:26:21,990
પરંતુ ખરેખર તમામ તમારે કરવા આદેશો માં શરૂઆતમાં લખો છે.

1401
01:26:21,990 --> 01:26:24,250
ભંગ મુખ્ય મુખ્ય ખાતે બ્રેકપોઇન્ટ મૂકે છે.

1402
01:26:24,250 --> 01:26:28,470
400 યાદી લાઇન 400 આસપાસ કોડ લીટીઓ યાદી આપે છે.

1403
01:26:28,470 --> 01:26:31,410
અને તેથી આ કિસ્સામાં તમે હમણાં આસપાસ નજર કરી શકો છો અને કહે છે, ઓહ,

1404
01:26:31,410 --> 01:26:34,360
હું 397 વાક્ય પર એક બ્રેકપોઇન્ટ, કે જે આ વાક્ય છે સેટ કરવા માંગો છો,

1405
01:26:34,360 --> 01:26:37,170
અને પછી તમારા કાર્યક્રમ છે કે જે પગલું માં ચાલે છે અને તે તોડી રહ્યું છે.

1406
01:26:37,170 --> 01:26:41,120
તે ત્યાં વિરામ માટે ચાલી રહ્યું છે, અને તમે છાપે છે, ઉદાહરણ તરીકે કરી શકો છો, અથવા ઓછા ઊંચા મૂલ્ય.

1407
01:26:41,120 --> 01:26:46,410
અને તેથી આદેશો તમે જાણવા જરૂર સમૂહ છે,

1408
01:26:46,410 --> 01:26:48,660
અને આ સ્લાઇડશો અપ વેબસાઈટ પર જશે,

1409
01:26:48,660 --> 01:26:54,000
તેથી જો તમે માત્ર આ સંદર્ભ કરવા માંગો છો અથવા માંગતા તેમને તમારા ખાણિયાઓને છેતરે શીટ્સ પર મૂકવા મફત લાગે.

1410
01:26:54,000 --> 01:27:00,650
>> સરસ. કે ક્વિઝ 0 સમીક્ષા હતી, અને અમે આસપાસ વળગી જો તમને કોઈ પ્રશ્નો હશે.

1411
01:27:00,650 --> 01:27:03,850
અધિકાર છે.

1412
01:27:03,850 --> 01:27:09,030
>>  [વધાવી]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]