1
00:00:00,000 --> 00:00:09,780
>> [સંગીત વગાડવાનો]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA ચાન: પુનઃપ્રાપ્ત માતાનો હલ કરીએ.

3
00:00:11,150 --> 00:00:14,030
પુનઃપ્રાપ્ત કદાચ મારી પ્રિય pset છે,
અને મુખ્યત્વે હું તેને લાગે છે, કારણ કે

4
00:00:14,030 --> 00:00:15,650
ખરેખર, ખરેખર સરસ.

5
00:00:15,650 --> 00:00:19,040
મૂળભૂત રીતે, તમે મેમરી આપવામાં રહ્યા છો
કાર્ડ ફાઇલ કે જેમાં

6
00:00:19,040 --> 00:00:20,900
ચિત્રો કાઢી નાખવામાં આવ્યા છે.

7
00:00:20,900 --> 00:00:23,650
પરંતુ જો તમે રહ્યા છીએ
શું તેમને બધા વસૂલ છે.

8
00:00:23,650 --> 00:00:24,250
>> બરાબર.

9
00:00:24,250 --> 00:00:28,230
તેથી કદાચ તે ખરેખર આકર્ષક છે, પરંતુ
તમે, કારણ કે થોડી લાવનારાઓ

10
00:00:28,230 --> 00:00:32,430
ખાલી સી ફાઈલ અને આપવામાં
તમે તેને સાઇન ભરવા માટે છે

11
00:00:32,430 --> 00:00:36,250
ઠીક છે, તેથી આપણે આ તોડી દો
વ્યવસ્થા ભાગો છે.

12
00:00:36,250 --> 00:00:38,160
તમે ખોલવા માંગો છો પડશે
મેમરી કાર્ડ ફાઇલ.

13
00:00:38,160 --> 00:00:39,900
તે પર્યાપ્ત સરળ લાગે છે.

14
00:00:39,900 --> 00:00:43,030
પછી, શરૂઆતમાં શોધવા
એક JPG છબી.

15
00:00:43,030 --> 00:00:46,740
આ મેમરી પર તમામ ફાઇલો
કાર્ડ jpgs હશે આવે છે.

16
00:00:46,740 --> 00:00:50,840
પછી, એક વાર તમે શરૂઆત શોધવા
જો તમે નવી JPG ખોલવા જઈ રહ્યા છો

17
00:00:50,840 --> 00:00:57,610
, જેમ કે, એક JPG, બનાવવાની, અને 512 લખો છે
નવી JPG છે ત્યાં સુધી એક પછી બાઇટ

18
00:00:57,610 --> 00:01:02,930
જોવા મળે છે, અને કાર્યક્રમ અંત, એક વખત
તમે ફાઈલના અંતે શોધી શકે છે.

19
00:01:02,930 --> 00:01:06,400
>> તેથી પ્રથમ પગલાં પ્રથમ ખોલવા માટે છે
મેમરી કાર્ડ ફાઇલ.

20
00:01:06,400 --> 00:01:09,850
પરંતુ જો તમે પહેલાથી જ આ ખબર છે, અને ત્યાં
બનશે કે ફાઈલ I / O નો કાર્ય

21
00:01:09,850 --> 00:01:12,030
ખૂબ જ ઉપયોગી સાબિત.

22
00:01:12,030 --> 00:01:12,820
બરાબર.

23
00:01:12,820 --> 00:01:14,760
તેથી jpgs શું છે?

24
00:01:14,760 --> 00:01:16,330
અમે શરૂઆતમાં તે જરૂર છે.

25
00:01:16,330 --> 00:01:21,310
વેલ, jpgs, માત્ર થોડી નકશા જેવા,
માત્ર બાઇટ્સ ક્રમ છે.

26
00:01:21,310 --> 00:01:30,660
સદભાગ્યે, દરેક JPG ક્યાં સાથે શરૂ થાય છે
0xff, 0xd8, 0xff, 0xe0, માત્ર એક ક્રમ

