1
00:00:00,000 --> 00:00:09,780
>> [MUSIC ప్లే]

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
>> OK.

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
OK, కాబట్టి యొక్క ఈ బ్రేక్ వీలు
నిర్వహించటానికి భాగాలుగా.

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
OK.

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
ఆ రెండు కాంబినేషన్ కంటే ఇతర none
నాలుగు బైట్లు.

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
నేను ఒక నిర్మాణం ప్రాతినిధ్యం చేసిన
చిత్రరూపంలో ఈ మెమరీ కార్డ్

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 వినుడు ఇది
కలిగిన struct లో పడుతుంది

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
OK, అది చదవడానికి?

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
OK.

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
Well, మేము ఉపయోగించే చూడాలని ఒక
ఫంక్షన్ sprintf అని.

81
00:04:34,310 --> 00:04:38,260
Printf పోలి కొద్దిగా, పేరు
మీరు, తీగలను కోసం placeholders ఉపయోగించవచ్చు

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
>> OK.

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
>> OK.

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
>> ఇప్పుడు, గమనించదగ్గ ఒక ముఖ్యమైన విషయం
మీరు I / O ను ఉపయోగిస్తే

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 DOG, 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
నేను ఇక్కడ చేర్చాను ఇది pseudocode,.

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