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
Well మీరు 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
మేము చేస్తాము వేరియబుల్స్ Int id0, Int 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
మరియు 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 విద్యార్థి 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
కలిసి ఈ ఐడిలను కనెక్ట్ ఏమీ లేదు, అందువలన అడగడం యొక్క మార్గం లేదు

19
00:01:19,600 --> 00:01:22,040
కార్యక్రమం 6 ద్వారా ID లు 0 ఇలా.

20
00:01:22,040 --> 00:01:26,120
Well ఇప్పుడు మీరు 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
మీరు C. లో చూస్తారు కేవలం కానీ ఇక్కడ మేము ప్రాథమిక శ్రేణి డేటా నిర్మాణంపై దృష్టి చేస్తాము

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
ముందు మా విద్యార్థి ID ఉదాహరణ వలె, ఈ పూర్తిగా ప్రత్యేక 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
ఇది N సూచీలు మొత్తం ఉంది.

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
X [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
ఈ, i = 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
>> లూప్ మొదటి లో, i, 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 కంటే వేరియబుల్ కోసం bit మంచి పేరు ఉండేది,

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
మేము N వద్ద ఆగదు మొదటి లూప్ మార్చుకున్నట్లయితే కూడా ఏమి పరిశీలించి లెట్

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
మాకు చాలా కాబట్టి బహుశా అనుకోకుండా, బదులుగా N యొక్క 10,000 పెట్టి లేదు

102
00:07:37,690 --> 00:07:42,930
మేము వంటి మరింత సూక్ష్మ ఏదో ఒకటి అయితే రాసే కంటే తక్కువ లేదా N సమానంగా ఏమి చెప్పాలి

103
00:07:42,930 --> 00:07:46,830
వ్యతిరేకంగా కోసం లూప్ స్థితిలో N. కంటే తక్కువ

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
>> నా పేరు రాబ్ బౌడెన్, మరియు ఈ CS50 ఉంది.