27
00:01:30,660 --> 00:01:33,610
ના બાઇટ્સ, અથવા અન્ય
બાઇટ્સ ક્રમ.

28
00:01:33,610 --> 00:01:37,250
>> તેથી તે ચાર બાઇટ્સ સૂચવે
એક JPG શરૂઆત.

29
00:01:37,250 --> 00:01:40,780
તે બે સંયોજનો આપે છે
ચાર બાઇટ્સ.

30
00:01:40,780 --> 00:01:44,840
અને સદભાગ્યે આપણા માટે, અન્ય હકીકત એ છે કે આપણે
લાભ લઈ શકે છે કે દરેક

31
00:01:44,840 --> 00:01:48,550
JPG બાજુ દ્વારા બાજુ સંગ્રહ કરવામાં આવે છે
મેમરી કાર્ડ પર.

32
00:01:48,550 --> 00:01:52,210
હું એક માળખું રજૂ કર્યું
schematically આ મેમરી કાર્ડ

33
00:01:52,210 --> 00:01:53,310
અહીં સ્લાઇડ.

34
00:01:53,310 --> 00:01:59,270
અહીં, દરેક ચોરસ, લંબચોરસ દરેક,
512 બાઇટ્સ રજૂ કરે છે, અને તે શરૂ થાય છે

35
00:01:59,270 --> 00:02:01,750
અમે કે જે એક ગ્રે સાથે
ખરેખર એક JPG છે.

36
00:02:01,750 --> 00:02:05,700
>> પરંતુ તે પછી અમે આખરે ફટકો
એક સ્ટાર સાથે બ્લોક.

37
00:02:05,700 --> 00:02:10,940
તે અર્થ એ થાય કે પ્રથમ ચાર બાઇટ્સ બહાર
તે 512 તે બે એક છે

38
00:02:10,940 --> 00:02:13,230
એક JPG ક્રમ શરૂ થાય છે.

39
00:02:13,230 --> 00:02:17,340
અને અમે એક વાર પછી ત્યાંથી જાય છે, અને
એક JPG આગામી એક શરૂ થાય છે, અંત થાય છે.

40
00:02:17,340 --> 00:02:20,990
અમે ક્યારેય કોઇ વધુ ન હોય
તેની વચ્ચે ગ્રે જગ્યા.

41
00:02:20,990 --> 00:02:25,550
>> પરંતુ કેવી રીતે અમે ખરેખર આ વાંચો, અને નથી
અમે કરી શકો છો કે જેથી 512 બાઇટ્સ વાંચી

42
00:02:25,550 --> 00:02:27,500
સરખામણી પ્રથમ સ્થાન?

43
00:02:27,500 --> 00:02:33,470
વેલ, જે પાછા fread પર જાઓ જે
સમાવે છે સ્ટ્રક્ટ માં લઈ જાય છે

44
00:02:33,470 --> 00:02:34,470
તમે વાંચી રહ્યા છો તે બાઇટ્સ.

45
00:02:34,470 --> 00:02:36,570
તેથી તમે મૂકી રહ્યા છીએ
ત્યાં તે -

46
00:02:36,570 --> 00:02:42,192
કદ, સંખ્યા, અને પછી inpointer
તમે માંથી વાંચવા રહ્યાં છે.

47
00:02:42,192 --> 00:02:49,900
હવે, અમે એક સમયે 512 વાંચી શકો છો, અને
અમે એક બફર આ સંગ્રહ કરવા માંગો,

48
00:02:49,900 --> 00:02:50,700
હું તેને કહું જાઉં છું.

49
00:02:50,700 --> 00:02:54,100
>> મૂળભૂત રીતે, અમે પકડી રહ્યા છીએ
તે 512 બાઇટ્સ પર અને શું

50
00:02:54,100 --> 00:02:55,500
તે સાથે વસ્તુઓ, અધિકાર?

