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, int id1, மற்றும் பல இருக்கும்.

7
00:00:30,700 --> 00:00:34,870
நாம் ஒரு மாணவர் அடையாள நிகழ்ச்சி செய்ய வேண்டும் எந்த தர்க்கம் நகல் மற்றும் ஒட்ட வேண்டும்

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
மற்றும் id2, 3, மற்றும் 4 id1 மற்றும் பல 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 மாணவர் ஐடிக்கள் வேண்டும் மாறாக 7 இல்லை உணர வேண்டும்?

16
00:01:05,360 --> 00:01:09,570
நீங்கள், உங்கள் மூல குறியீடு மீண்டும் சென்று ஒரு id5 உள்ள சேர்க்க ஒரு id6, வேண்டும்

17
00:01:09,570 --> 00:01:14,260
ID கள் இந்த 2 புதிய ஐடிகளுக்கு வர்க்கம் சேர்ந்தவை என்றால் பரிசோதிக்கவும், தர்க்கம் நகலெடுத்து ஒட்டவும்.

18
00:01:14,260 --> 00:01:19,600
ஒன்றாக இந்த ID கள் இணைக்கும் இல்லை, அதனால் கேட்டு வழி இல்லை

19
00:01:19,600 --> 00:01:22,040
நிரல் 6 வழியாக ஐடிக்கள் 0 இந்த செய்ய.

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
நாங்கள் இருமுறை x அறிவிக்க இருந்து.

47
00:03:20,900 --> 00:03:25,140
நாம் ஒரு பிட் உள்ள அறிவிப்புக்கள் இந்த 2 வகையான இடையே வேறுபாடுகள் சில பாருங்கள் வேண்டும்.

48
00:03:25,140 --> 00:03:28,560
இந்த வரிகளை இருவரும், அளவு N அணிவரிசை பிரகடனம்

49
00:03:28,560 --> 00:03:30,740
அங்கு நாம் # 10 N வரையறுக்க வேண்டும்.

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
முன்பு எங்கள் மாணவர் அடையாள உதாரணமாக போல், இந்த முற்றிலும் தனி 10 அறிவித்தார் போன்ற வகையான உள்ளது

53
00:03:41,960 --> 00:03:49,000
கற்பனை மாறிகள்; x0, 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
நாம் x போன்ற ஏதாவது எழுத போது [3], இது நான், x அடைப்புக்குறி 3 வாசிக்கப்பட வேண்டும்

57
00:04:09,660 --> 00:04:13,090
நீங்கள் கற்பனை x3 கேட்டு போல் அதை நினைக்க முடிகிறது.

58
00:04:13,090 --> 00:04:17,519
என்று அடைப்புக்குறிக்குள் உள்ளே எண், அளவு N, அதாவது ஒரு வரிசை விட அறிவிப்பு

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 பைட்டுகள் என்று அனுமானித்து, முழு வரிசையில் x நினைவகம் ஒரு 40 பைட் தொகுதி ஆகும்.

64
00:04:37,460 --> 00:04:41,360
எனவே x0 தடுப்பு முதல் 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
நாம் இருந்து 1,600 பைட்டுகள் கிடைக்கும் Where'd? இது முழு ஒன்றுக்கு மட்டும் 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 இடத்தில், மதிப்பு 0 முறை 2 ஒதுக்க வேண்டும்.

83
00:05:58,680 --> 00:06:04,370
பின்னர் நான் அதிகரிக்கும், மற்றும் நாம் மதிப்பு 1 முறை 2 வரிசையில் முதல் இடத்தை ஒதுக்க.

84
00:06:04,370 --> 00:06:10,170
நாம் வரிசையில் N-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 x விட மாறி ஒரு பிட் நல்ல பெயர் இருந்திருக்கும்,

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
Oops. ஒருவேளை நீங்கள் இந்த பார்த்திருக்கிறேன்.

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
நமக்கு மிக மிக பெரும்பாலும் தற்செயலாக, அதற்கு பதிலாக N 10,000 போட முடியாது

102
00:07:37,690 --> 00:07:42,930
நாம் போன்ற நுட்பமான ஏதாவது செய் ஆனால் எழுத குறைவாக அல்லது N சமமாக என்ன

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
இதில் குறியீட்டு N வரிசை இறுதியில் அப்பால் உள்ளது என்று அர்த்தம்.

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
இந்த, நாம் x + அடைப்புக்குறி வகை போன்ற ஏதாவது செய்ய முடியாது

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
மாறி x தன்னை, ஸ்டாக் சேமிக்கப்படும் மற்றும் ஒரு ஒற்றை சுட்டிக்காட்டி உள்ளது

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
அதை நீங்கள் சாதனம் மட்டும் 4 பைட்டுகள் வாய்ப்பு இது மாறி x தன்னை, அளவு கொடுக்கும்.

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
நாம் குறுக்குவழி initilization பயன்படுத்தி முதல் 10 கூட முழு எழுத எப்படி என்று பார்ப்போம்.

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
>> என் பெயர் ராப் Bowden, மற்றும் இந்த CS50 உள்ளது.