1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] ચાલો એરે વિશે વાત કરો.

2
00:00:09,360 --> 00:00:12,780
શા માટે કે જેથી અમે ક્યારેય એરે ઉપયોગ કરવા માંગો છો માંગો છો?

3
00:00:12,780 --> 00:00:17,210
વેલ દો કહો કે તમે એક કાર્યક્રમ છે કે જે 5 વિદ્યાર્થી ID ને સંગ્રહિત કરવાની જરૂર હોય છે.

4
00:00:17,210 --> 00:00:21,270
તે વાજબી જણાય છે માટે 5 અલગ ચલો હોય શકે છે.

5
00:00:21,270 --> 00:00:24,240
કારણો અમે બીટ માં જોશો માટે, અમે 0 થી ગણતરી શરૂ કરી શકશો.

6
00:00:24,240 --> 00:00:30,700
ચલો અમે પડશે પૂર્ણાંક id0, પૂર્ણાંક id1, અને તેથી હશે.

7
00:00:30,700 --> 00:00:34,870
કોઈપણ તર્ક અમે એક વિદ્યાર્થી ID પર કરવા માંગો નકલ અને તે પેસ્ટ કરવાની જરૂર પડશે

8
00:00:34,870 --> 00:00:36,870
આ વિદ્યાર્થી ID ની દરેક માટે.

9
00:00:36,870 --> 00:00:39,710
જો અમે તપાસ જે વિદ્યાર્થીઓને CS50 હોવા થાય માંગો છો,

10
00:00:39,710 --> 00:00:43,910
અમે પ્રથમ તપાસો જો id0 કોર્સ માં વિદ્યાર્થી પ્રતિનિધિત્વ કરવાની જરૂર પડશે.

11
00:00:43,910 --> 00:00:48,070
પછી આગામી વિદ્યાર્થી માટે પણ આવું જ, અમે નકલ અને id0 માટે કોડ પેસ્ટ કરવાની જરૂર પડશે

12
00:00:48,070 --> 00:00:54,430
અને id1 સાથે અને તેથી id2, 3, અને 4 માટે id0 તમામ ઘટનાઓ બદલો.

13
00:00:54,430 --> 00:00:57,560
>> જલદી તમે સાંભળો કે અમે કૉપિ અને પેસ્ટ કરેલો જરૂર છે,

14
00:00:57,560 --> 00:01:00,440
તમે વિચારીને કે ત્યાં એક વધુ સારો ઉકેલ છે શરૂ કરીશું.

15
00:01:00,440 --> 00:01:05,360
હવે જો તમે સમજો છો કે તમને 5 વિદ્યાર્થી ID ને જરૂર નથી પરંતુ તેના બદલે 7?

16
00:01:05,360 --> 00:01:09,570
તમે તમારા સ્રોત કોડમાં પાછા જાઓ અને એક id5 માં ઉમેરવાની જરૂર છે, id6 એક,

17
00:01:09,570 --> 00:01:14,260
અને નકલ કરો અને ચકાસણી માટે તર્કશાસ્ત્ર પેસ્ટ કરો જો ID ને આ 2 નવી ID માટે આ વર્ગના સભ્ય છે.

18
00:01:14,260 --> 00:01:19,600
આ તમામ ID ને એક સાથે જોડાઈ કંઈ નથી, અને તેથી ત્યાં કહેતી કોઈ રીત છે

19
00:01:19,600 --> 00:01:22,040
આ કાર્યક્રમ 6 મારફતે 0 ID માટે આ કરવા માટે.

20
00:01:22,040 --> 00:01:26,120
વેલ હવે તમે સમજો છો કે તમને 100 વિદ્યાર્થી ID હોય છે.

21
00:01:26,120 --> 00:01:30,770
તે આદર્શ કરતાં ઓછી હોવાનું જણાય છે માટે અલગથી આ ID ની દરેક જાહેર કરવાની જરૂર શરૂ છે,

22
00:01:30,770 --> 00:01:33,760
અને નકલ કરો અને તે નવા ID માટે કોઇ લોજીક પેસ્ટ કરો.

23
00:01:33,760 --> 00:01:38,380
પરંતુ કદાચ અમે નક્કી કરવામાં આવે છે, અને અમે તેને તમામ 100 વિદ્યાર્થીઓ માટે નથી.