51
00:02:55,500 --> 00:02:58,260
અમે ક્યાં તો પ્રથમ કરો રહ્યા છીએ
ચાર બાઇટ્સ, અથવા આપણે રહ્યા છીએ

52
00:02:58,260 --> 00:02:59,830
ઠીક છે, તેમાંથી વાંચે?

53
00:02:59,830 --> 00:03:05,050
તેથી પછી ડેટા નિર્દેશક ત્યાર પછી
તમારા બફર તરીકે સેવા, અને

54
00:03:05,050 --> 00:03:07,745
inpointer, સાથે સાથે, કે જે હમણાં જ ચાલી રહ્યું છે
તમારી મેમરી કાર્ડ છે.

55
00:03:07,745 --> 00:03:09,500
>> અમારા મેમરી કાર્ડ યોજનાકીય પર પાછા.

56
00:03:09,500 --> 00:03:14,690
અમે એક સમયે 512 બાઇટ્સ વાંચી રહ્યા છીએ,
દરેક 512 બાઇટ બ્લોક સ્ટોર

57
00:03:14,690 --> 00:03:19,190
એક બફર માં, હોલ્ડિંગ તે પર
આપણે જાણીએ છીએ, ત્યાં સુધી, તે 512 બાઇટ્સ બફર

58
00:03:19,190 --> 00:03:22,000
બરાબર શું કરવું જોઈએ.

59
00:03:22,000 --> 00:03:25,960
તેથી શરૂઆતમાં કંઈપણ નથી, તેથી
અમે બફર વાંચી તે કરો, અને પડશે

60
00:03:25,960 --> 00:03:28,160
અમે તેની સાથે કંઈ પણ કરવા માટે જરૂર નથી.

61
00:03:28,160 --> 00:03:32,030
અને પછી, અમે આખરે એક તારો હિટ
અમે કર્યું છે કે, જેનો અર્થ થાય અવરોધિત

62
00:03:32,030 --> 00:03:33,630
અમારી પ્રથમ JPG મળ્યાં નથી.

63
00:03:33,630 --> 00:03:36,560
તેથી બફર હવે પકડી
કે JPG બાઈટ્સ.

64
00:03:36,560 --> 00:03:40,220
>> તેઓ 512 બાઇટ્સ, કારણ કે આગામી સમય
નથી એક સ્ટાર બ્લોક, પણ છે

65
00:03:40,220 --> 00:03:41,740
કે JPG ભાગ છે.

66
00:03:41,740 --> 00:03:47,630
અને JPGS ત્યાંથી સતત છે
પર હવે પછીના JPG હિટ, ત્યાં સુધી માં.

67
00:03:47,630 --> 00:03:51,880
અને પછી બફર પછી ધરાવે છે
512 કે JPG માટે બાઇટ્સ, અને

68
00:03:51,880 --> 00:03:53,580
તેથી, અને તેથી આગળ.

69
00:03:53,580 --> 00:03:54,250
બરાબર.

70
00:03:54,250 --> 00:03:58,980
>> તમે પ્રથમ તારાંકિત હિટ તેથી એક વખત
બ્લોક, પ્રથમ JPG, તમે કેવી રીતે કરવું

71
00:03:58,980 --> 00:04:01,910
ખરેખર, સાથે સાથે, તેને ખોલવા?

72
00:04:01,910 --> 00:04:04,990
ચાલો એક નવી JPG બનાવીએ.

73
00:04:04,990 --> 00:04:08,846
એક JPG માટે ફાઈલ નામો જવું છે
આ બંધારણમાં જ હોવી, નંબર, નંબર,

74
00:04:08,846 --> 00:04:13,830
number.jpg, કે તેઓ રાખવામાં આવ્યું રહ્યા છો
તેઓ જોવા મળે છે કે જેમાં ક્રમ,

75
00:04:13,830 --> 00:04:14,780
0 શરૂ.

76
00:04:14,780 --> 00:04:19,890
>> જેથી પ્રથમ JPG કે જો તમારી પાસે
શોધવા 000.jpg કરવામાં આવશે.

77
00:04:19,890 --> 00:04:26,560
તેથી, કદાચ એક સારો વિચાર ટ્રેક રાખવા માટે
તમે અત્યાર સુધી મળી છે કે કેટલા jpgs.

78
00:04:26,560 --> 00:04:27,610
જેથી ફાઇલ નામ છે.

79
00:04:27,610 --> 00:04:29,660
પરંતુ તમે કેવી રીતે વાસ્તવમાં તે કરી શકું?

80
00:04:29,660 --> 00:04:34,310
વેલ, અમે ઉપયોગ જઈ રહ્યાં છો એક
કાર્ય sprintf છે.

81
00:04:34,310 --> 00:04:38,260
માટે સમાન printf એક થોડો છે, જ્યાં
તમે શબ્દમાળાઓ માટે જગ્યામાં ઉપયોગ કરી શકો છો

82
00:04:38,260 --> 00:04:42,420
આ કિસ્સામાં સિવાય sprintf છાપશે
વર્તમાન ફાઇલ બહાર

83
00:04:42,420 --> 00:04:45,550
ડિરેક્ટરી, બિન ટર્મિનલ માં.

84
00:04:45,550 --> 00:04:46,120
>> બરાબર.

85
00:04:46,120 --> 00:04:49,950
અહીં અમે અમે શીર્ષક છે કે નહીં તે જોવા,
સ્ટોર છે કે જે ઘરનાં પરચૂરણ કામો એરે

86
00:04:49,950 --> 00:04:55,120
પરિણામે શબ્દમાળા, અને અમે પાસ
એક સાથે વાસ્તવિક શબ્દમાળા શીર્ષક

87
00:04:55,120 --> 00:04:58,720
પ્લેસહોલ્ડર, માત્ર અમે દીધું છે
printf સાથે કરી શીખ્યા.

88
00:04:58,720 --> 00:05:05,530
પરંતુ હું અહીં છે કે આ કોડ
2.jpg નથી 002.jpg આપશે.

89
00:05:05,530 --> 00:05:09,920
તેથી હું તે જાણવા માટે તમારા માટે છોડી જાય છે કેવી રીતે
બનાવવા માટે પ્લેસહોલ્ડર સુધારવા પાંચ

90
00:05:09,920 --> 00:05:11,920
સાચું નામ.

91
00:05:11,920 --> 00:05:12,610
>> બરાબર.

92
00:05:12,610 --> 00:05:17,390
તેથી એક વખત તમે તમે આ કરી શકો તો પછી sprintf'd છે
તે અસ્તિત્વ ધરાવે છે, કારણ કે, તે ફાઇલ ખોલો

93
00:05:17,390 --> 00:05:22,690
fopen સાથે તમારા ડિરેક્ટરી, મદદથી
શીર્ષક, અને તમે ઇચ્છો તો પછી ગમે સ્થિતિ

94
00:05:22,690 --> 00:05:25,140
સાઇન તે ફાઈલ ખોલવા માટે

95
00:05:25,140 --> 00:05:30,260
તેથી હવે અમે નવા JPG ફાઇલ ખોલી કરી લીધી છે,
હવે અમે એક પર 512 બાઇટ્સ લખી શકો છો

96
00:05:30,260 --> 00:05:33,320
નવી JPG જોવા મળે છે ત્યાં સુધી સમય,.

97
00:05:33,320 --> 00:05:36,640
તેથી આપણે અન્ય નજર
fwrite ની સિન્ટેક્ષ છે.

98
00:05:36,640 --> 00:05:40,060
>> હું આ સ્લાઇડ દર્શાવે છું ખબર છે કે
ઘણા છે, પરંતુ હું માત્ર તેની ખાતરી કરવા માંગો છો