24
00:01:38,380 --> 00:01:42,240
પરંતુ જો તમને ખબર નહિં હોય કે કેટલી વિદ્યાર્થીઓ ત્યાં ખરેખર શું છે?

25
00:01:42,240 --> 00:01:47,320
ત્યાં માત્ર કેટલાક n વિદ્યાર્થીઓ અને તમારા કાર્યક્રમ વપરાશકર્તા કે કઈ n છે પૂછી છે.

26
00:01:47,320 --> 00:01:50,250
ઓહો. આ ખૂબ જ સારી રીતે કામ નથી જઈ રહ્યા છે.

27
00:01:50,250 --> 00:01:53,820
તમારા કાર્યક્રમ માત્ર અમુક વિદ્યાર્થીઓ સતત નંબર માટે કામ કરે છે.

28
00:01:53,820 --> 00:01:57,520
>> આ સમસ્યાઓ ઉકેલવા તમામ એરે ની સુંદરતા છે.

29
00:01:57,520 --> 00:01:59,930
તેથી ઝાકઝમાળ શું છે?

30
00:01:59,930 --> 00:02:04,480
કેટલાક પ્રોગ્રામિંગ ભાષાઓ એક એરે પ્રકાર માટે થોડી વધુ કરવા સક્ષમ હોઈ શકો છો,

31
00:02:04,480 --> 00:02:09,960
પરંતુ, અહીં આપણે મૂળભૂત એરે માહિતી બંધારણ પર ધ્યાન કેન્દ્રિત જેમ તમે તેને સી માં જોશો પડશે

32
00:02:09,960 --> 00:02:14,030
ઝાકઝમાળ માત્ર મેમરી એક મોટી બ્લોક છે. આ તે છે.

33
00:02:14,030 --> 00:02:17,770
જ્યારે આપણે કહેવું અમે 10 પૂર્ણાંકો ઝાકઝમાળ છે, કે જે હમણાં જ અર્થ એ કે અમે કેટલાક બ્લોક હોય

34
00:02:17,770 --> 00:02:20,740
મેમરી કે તેટલા મોટા 10 અલગ પૂર્ણાંકો પકડી છે.

35
00:02:29,930 --> 00:02:33,410
એમ ધારી રહ્યા છીએ કે પૂર્ણાંક 4 બાઇટ્સ છે, એનો અર્થ એ કે 10 પૂર્ણાંકો ઝાકઝમાળ

36
00:02:33,410 --> 00:02:37,180
મેમરીમાં 40 બાઇટ્સ સતત બ્લોક છે.

37
00:02:42,660 --> 00:02:46,280
ત્યારે પણ તમે બહુપરીમાણીય એરે, જે અમે અહીં ન જાય વાપરવા માટે,

38
00:02:46,280 --> 00:02:49,200
તે હજુ પણ માત્ર મેમરી એક મોટી બ્લોક છે.

39
00:02:49,200 --> 00:02:51,840
આ બહુપરીમાણીય નોટેશનમાં માત્ર એક સગવડ છે.

40
00:02:51,840 --> 00:02:55,640
જો તમે 3 પૂર્ણાંકોના બહુપરીમાણીય એરે દ્વારા 3 એક છે,

41
00:02:55,640 --> 00:03:00,650
પછી તમારા કાર્યક્રમ ખરેખર માત્ર 36 બાઇટ્સ એક મોટી બ્લોક તરીકે આ માનશે.

42
00:03:00,650 --> 00:03:05,460
પૂર્ણાંકો કુલ સંખ્યા 3 3 વખત છે, અને દરેક પૂર્ણાંક અપ 4 બાઇટ્સ લે છે.

43
00:03:05,460 --> 00:03:07,750
>> ચાલો એક ઉદાહરણ મૂળભૂત પર એક નજર.

44
00:03:07,750 --> 00:03:10,660
અમે અહીં જાહેર એરે, 2 અલગ અલગ રીતે જોઈ શકે છે.

45
00:03:15,660 --> 00:03:18,580
અમે 1 તેના માટે કમ્પાઇલ કાર્યક્રમ માટે ટિપ્પણી પડશે

46
00:03:18,580 --> 00:03:20,900
કારણ કે અમે એક્સ બે વખત જાહેર.