99
00:05:40,060 --> 00:05:43,530
તમે ગાય્ઝ પણ ગેરસમજ મળી નથી કારણ કે
હું તે ખૂબ જ સરળ છે ખબર છે કે

100
00:05:43,530 --> 00:05:47,000
પ્રથમ અને છેલ્લા મિશ્રણ
દલીલ, ખાસ કરીને.

101
00:05:47,000 --> 00:05:54,390
પરંતુ તમને આ લખી રહ્યાં યાદ રાખો કે
બહાર ફાઇલ છબીઓ તમારા બફર.

102
00:05:54,390 --> 00:05:59,250
>> હવે તમે જાણો છો કે કેવી રીતે લખવા 512
તમે કર્યું છે કે જે તમારા JPG ફાઇલમાં બાઇટ્સ

103
00:05:59,250 --> 00:06:03,230
બનાવનાર, સાથે સાથે, અમે તે બંધ કરવા માંગો છો
અમે અંત સુધી પહોંચી ગયા છો પ્રક્રિયા એક વખત

104
00:06:03,230 --> 00:06:06,720
અમારા કાર્ડ, કારણ કે ત્યાં નહીં
જોવા મળે છે કોઇ વધુ છબીઓ.

105
00:06:06,720 --> 00:06:10,760
તેથી આપણે fread પર પાછા જાઓ
વધુ એક વખત, હું વચન.

106
00:06:10,760 --> 00:06:15,600
fread કદ ઘણી વસ્તુઓ કેવી રીતે આપે છે,
કદ, સફળતાપૂર્વક માં તૈયાર હતા.

107
00:06:15,600 --> 00:06:19,440
આદર્શ રીતે, આ પ્રયત્ન રહ્યું છે ગમે
તમે, નંબર માટે પાસ?

108
00:06:19,440 --> 00:06:24,140
તમે નંબર વાંચી પ્રયાસ કરી રહ્યા છો કારણ કે
કદ, કદ તત્વો.

109
00:06:24,140 --> 00:06:29,380
પરંતુ fread કે વાંચી શકતા ન હોય તો
તત્વો નંબર છે, પછી તે પરત મળશે

110
00:06:29,380 --> 00:06:32,530
તે સફળતાપૂર્વક વાંચી ગમે સંખ્યા.

111
00:06:32,530 --> 00:06:36,310
>> હવે, નોંધ કરવાની એક મહત્વની બાબત છે
કે તમે મને / કંઈપણ બીજી ફાઇલ વાપરો તો

112
00:06:36,310 --> 00:06:43,860
fgetc જેમ કાર્ય છે, તે પણ પરત મળશે
તે સફળતાપૂર્વક વાંચી ઘણી વસ્તુઓ કેવી રીતે.

113
00:06:43,860 --> 00:06:48,000
શું આ કાર્ય વિશે ઉપયોગી છે છે
કે તમે અંદર કાર્યો ઉપયોગ જો

114
00:06:48,000 --> 00:06:53,190
શરત, તે જ્યારે પોતે ચલાવવા પડશે
છે કે સ્થિતિ, નક્કી

115
00:06:53,190 --> 00:06:54,340
માત્ર ખરેખર ઉપયોગી છે.

116
00:06:54,340 --> 00:07:00,440
તેથી જો તમે આ શરતો હોય છે, જેમ કે,
જો fread બફર, sizeof કૂતરો, 2,

117
00:07:00,440 --> 00:07:04,870
નિર્દેશક, 1 સમકક્ષ સમકક્ષ હોય છે કે
હું વાંચી કરવા માંગો છો કે જે થાય છે

118
00:07:04,870 --> 00:07:06,540
સમયે 2 ડોગ્સ.

119
00:07:06,540 --> 00:07:13,490
પરંતુ fread તરીકે બદલે 2 1 આપે, તો
અપેક્ષા, કે 2 છે કે જે થાય છે