47
00:03:20,900 --> 00:03:25,140
અમે એક બીટ માં જાહેરાતો આ 2 પ્રકારો વચ્ચે તફાવત કેટલાક પર એક નજર પડશે.

48
00:03:25,140 --> 00:03:28,560
આ રેખાઓ બંને કદ એન ઝાકઝમાળ જાહેર,

49
00:03:28,560 --> 00:03:30,740
અમે # જ્યાં 10 તરીકે છે એન વ્યાખ્યાયિત કરે છે.

50
00:03:30,740 --> 00:03:34,460
અમે હમણાં જ તરીકે સરળતાથી હકારાત્મક પૂર્ણાંક માટે કરી શકે છે વપરાશકર્તાને પૂછવામાં છે

51
00:03:34,460 --> 00:03:37,250
અને અમારા એરે માં તત્વોના નંબર કે પૂર્ણાંક ઉપયોગ થાય છે.

52
00:03:37,250 --> 00:03:41,960
અમારા વિદ્યાર્થી ID ને ઉદાહરણ પહેલાં જેમ, આ 10 સંપૂર્ણપણે અલગ જાહેર જેવા પ્રકારની છે

53
00:03:41,960 --> 00:03:49,000
કાલ્પનિક ચલો; એકસ 0, x1, x2, અને તેથી xN-1 માટે આ બોલ પર.

54
00:03:57,270 --> 00:04:00,840
લીટીઓ અવગણીને જ્યાં અમે એરે જાહેર, ચોરસ કૌંસ અકબંધ નોટિસ

55
00:04:00,840 --> 00:04:02,090
આંટીઓ માટે અંદર.

56
00:04:02,090 --> 00:04:09,660
જ્યારે અમે એક્સ કંઈક લખી [3], હું હમણાં જ એક્સ 3 કૌંસ તરીકે વાંચી શકશો કે જે,

57
00:04:09,660 --> 00:04:13,090
તમે તેને લાગે કે કાલ્પનિક એકસ 3 માટે પૂછતી પસંદ કરી શકો છો.

58
00:04:13,090 --> 00:04:17,519
કદ એન, કે કૌંસ ની અંદર સંખ્યા, આ અર્થ ઝાકઝમાળ કરતાં નોટિસ

59
00:04:17,519 --> 00:04:22,630
જે અમે ઇન્ડેક્સ કહી શકશો, 0 થી N-1 કંઈપણ હોઈ શકે છે,

60
00:04:22,630 --> 00:04:25,660
જે એન સૂચકાંકોના કુલ છે.

61
00:04:25,660 --> 00:04:28,260
>> કેવી રીતે કામ કરે છે અને આ ખરેખર વિશે વિચારો

62
00:04:28,260 --> 00:04:31,260
યાદ રાખો કે એરે મેમરી મોટા બ્લોક છે.

63
00:04:31,260 --> 00:04:37,460
એમ ધારી રહ્યા છીએ કે પૂર્ણાંક 4 બાઇટ્સ છે, સમગ્ર એરે એક્સ મેમરી એક 40 બાઇટ બ્લોક છે.

64
00:04:37,460 --> 00:04:41,360
તેથી એકસ 0 ખૂબ પ્રથમ બ્લોક નું 4 બાઇટ્સ ઉલ્લેખ કરે છે.

65
00:04:45,810 --> 00:04:49,230
એક્સ [1] પછીના 4 બાઇટ્સ અને તેથી ઉલ્લેખ કરે છે.

66
00:04:49,230 --> 00:04:53,760
આનો અર્થ એ થાય કે x ની શરૂઆતમાં તમામ કાર્યક્રમ ક્યારેય સાચવી રાખે જરૂર છે.

67
00:04:55,660 --> 00:04:59,840
જો તમે x [400] નો ઉપયોગ કરવા માંગો છો, તો પછી કાર્યક્રમ જાણે છે કે આ બરાબર છે

68
00:04:59,840 --> 00:05:03,460
x ની શરૂઆત પછી 1,600 બાઇટ્સ માત્ર છે.

69
00:05:03,460 --> 00:05:08,780
Where'd અમે માંથી 1,600 બાઇટ્સ મળી શકે? તે પૂર્ણાંક દીઠ માત્ર 400 4 વખત બાઇટ્સ છે.

70
00:05:08,780 --> 00:05:13,170
>> પર જતાં પહેલાં, તે ખૂબ જ મહત્વપૂર્ણ છે ખ્યાલ છે કે સી