120
00:07:13,490 --> 00:07:16,480
શ્વાન મારા ફાઇલમાં બાકી છે, પરંતુ તેના બદલે 1.

121
00:07:16,480 --> 00:07:22,450
પરંતુ તે 2 આપે છે, પછી હું હજુ પણ છે
મારા બફર ની અંદર તે 2 ડોગ્સ.

122
00:07:22,450 --> 00:07:26,280
>> તેથી હવે તમે કેવી રીતે એક સમજ આપે છે
આ ફાઈલના અંતે માટે ચકાસો, પરંતુ

123
00:07:26,280 --> 00:07:28,940
હવે તર્ક મારફતે જાઓ.

124
00:07:28,940 --> 00:07:32,460
કેવી રીતે અમે ખરેખર તમામ ભાગ નથી
એક સાથે આ તત્વોની?

125
00:07:32,460 --> 00:07:36,880
અમે અમારી પ્રથમ JPG હિટ જાય, કારણ કે
અમે jpgs સંગ્રહાય છે ખબર છે કે

126
00:07:36,880 --> 00:07:40,910
નજીકના, અમે ત્યાં સુધી લખવા પડશે
અમે કાર્ડ ફાઈલના અંતે પહોંચે છે.

127
00:07:40,910 --> 00:07:43,950
પરંતુ અમે લખી નથી માંગતા
કંઈપણ ત્યાં સુધી.

128
00:07:43,950 --> 00:07:48,710
તેથી તે અમે પર છો કે માત્ર બાબતો,
આ નવી JPG શરૂ, પરંતુ કે શું

129
00:07:48,710 --> 00:07:50,655
અમે પહેલાથી જ એક JPG અથવા નથી મળ્યાં છે.

130
00:07:50,655 --> 00:07:55,390
>> એ એક નવો JPG શરૂઆત છે, તો અમે પડશે
અમારા વર્તમાન JPG ફાઇલ જો બંધ કરવા માંગો છો

131
00:07:55,390 --> 00:07:59,110
અમે એક ઓપન, અને ખુલ્લી છે
માં લખવા માટે કરી નવો.

132
00:07:59,110 --> 00:08:03,340
તે નવી JPG શરૂઆત નથી, તો
જોકે, અમે એ જ JPG ફાઇલને પડશે

133
00:08:03,340 --> 00:08:05,910
ખોલો અને તે માં લખો.

134
00:08:05,910 --> 00:08:10,100
અમે જે અમારા બફર લખીશ
અમે ખોલેલા JPG ફાઇલ, એ શરતે કે

135
00:08:10,100 --> 00:08:12,120
અમે અલબત્ત, એક ઓપન છે.

136
00:08:12,120 --> 00:08:16,190
અમે અમારી પ્રથમ JPG મળ્યા નથી તો
છતાં, આપણે કંઈ પણ લખો નહિં.

137
00:08:16,190 --> 00:08:20,290
અને આ પ્રક્રિયા તમે ત્યાં સુધી ચાલુ રહે છે
કાર્ડ ફાઈલના અંતે પહોંચે છે.

138
00:08:20,290 --> 00:08:23,410
>> અને છેલ્લે, તમે બનાવવા માંગો છો પડશે
જો તમે કોઇ fclose ખાતરી કરો કે

139
00:08:23,410 --> 00:08:25,800
તમે fopened કરેલો ફાઈલો.

140
00:08:25,800 --> 00:08:28,360
તમે સાથે આરામદાયક છો એકવાર
ખ્યાલો, કેટલાક પર એક નજર

141
00:08:28,360 --> 00:08:30,840
હું અહીં સમાવેશ કર્યા છે જે સ્યુડોકોડનો.

142
00:08:30,840 --> 00:08:34,830
પ્રથમ, તમે કાર્ડ ફાઇલ ખોલવા માંગો છો,
અને પછી નીચેનો પ્રક્રિયા પુનરાવર્તન