71
00:05:13,170 --> 00:05:17,080
ત્યાં ઇન્ડેક્સ કે અમે એરે ઉપયોગ કોઈ અમલ છે.

72
00:05:17,080 --> 00:05:23,180
અમારા મોટા બ્લોક માત્ર 10 પૂર્ણાંકો લાંબો છે, પરંતુ કંઇ અમને અંતે કિકિયારી જો આપણે x [20] લખશે

73
00:05:23,180 --> 00:05:26,060
અથવા તો x [-5].

74
00:05:26,060 --> 00:05:28,240
ઇન્ડેક્સ પણ એક સંખ્યા હોવી નથી.

75
00:05:28,240 --> 00:05:30,630
તેને કોઈપણ મનસ્વી અભિવ્યક્તિ હોઈ શકે છે.

76
00:05:30,630 --> 00:05:34,800
કાર્યક્રમ અમે ના એરે માં ઇન્ડેક્સ લૂપ માટે ચલ હું વાપરો.

77
00:05:34,800 --> 00:05:40,340
આ એક ખૂબ જ સામાન્ય પેટર્ન છે, આઇ = 0 થી એરે લંબાઈના રહ્યાં,

78
00:05:40,340 --> 00:05:43,350
અને પછી હું એરે માટે અનુક્રમણિકા તરીકે ઉપયોગ થાય છે.

79
00:05:43,350 --> 00:05:46,160
આ તમે સમગ્ર એરે પર અસરકારક રીતે લૂપ રીતે,

80
00:05:46,160 --> 00:05:50,600
અને તમે ક્યાં તો એરે દરેક સ્પોટ સોંપી શકે છે અથવા તેને કેટલીક ગણતરી માટે ઉપયોગ કરે છે.

81
00:05:50,600 --> 00:05:53,920
>> લૂપ માટે પ્રથમ, આઇ 0 પર શરૂ થાય છે,

82
00:05:53,920 --> 00:05:58,680
અને તેથી તે એરે માં 0 સ્પોટ, કિંમત 2 0 ગણી અસાઇન કરશે.

83
00:05:58,680 --> 00:06:04,370
પછી ઇન્ક્રીમેન્ટ આઇ, અને અમે એરે મૂલ્ય 1 જોવાયા 2 માં પ્રથમ સ્પોટ સોંપો.

84
00:06:04,370 --> 00:06:10,170
પછી પર હું ફરીથી અને તેથી ઇન્ક્રીમેન્ટ સુધી અમે એરે માં એન-1 પોઝિશન સોંપી

85
00:06:10,170 --> 00:06:13,370
મૂલ્ય N-1 2 વખત.

86
00:06:13,370 --> 00:06:17,810
તેથી અમે પ્રથમ 10 બેકી ક્રમાંકો સાથે એરે બનાવી છે.

87
00:06:17,810 --> 00:06:21,970
કદાચ evens એક્સ કરતાં ચલ માટે બીટ વધુ સારી નામ હતું,

88
00:06:21,970 --> 00:06:24,760
પરંતુ તે વસ્તુઓ છે દૂર આપવામાં આવશે.

89
00:06:24,760 --> 00:06:30,210
લૂપ માટે બીજા પછી માત્ર કિંમતો કે અમે પહેલાથી જ એરે ની અંદર સંગ્રહાય છે છાપે છે.

90
00:06:30,210 --> 00:06:33,600
>> ચાલો એરે જાહેરાતો બંને પ્રકારના કાર્યક્રમ ચલાવવાનો પ્રયત્ન

91
00:06:33,600 --> 00:06:36,330
અને કાર્યક્રમ આઉટપુટ પર એક નજર.

92
00:06:51,450 --> 00:06:57,020
જ્યાં સુધી આપણે જોઈ શકે છે, આ કાર્યક્રમ જાહેરાતો બંને પ્રકારના માટે એ જ રીતે વર્તે છે.

93
00:06:57,020 --> 00:07:02,230
ચાલો પણ શું થાય પર એક નજર જો અમે પ્રથમ લૂપ બદલી એન અંતે અટકાવવા માટે નથી

94
00:07:02,230 --> 00:07:05,040
પરંતુ 10,000 કહો.

95
00:07:05,040 --> 00:07:07,430
એરે ઓવરને બહાર વે.

96
00:07:14,700 --> 00:07:17,210
અરે. કદાચ તમે આ જોઇ છે તે પહેલાં.

97
00:07:17,210 --> 00:07:20,440
એક સેગ્મેન્ટેશન ક્ષતિમાં અર્થ છે તમારા કાર્યક્રમ ક્રેશ થયું છે.

98
00:07:20,440 --> 00:07:24,430
તમે આ જોવાનું શરૂ જ્યારે તમે મેમરી વિસ્તારોમાં તમે સ્પર્શ જોઇએ નહિં સ્પર્શ.

99
00:07:24,430 --> 00:07:27,870
અહીં અમે x ની શરૂઆતમાં આગળ 10,000 સ્થળોએ સ્પર્શ કરવામાં આવે છે,

100
00:07:27,870 --> 00:07:31,920
જે દેખીતી રીતે મેમરીમાં સ્થાન અમે સ્પર્શ જોઇએ નહિં છે.

101
00:07:31,920 --> 00:07:37,690
અમને મોટા ભાગના તેથી કદાચ આકસ્મિક 10,000 એન બદલે મૂકી શકે છે,

102
00:07:37,690 --> 00:07:42,930
પરંતુ જો અમે વધુ જેવી ગૂઢ કંઈક લખવા કરતાં ઓછી અથવા એન સમાન કહેવું

103
00:07:42,930 --> 00:07:46,830
માટે લૂપ શરત તરીકે વિરોધ માં એન કરતા ઓછી

104
00:07:46,830 --> 00:07:50,100
યાદ રાખો કે એક એરે માત્ર 0 થી N-1 માટે સૂચકાંકો ધરાવે છે,

105
00:07:50,100 --> 00:07:54,510
જેનો અર્થ છે કે ઇન્ડેક્સ એન એરે ઓવરને બહાર છે.

106
00:07:54,510 --> 00:07:58,050
આ કાર્યક્રમ આ કેસ નથી તૂટી છે, પરંતુ તે હજુ પણ એક ભૂલ છે શકે છે.

107
00:07:58,050 --> 00:08:01,950
હકીકતમાં, આ ભૂલ જેથી સામાન્ય કે તે પોતાના નામ છે,

108
00:08:01,950 --> 00:08:03,970
1 ભૂલ કરીને નહીં.

109
00:08:03,970 --> 00:08:05,970
>> કે તે મૂળભૂત માટે છે.

110
00:08:05,970 --> 00:08:09,960
તેથી એરે જાહેરાતો ના 2 પ્રકારો વચ્ચે મુખ્ય તફાવત શું છે?

111
00:08:09,960 --> 00:08:13,960
એક તફાવત છે જ્યાં મેમરી મોટા બ્લોક જાય છે.

112
00:08:13,960 --> 00:08:17,660
પ્રથમ ઘોષણા, જે હું પ્રકાર કૌંસ-એરે કહી શકશો,

113
00:08:17,660 --> 00:08:20,300
જોકે આ દ્વારા કોઈ એક પરંપરાગત નામ એનો અર્થ એ થાય

114
00:08:20,300 --> 00:08:22,480
તે સ્ટેક પર જાય છે.

115
00:08:22,480 --> 00:08:27,450
બીજી, જે હું પ્રકાર નિર્દેશક-એરે કહી શકશો, જ્યારે તે ઢગલો પર જાય છે.

116
00:08:27,450 --> 00:08:32,480
આનો અર્થ એ થાય કે જ્યારે કાર્ય વળતર, કૌંસ એરે આપોઆપ deallocated આવશે,

117
00:08:32,480 --> 00:08:36,419
જેમ તમે explicitily પોઇન્ટર એરે પર મફત કૉલ કરવો આવશ્યક છે જ્યારે

118
00:08:36,419 --> 00:08:38,010
અથવા તો તમે મેમરી છિદ્ર હોય છે.

119
00:08:38,010 --> 00:08:42,750
વધુમાં, કૌંસ એરે ખરેખર એક ચલ નથી.

120
00:08:42,750 --> 00:08:45,490
આ અગત્યનું છે. તે માત્ર એક પ્રતીક છે.

121
00:08:45,490 --> 00:08:49,160
તમે તેને સતત કે કમ્પાઇલર તમે પસંદ તરીકે વિચાર કરી શકો છો.