143
00:08:34,830 --> 00:08:37,144
તમે પહોંચી ગયા છો ત્યાં સુધી
કાર્ડ અંત થાય છે.

144
00:08:37,144 --> 00:08:40,880
તમે 512 બાઇટ્સ વાંચી શકો છો
એક બફર માં.

145
00:08:40,880 --> 00:08:43,934
કે બફર મદદથી, તમે તપાસ કરવા માંગો છો પડશે
તમે શરૂઆતમાં છો

146
00:08:43,934 --> 00:08:45,300
નવી JPG અથવા નથી.

147
00:08:45,300 --> 00:08:48,400
અને તે પ્રશ્નનો જવાબ આપશે
તમારી ફાઈલ વ્યવસ્થાપન અસર -

148
00:08:48,400 --> 00:08:51,940
જે તમે ફાઇલો ખોલો, જે
તમે જેના બંધ છે.

149
00:08:51,940 --> 00:08:55,220
>> પછી, તમે પહેલેથી જ JPG મળ્યા છે?

150
00:08:55,220 --> 00:08:57,740
તમે કેવી રીતે રાખી રહ્યું છે
કે ટ્રૅક?

151
00:08:57,740 --> 00:09:01,735
પછી, તો તેના પર આધાર રાખીને, તમે ક્યાં તો પડશે
વર્તમાન JPG માં લખો કે તમે

152
00:09:01,735 --> 00:09:07,090
તે બધા લખી ઓપન, અથવા ન હોય,
તમે હજુ સુધી એક JPG મળ્યા નથી છે.

153
00:09:07,090 --> 00:09:10,870
છેલ્લે, એક વાર તમે અંતના પહોંચી ગયા છો
ફાઇલ, તમે કોઈ પણ બંધ કરવા માંગો છો પડશે

154
00:09:10,870 --> 00:09:12,590
તમે ખોલેલા તે ફાઇલો બાકી.

155
00:09:12,590 --> 00:09:14,590
અમે અહીં વ્યવસ્થિત રાખવા માંગે છે.

156
00:09:14,590 --> 00:09:18,790
>> અને તે સાથે, તમે બધા પ્રાપ્ત છે
કે મેમરીમાંથી ગુમ થયેલ ફાઇલો

157
00:09:18,790 --> 00:09:21,620
એક ખૂબ સુંદર પરાક્રમ છે જે કાર્ડ,.

158
00:09:21,620 --> 00:09:23,430
તેથી પાછળ તમારા પેટ.

159
00:09:23,430 --> 00:09:27,560
પરંતુ, વધુ એક તત્વ છે
આ સ્પર્ધા છે જે pset,.

160
00:09:27,560 --> 00:09:30,920
તમે મળશે કે ચિત્રો તમામ
તમે પ્રાપ્ત કરી છે તે ખરેખર છે

161
00:09:30,920 --> 00:09:32,820
CS50 સ્ટાફ ચિત્રો.

162
00:09:32,820 --> 00:09:38,500
તેથી જો તમે કેમ્પસ પર અથવા બીજે છો
નજીક, તો પછી તમારી સાથે ચિત્રો લઇ શકે છે

163
00:09:38,500 --> 00:09:42,600
સ્ટાફ, અને છે કે વિભાગ
સ્ટાફ સભ્યો સાથે સૌથી વધુ ચિત્રો

164
00:09:42,600 --> 00:09:46,940
તેમના પ્રાપ્ત ફાઇલોની કરશે
એક અદ્ભુત ઇનામ વિષે.

165
00:09:46,940 --> 00:09:50,650
કે સાથે, પછી તમે પૂર્ણ કરી લો
પુનઃપ્રાપ્ત pset.

166
00:09:50,650 --> 00:09:53,600
મારું નામ Zamyla છે, અને આ CS50 છે.

167
00:09:53,600 --> 00:10:01,835