122
00:08:49,160 --> 00:08:52,970
આનો અર્થ એ થાય કે અમે એક્સ + + કૌંસ પ્રકાર સાથે કંઈક ન કરી શકો,

123
00:08:52,970 --> 00:08:56,240
જોકે આ સંપૂર્ણપણે પોઇન્ટર પ્રકાર સાથે માન્ય છે.

124
00:08:56,240 --> 00:08:58,270
>> આ નિર્દેશક પ્રકાર ચલ છે.

125
00:08:58,270 --> 00:09:01,510
પોઇન્ટર પ્રકાર માટે, અમે મેમરી 2 અલગ બ્લોક્સ ધરાવે છે.

126
00:09:01,510 --> 00:09:06,060
આ ચલ પોતે એક્સ સ્ટેક માં સંગ્રહાય છે અને માત્ર એક નિર્દેશક છે,

127
00:09:06,060 --> 00:09:08,620
પરંતુ મેમરી મોટા બ્લોક ઢગલો પર સંગ્રહાયેલ છે.

128
00:09:08,620 --> 00:09:11,010
સ્ટેક પર ચલ x ફક્ત સરનામા સંગ્રહ કરે છે

129
00:09:11,010 --> 00:09:14,010
આ ઢગલો પર મેમરી મોટા બ્લોક છે.

130
00:09:14,010 --> 00:09:17,370
આ એક સૂચિતાર્થ ઓપરેટર માપ સાથે છે.

131
00:09:17,370 --> 00:09:22,480
જો તમે કૌંસમાં એરે માપ માટે પૂછો, તો તે તમને મેમરી મોટા બ્લોક માપ આપશે,

132
00:09:22,480 --> 00:09:24,620
40 બાઇટ્સ કંઈક,

133
00:09:24,620 --> 00:09:26,920
પરંતુ જો તમે ઍરેના નિર્દેશક પ્રકારના કદ માટે પૂછો,

134
00:09:26,920 --> 00:09:32,740
તે તમને ચલ x પોતે જ, કે જે ઉપકરણ પર થવાની શક્યતા છે ફક્ત 4 બાઇટ્સ માપ આપશે.

135
00:09:32,740 --> 00:09:36,530
પ્રકાર નિર્દેશક-એરે મદદથી, તે અશક્ય છે સીધી માટે પૂછો

136
00:09:36,530 --> 00:09:38,530
મેમરી મોટા બ્લોક માપ.

137
00:09:38,530 --> 00:09:42,530
આ સામાન્ય રીતે પ્રતિબંધ મોટા થી અમે ખૂબ જ ભાગ્યે જ માપ કરવા માંગો છો નથી

138
00:09:42,530 --> 00:09:46,980
ની મેમરી મોટા બ્લોક, અને અમે સામાન્ય રીતે તે ગણતરી જો અમે તેને જરૂર કરી શકો છો.

139
00:09:46,980 --> 00:09:51,490
>> છેલ્લે, કૌંસ એરે માટે અમને એક એરે પ્રારંભ માટે એક શોર્ટકટ પ્રદાન થાય છે.

140
00:09:51,490 --> 00:09:56,130
ચાલો જોવા અમે કેવી રીતે પ્રથમ 10 પણ શૉર્ટકટ initilization મદદથી પૂર્ણાંકો લખી શકે છે.

141
00:10:11,220 --> 00:10:14,470
પોઇન્ટર એરે સાથે, ત્યાં આ જેવા શોર્ટકટ કરવા રસ્તો નથી.

142
00:10:14,470 --> 00:10:18,120
આ માત્ર તમે શું એરે સાથે કરી શકો પરિચય છે.

143
00:10:18,120 --> 00:10:20,990
તેઓ લગભગ દરેક કાર્યક્રમ તમે લખી માં બતાવે છે.

144
00:10:20,990 --> 00:10:24,390
આસ્થાપૂર્વક તમે હવે વિદ્યાર્થી ID ને ઉદાહરણ કરવાનું સારી રીતે જોઈ શકે છે

145
00:10:24,390 --> 00:10:26,710
વિડિઓ શરૂઆત છે.

146
00:10:26,710 --> 00:10:29,960
>> મારું નામ રોબ બોડેન છે, અને આ CS50 છે.